@qvac/tts-ggml 0.13.0 → 0.14.1

package/lib/addonEvents.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Native output callbacks, routed to the job handler and the sentence stream:
+ * an error fails the job, audio goes out as output (enriched while a sentence
+ * stream is active) and stats end the job unless the stream consumes them.
+ */
+import type { JobHandler } from "@qvac/infer-base";
+import type QvacLoggerType from "@qvac/logging";
+import { type SentenceStreamer } from "./sentenceStream";
+import type { NativeStats, RuntimeStats } from "./types";
+export interface AddonEventHost {
+    readonly job: JobHandler;
+    readonly stream: SentenceStreamer;
+    logger(): QvacLoggerType;
+    /** Whether stats reach the response (`opts.stats`). */
+    reportStats(): boolean;
+}
+export declare class AddonEventRouter {
+    private readonly host;
+    constructor(host: AddonEventHost);
+    route(event: unknown, data: unknown, error: unknown): void;
+    /** Ends the job, forwarding the stats only when the caller asked for them. */
+    endJob(stats: RuntimeStats | NativeStats): void;
+    private onError;
+    private onOutput;
+    private onStats;
+}

package/lib/addonEvents.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AddonEventRouter = void 0;
+const sentenceStream_1 = require("./sentenceStream");
+class AddonEventRouter {
+    host;
+    constructor(host) {
+        this.host = host;
+    }
+    route(event, data, error) {
+        if (typeof error === "string" && error.length > 0)
+            this.onError(error);
+        else if ((0, sentenceStream_1.isAudioOutputEvent)(data))
+            this.onOutput(data);
+        else if ((0, sentenceStream_1.isStatsEvent)(data))
+            this.onStats(data);
+        else
+            this.host.logger().debug(`Received TTS event: ${String(event)}`);
+    }
+    /** Ends the job, forwarding the stats only when the caller asked for them. */
+    endJob(stats) {
+        if (this.host.reportStats())
+            this.host.job.end(stats);
+        else
+            this.host.job.end();
+    }
+    onError(error) {
+        this.host.logger().error(`TTS job failed with error: ${error}`);
+        this.host.stream.rejectActiveChunk(new Error(error));
+        this.host.job.fail(error);
+    }
+    onOutput(data) {
+        const logger = this.host.logger();
+        try {
+            logger.debug(`TTS job produced output: ${(0, sentenceStream_1.ttsOutputDebugString)(data)}`);
+        }
+        catch (error) {
+            if (!(error instanceof RangeError))
+                throw error;
+            logger.debug("TTS job produced output: [data too large]");
+        }
+        const { stream } = this.host;
+        this.host.job.output(stream.ctx ? stream.enrich(data) : data);
+    }
+    onStats(data) {
+        this.host.logger().info(`TTS job completed. Stats: ${JSON.stringify(data)}`);
+        if (!this.host.stream.onStats(data))
+            this.endJob(data);
+    }
+}
+exports.AddonEventRouter = AddonEventRouter;

package/lib/conditioning.d.ts

@@ -0,0 +1,50 @@
+import { type EngineType } from "./engineIds";
+import type { EngineSetup } from "./engineSetup";
+export declare const EMOTIONS: readonly ["command", "anger", "narration", "conversation", "disgust", "fear", "happy", "neutral", "proper noun", "news", "sad", "surprise"];
+export declare const PACES: readonly ["slow", "moderate", "fast"];
+export type Emotion = (typeof EMOTIONS)[number];
+export type Pace = (typeof PACES)[number];
+export declare const CONDITIONING_KEYS: readonly ["emotion", "pace"];
+export type ConditioningKey = (typeof CONDITIONING_KEYS)[number];
+export type ConditioningFields = Partial<Record<ConditioningKey, string>>;
+/**
+ * Cross-engine conditioning. Accepted at construction and on `reload()` by
+ * every engine that supports them, and per call by Parler and CosyVoice3. A
+ * value outside the canonical vocabulary, outside the engine's supported
+ * subset, or on a channel the engine cannot change per call, throws naming the
+ * alternative -- nothing is silently degraded.
+ */
+export interface TTSConditioningFields {
+    /** Speaking style. Parler: all 12. CosyVoice3: anger|happy|neutral|sad. */
+    emotion?: Emotion;
+    /**
+     * Speaking rate. Parler / CosyVoice3 / Supertonic. Supertonic conditions its
+     * engine at construction, so its pace only moves there or via `reload()`.
+     */
+    pace?: Pace;
+}
+/** Collect the cross-engine conditioning properties present on `source`. */
+export declare function pickConditioningFields(source: TTSConditioningFields | null | undefined): ConditioningFields | undefined;
+export declare function assertCanonicalValue(value: string, canonical: readonly string[], kind: string): void;
+export declare function supportedValues(engine: EngineType, kind: ConditioningKey): readonly ("command" | "anger" | "narration" | "conversation" | "disgust" | "fear" | "happy" | "neutral" | "proper noun" | "news" | "sad" | "surprise")[] | readonly ("slow" | "moderate" | "fast")[];
+export declare function assertEngineSupports(engine: EngineType, kind: ConditioningKey, value: string): void;
+/**
+ * Validate emotion/pace against the canonical vocabulary first (so a typo reads
+ * clearly), then against what this engine actually supports.
+ */
+export declare function validateConditioning(engine: EngineType, fields: ConditioningFields | undefined): void;
+/**
+ * Reject a channel the engine supports but cannot change per call, so it is
+ * never accepted here and then dropped on the way to the engine. Runs after
+ * validateConditioning so an engine with no such control keeps its own message.
+ */
+export declare function assertPerCallConditioning(engine: EngineType, fields: ConditioningFields | undefined, where: string): void;
+export declare const COSYVOICE_DISENGAGED: Record<string, string>;
+export declare function engagedCosyvoiceControls(fields: ConditioningFields | undefined, instruct: string | undefined): string[];
+export declare function assertSingleCosyvoiceControl(fields: ConditioningFields | undefined, instruct: string | undefined, where: string): void;
+/**
+ * Validate the configured emotion/pace against this engine, and enforce
+ * CosyVoice3's one-instruction-per-synthesis rule. Runs at construction and
+ * again after a reload rewrites either channel.
+ */
+export declare function assertConditioningConsistency(setup: EngineSetup, where: string): void;

package/lib/conditioning.js

@@ -0,0 +1,184 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.COSYVOICE_DISENGAGED = exports.CONDITIONING_KEYS = exports.PACES = exports.EMOTIONS = void 0;
+exports.pickConditioningFields = pickConditioningFields;
+exports.assertCanonicalValue = assertCanonicalValue;
+exports.supportedValues = supportedValues;
+exports.assertEngineSupports = assertEngineSupports;
+exports.validateConditioning = validateConditioning;
+exports.assertPerCallConditioning = assertPerCallConditioning;
+exports.engagedCosyvoiceControls = engagedCosyvoiceControls;
+exports.assertSingleCosyvoiceControl = assertSingleCosyvoiceControl;
+exports.assertConditioningConsistency = assertConditioningConsistency;
+const engineIds_1 = require("./engineIds");
+// Canonical cross-engine conditioning vocabulary. This is a MIRROR, not the
+// source of truth: tts-cpp owns it in include/tts-cpp/voice_controls.h, and
+// test/unit/voice-controls.test.js pins this copy against the native lists.
+exports.EMOTIONS = [
+    "command",
+    "anger",
+    "narration",
+    "conversation",
+    "disgust",
+    "fear",
+    "happy",
+    "neutral",
+    "proper noun",
+    "news",
+    "sad",
+    "surprise",
+];
+exports.PACES = ["slow", "moderate", "fast"];
+exports.CONDITIONING_KEYS = ["emotion", "pace"];
+// Per-engine supported subsets, mirroring controls::supported_emotions() /
+// supported_paces(). An empty list means the engine has no such control.
+const ENGINE_EMOTIONS = {
+    [engineIds_1.ENGINE_PARLER]: exports.EMOTIONS,
+    // Only the emotions Fun-CosyVoice3 has a trained instruction for; the rest,
+    // and the upstream spelling "angry", are rejected rather than paraphrased.
+    [engineIds_1.ENGINE_COSYVOICE3]: ["anger", "happy", "neutral", "sad"],
+    [engineIds_1.ENGINE_SUPERTONIC]: [],
+    [engineIds_1.ENGINE_CHATTERBOX]: [],
+    [engineIds_1.ENGINE_POCKET]: [],
+    [engineIds_1.ENGINE_AUDIO8]: [],
+    [engineIds_1.ENGINE_MOSS]: [],
+    [engineIds_1.ENGINE_MOSS_SFX]: [],
+    [engineIds_1.ENGINE_MOSS_SPEECH]: [],
+};
+const ENGINE_PACES = {
+    [engineIds_1.ENGINE_PARLER]: exports.PACES, // rendered into the training caption
+    [engineIds_1.ENGINE_COSYVOICE3]: exports.PACES, // slow/fast -> instruct; moderate -> none
+    [engineIds_1.ENGINE_SUPERTONIC]: exports.PACES, // mapped onto the duration multiplier
+    [engineIds_1.ENGINE_CHATTERBOX]: [], // time-stretch only; use `speed`
+    [engineIds_1.ENGINE_POCKET]: [],
+    [engineIds_1.ENGINE_AUDIO8]: [], // no rate control at all
+    [engineIds_1.ENGINE_MOSS]: [],
+    [engineIds_1.ENGINE_MOSS_SFX]: [],
+    [engineIds_1.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
+// per-call surface for it, so it only moves at construction or reload().
+// tts-cpp engine names (tts-cpp/voice_controls.h engine_name) that differ from
+const ENGINE_PER_CALL_CONDITIONING = {
+    [engineIds_1.ENGINE_PARLER]: exports.CONDITIONING_KEYS,
+    [engineIds_1.ENGINE_COSYVOICE3]: exports.CONDITIONING_KEYS,
+    [engineIds_1.ENGINE_SUPERTONIC]: [],
+    [engineIds_1.ENGINE_CHATTERBOX]: [],
+    [engineIds_1.ENGINE_POCKET]: [],
+    [engineIds_1.ENGINE_AUDIO8]: [],
+    [engineIds_1.ENGINE_MOSS]: [],
+    [engineIds_1.ENGINE_MOSS_SFX]: [],
+    [engineIds_1.ENGINE_MOSS_SPEECH]: [],
+};
+/** Collect the cross-engine conditioning properties present on `source`. */
+function pickConditioningFields(source) {
+    if (source == null || typeof source !== "object")
+        return undefined;
+    const out = {};
+    let any = false;
+    for (const key of exports.CONDITIONING_KEYS) {
+        const value = source[key];
+        if (value != null && value !== "") {
+            out[key] = value;
+            any = true;
+        }
+    }
+    return any ? out : undefined;
+}
+function assertCanonicalValue(value, canonical, kind) {
+    if (canonical.includes(value.toLowerCase()))
+        return;
+    throw new Error(`tts-ggml: invalid ${kind} "${value}". ` +
+        `Valid ${kind}s: ${canonical.join(", ")}.`);
+}
+function supportedValues(engine, kind) {
+    return kind === "emotion" ? ENGINE_EMOTIONS[engine] : ENGINE_PACES[engine];
+}
+function assertEngineSupports(engine, kind, value) {
+    const supported = supportedValues(engine, kind);
+    if (supported.length === 0) {
+        const hint = kind === "pace"
+            ? "; use `speed` (an exact multiplier) instead"
+            : "";
+        throw new Error(`tts-ggml: the ${engine} engine does not support \`${kind}\`${hint}`);
+    }
+    if (supported.includes(value.toLowerCase()))
+        return;
+    throw new Error(`tts-ggml: ${kind} "${value}" is not supported by the ${engine} engine. ` +
+        `${engine} supports: ${supported.join(", ")}.`);
+}
+/**
+ * Validate emotion/pace against the canonical vocabulary first (so a typo reads
+ * clearly), then against what this engine actually supports.
+ */
+function validateConditioning(engine, fields) {
+    if (!fields)
+        return;
+    if (fields.emotion != null) {
+        assertCanonicalValue(fields.emotion, exports.EMOTIONS, "emotion");
+        assertEngineSupports(engine, "emotion", fields.emotion);
+    }
+    if (fields.pace != null) {
+        assertCanonicalValue(fields.pace, exports.PACES, "pace");
+        assertEngineSupports(engine, "pace", fields.pace);
+    }
+}
+/**
+ * Reject a channel the engine supports but cannot change per call, so it is
+ * never accepted here and then dropped on the way to the engine. Runs after
+ * validateConditioning so an engine with no such control keeps its own message.
+ */
+function assertPerCallConditioning(engine, fields, where) {
+    if (!fields)
+        return;
+    const perCall = ENGINE_PER_CALL_CONDITIONING[engine];
+    const fixed = exports.CONDITIONING_KEYS.filter((key) => fields[key] != null && !perCall.includes(key));
+    if (fixed.length === 0)
+        return;
+    throw new Error(`tts-ggml: ${where}: ${engine} applies ` +
+        `${fixed.map((key) => `\`${key}\``).join(", ")} when the engine is ` +
+        `built, so it cannot change per call; set it in the constructor or ` +
+        `reload({ ${fixed.join(", ")} })`);
+}
+// CosyVoice3 is trained on one instruction per synthesis. Only `pace: moderate`
+// resolves to no instruction, so it is the one value that never conflicts; every
+// emotion carries a trained instruction, `neutral` included.
+exports.COSYVOICE_DISENGAGED = {
+    pace: "moderate",
+};
+function engagedCosyvoiceControls(fields, instruct) {
+    const engaged = [];
+    for (const key of exports.CONDITIONING_KEYS) {
+        const value = fields?.[key];
+        if (value != null && value.toLowerCase() !== exports.COSYVOICE_DISENGAGED[key]) {
+            engaged.push(`${key}="${value}"`);
+        }
+    }
+    if (instruct != null && instruct !== "")
+        engaged.push("instruct");
+    return engaged;
+}
+function assertSingleCosyvoiceControl(fields, instruct, where) {
+    const engaged = engagedCosyvoiceControls(fields, instruct);
+    if (engaged.length <= 1)
+        return;
+    throw new Error(`tts-ggml: ${where}: conflicting conditioning controls ` +
+        `(${engaged.join(", ")}); cosyvoice3 is trained on one instruction per ` +
+        `synthesis -- set exactly one (pace="moderate" disengages a channel)`);
+}
+/**
+ * Validate the configured emotion/pace against this engine, and enforce
+ * CosyVoice3's one-instruction-per-synthesis rule. Runs at construction and
+ * again after a reload rewrites either channel.
+ */
+function assertConditioningConsistency(setup, where) {
+    const fields = pickConditioningFields({
+        emotion: setup.settings.emotion,
+        pace: setup.settings.pace,
+    });
+    validateConditioning(setup.engineType, fields);
+    if (setup.engineType === engineIds_1.ENGINE_COSYVOICE3) {
+        assertSingleCosyvoiceControl(fields, setup.settings.instruct, where);
+    }
+}

package/lib/engineDetection.d.ts

@@ -0,0 +1,14 @@
+import { type EngineType } from "./engineIds";
+import type { ModelPaths } from "./engineSetup";
+import { type NormalizedFiles } from "./modelFiles";
+export declare function detectEngineType(engine: EngineType | undefined, files: NormalizedFiles): EngineType;
+/** The constructor options that name dictionary files directly. */
+export interface ModelPathOptions {
+    mecabDictPath?: string;
+    mecabDictDir?: string;
+    cangjieTsvPath?: string;
+    /** MOSS dialogue mode, which narrows the backbone discovered under `modelDir`. */
+    dialogue: boolean;
+}
+/** The model files `engineType` loads: explicit paths first, then `modelDir`. */
+export declare function resolveModelPaths(engineType: EngineType, files: NormalizedFiles, options: ModelPathOptions): ModelPaths;

package/lib/engineDetection.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectEngineType = detectEngineType;
+exports.resolveModelPaths = resolveModelPaths;
+/**
+ * Engine discovery: which engine a `files` object selects, and the model paths
+ * that engine loads. Precedence: an explicit `engine` option, then explicit
+ * per-engine file keys, then the contents of a shared `modelDir`.
+ */
+/* eslint-disable @typescript-eslint/no-require-imports -- Bare modules expose CommonJS export shapes. */
+const path = require("bare-path");
+/* eslint-enable @typescript-eslint/no-require-imports */
+const engineIds_1 = require("./engineIds");
+const audio8_1 = require("./engines/audio8");
+const chatterbox_1 = require("./engines/chatterbox");
+const cosyvoice_1 = require("./engines/cosyvoice");
+const moss_1 = require("./engines/moss");
+const mossSoundEffect_1 = require("./engines/mossSoundEffect");
+const mossSpeech_1 = require("./engines/mossSpeech");
+const parler_1 = require("./engines/parler");
+const supertonic_1 = require("./engines/supertonic");
+const modelFiles_1 = require("./modelFiles");
+const POCKET_FLOW_LM = "flow-lm.gguf";
+function detectEngineType(engine, files) {
+    if ((0, engineIds_1.isEngineType)(engine))
+        return engine;
+    if (engine != null && engine !== "") {
+        throw new Error("tts-ggml: 'engine' option must be 'chatterbox', 'supertonic', " +
+            `'cosyvoice3', 'parler', 'audio8', 'moss', 'moss-sfx', 'moss-speech' or 'pocket' (got '${String(engine)}')`);
+    }
+    return (engineFromExplicitFiles(files) ??
+        (files.modelDir ? engineFromModelDir(files.modelDir) : undefined) ??
+        engineIds_1.ENGINE_CHATTERBOX);
+}
+/** Explicit per-engine file keys, in precedence order. */
+function engineFromExplicitFiles(files) {
+    if (files.pocketFlowModel || files.pocketMimiModel)
+        return engineIds_1.ENGINE_POCKET;
+    // Explicit CosyVoice3 files/dir take precedence over shared-modelDir sniffing.
+    if (files.cosyvoiceModelDir || files.cosyvoiceLlmModel) {
+        return engineIds_1.ENGINE_COSYVOICE3;
+    }
+    if (files.t3Model || files.s3genModel)
+        return engineIds_1.ENGINE_CHATTERBOX;
+    if (files.supertonicModel)
+        return engineIds_1.ENGINE_SUPERTONIC;
+    if (files.parlerModel)
+        return engineIds_1.ENGINE_PARLER;
+    if (files.audio8Lm || files.audio8CodecDecoder)
+        return engineIds_1.ENGINE_AUDIO8;
+    if (files.mossBackbone || files.mossCodecDecoder)
+        return engineIds_1.ENGINE_MOSS;
+    if (files.mossSoundEffect)
+        return engineIds_1.ENGINE_MOSS_SFX;
+    if (files.mossSpeechModel || files.mossSpeechCodec)
+        return engineIds_1.ENGINE_MOSS_SPEECH;
+    return undefined;
+}
+/** What a shared `modelDir` holds, in precedence order. */
+function engineFromModelDir(modelDir) {
+    if ((0, cosyvoice_1.dirHasCosyvoice3)(modelDir))
+        return engineIds_1.ENGINE_COSYVOICE3;
+    if ((0, chatterbox_1.hasChatterboxModelDir)(modelDir))
+        return engineIds_1.ENGINE_CHATTERBOX;
+    if ((0, supertonic_1.hasSupertonicModelDir)(modelDir))
+        return engineIds_1.ENGINE_SUPERTONIC;
+    if ((0, parler_1.findParlerInDir)(modelDir))
+        return engineIds_1.ENGINE_PARLER;
+    if ((0, modelFiles_1.findQuantRankedGguf)(modelDir, audio8_1.AUDIO8_LM_RE))
+        return engineIds_1.ENGINE_AUDIO8;
+    if ((0, modelFiles_1.findQuantRankedGguf)(modelDir, moss_1.MOSS_BACKBONE_RE))
+        return engineIds_1.ENGINE_MOSS;
+    if ((0, modelFiles_1.findQuantRankedGguf)(modelDir, moss_1.MOSS_DIALOGUE_BACKBONE_RE))
+        return engineIds_1.ENGINE_MOSS;
+    if ((0, modelFiles_1.findQuantRankedGguf)(modelDir, mossSoundEffect_1.MOSS_SFX_RE))
+        return engineIds_1.ENGINE_MOSS_SFX;
+    if ((0, modelFiles_1.findQuantRankedGguf)(modelDir, mossSpeech_1.MOSS_SPEECH_RE))
+        return engineIds_1.ENGINE_MOSS_SPEECH;
+    if ((0, modelFiles_1.fileExistsSafe)(path.join(modelDir, POCKET_FLOW_LM)))
+        return engineIds_1.ENGINE_POCKET;
+    return undefined;
+}
+/** The model files `engineType` loads: explicit paths first, then `modelDir`. */
+function resolveModelPaths(engineType, files, options) {
+    const shared = {
+        voicesDir: files.voicesDir,
+        mecabDictPath: (0, modelFiles_1.firstNonEmpty)(options.mecabDictPath, options.mecabDictDir, files.mecabDictDir),
+        cangjieTsvPath: (0, modelFiles_1.firstNonEmpty)(options.cangjieTsvPath, files.cangjieTsvPath),
+    };
+    switch (engineType) {
+        case engineIds_1.ENGINE_POCKET:
+            return shared;
+        case engineIds_1.ENGINE_COSYVOICE3:
+            return { ...shared, ...(0, cosyvoice_1.resolveCosyvoiceModelPaths)(files) };
+        case engineIds_1.ENGINE_SUPERTONIC:
+            return { ...shared, ...(0, supertonic_1.resolveSupertonicModelPaths)(files) };
+        case engineIds_1.ENGINE_PARLER:
+            return { ...shared, ...(0, parler_1.resolveParlerModelPaths)(files) };
+        case engineIds_1.ENGINE_AUDIO8:
+            return { ...shared, ...(0, audio8_1.resolveAudio8ModelPaths)(files) };
+        case engineIds_1.ENGINE_MOSS:
+            return { ...shared, ...(0, moss_1.resolveMossModelPaths)(files, options.dialogue) };
+        case engineIds_1.ENGINE_MOSS_SFX:
+            return { ...shared, ...(0, mossSoundEffect_1.resolveMossSoundEffectModelPaths)(files) };
+        case engineIds_1.ENGINE_MOSS_SPEECH:
+            return { ...shared, ...(0, mossSpeech_1.resolveMossSpeechModelPaths)(files) };
+        default:
+            return { ...shared, ...(0, chatterbox_1.resolveChatterboxModelPaths)(files) };
+    }
+}

package/lib/engineIds.d.ts

@@ -0,0 +1,15 @@
+export declare const ENGINE_CHATTERBOX = "chatterbox";
+export declare const ENGINE_SUPERTONIC = "supertonic";
+export declare const ENGINE_COSYVOICE3 = "cosyvoice3";
+export declare const ENGINE_PARLER = "parler";
+export declare const ENGINE_AUDIO8 = "audio8";
+export declare const ENGINE_MOSS = "moss";
+export declare const ENGINE_MOSS_SFX = "moss-sfx";
+export declare const ENGINE_MOSS_SPEECH = "moss-speech";
+export declare const ENGINE_POCKET = "pocket";
+export type EngineType = typeof ENGINE_CHATTERBOX | typeof ENGINE_SUPERTONIC | typeof ENGINE_COSYVOICE3 | typeof ENGINE_PARLER | typeof ENGINE_AUDIO8 | typeof ENGINE_MOSS | typeof ENGINE_MOSS_SFX | typeof ENGINE_MOSS_SPEECH | typeof ENGINE_POCKET;
+export declare const ENGINE_TYPES: readonly EngineType[];
+export declare function isEngineType(value: unknown): value is EngineType;
+/** Engines that draw tokens, and so accept temperature / topK / topP / maxFrames. */
+export declare const SAMPLING_ENGINES: readonly string[];
+export declare const FABRIC_ENGINE_TYPES: Record<string, EngineType>;

package/lib/engineIds.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FABRIC_ENGINE_TYPES = exports.SAMPLING_ENGINES = exports.ENGINE_TYPES = exports.ENGINE_POCKET = exports.ENGINE_MOSS_SPEECH = exports.ENGINE_MOSS_SFX = exports.ENGINE_MOSS = exports.ENGINE_AUDIO8 = exports.ENGINE_PARLER = exports.ENGINE_COSYVOICE3 = exports.ENGINE_SUPERTONIC = exports.ENGINE_CHATTERBOX = void 0;
+exports.isEngineType = isEngineType;
+exports.ENGINE_CHATTERBOX = "chatterbox";
+exports.ENGINE_SUPERTONIC = "supertonic";
+// CosyVoice3 (Fun-CosyVoice3-0.5B / 1.5B). Ships as a small set of GGUFs
+// (cosyvoice3-{llm,flow,hift}-*.gguf) plus voice.gguf, vocab.json and
+// merges.txt; a modelDir holding them (or an explicit
+// `files.cosyvoiceModelDir`) routes here.
+exports.ENGINE_COSYVOICE3 = "cosyvoice3";
+exports.ENGINE_PARLER = "parler";
+exports.ENGINE_AUDIO8 = "audio8";
+exports.ENGINE_MOSS = "moss";
+exports.ENGINE_MOSS_SFX = "moss-sfx";
+exports.ENGINE_MOSS_SPEECH = "moss-speech";
+exports.ENGINE_POCKET = "pocket";
+exports.ENGINE_TYPES = [
+    exports.ENGINE_CHATTERBOX,
+    exports.ENGINE_SUPERTONIC,
+    exports.ENGINE_COSYVOICE3,
+    exports.ENGINE_PARLER,
+    exports.ENGINE_AUDIO8,
+    exports.ENGINE_MOSS,
+    exports.ENGINE_MOSS_SFX,
+    exports.ENGINE_MOSS_SPEECH,
+    exports.ENGINE_POCKET,
+];
+function isEngineType(value) {
+    return (typeof value === "string" &&
+        exports.ENGINE_TYPES.includes(value));
+}
+/** Engines that draw tokens, and so accept temperature / topK / topP / maxFrames. */
+exports.SAMPLING_ENGINES = [exports.ENGINE_PARLER, exports.ENGINE_AUDIO8];
+// tts-cpp engine names (tts-cpp/voice_controls.h engine_name) that differ from
+// this package's engine types.
+exports.FABRIC_ENGINE_TYPES = {
+    cosyvoice: exports.ENGINE_COSYVOICE3,
+};

package/lib/engineParams.d.ts

@@ -0,0 +1,3 @@
+import type { TTSConfigurationParams } from "../tts";
+import type { EngineSetup } from "./engineSetup";
+export declare function buildNativeParams(setup: EngineSetup): TTSConfigurationParams;

package/lib/engineParams.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildNativeParams = buildNativeParams;
+const engineIds_1 = require("./engineIds");
+const audio8_1 = require("./engines/audio8");
+const chatterbox_1 = require("./engines/chatterbox");
+const cosyvoice_1 = require("./engines/cosyvoice");
+const moss_1 = require("./engines/moss");
+const mossSoundEffect_1 = require("./engines/mossSoundEffect");
+const mossSpeech_1 = require("./engines/mossSpeech");
+const parler_1 = require("./engines/parler");
+const supertonic_1 = require("./engines/supertonic");
+function buildNativeParams(setup) {
+    if (setup.pocket)
+        return { ...setup.pocket.params };
+    switch (setup.engineType) {
+        case engineIds_1.ENGINE_SUPERTONIC:
+            return (0, supertonic_1.buildSupertonicParams)(setup);
+        case engineIds_1.ENGINE_COSYVOICE3:
+            return (0, cosyvoice_1.buildCosyvoiceParams)(setup);
+        case engineIds_1.ENGINE_PARLER:
+            return (0, parler_1.buildParlerParams)(setup);
+        case engineIds_1.ENGINE_AUDIO8:
+            return (0, audio8_1.buildAudio8Params)(setup);
+        case engineIds_1.ENGINE_MOSS:
+            return (0, moss_1.buildMossParams)(setup);
+        case engineIds_1.ENGINE_MOSS_SFX:
+            return (0, mossSoundEffect_1.buildMossSoundEffectParams)(setup);
+        case engineIds_1.ENGINE_MOSS_SPEECH:
+            return (0, mossSpeech_1.buildMossSpeechParams)(setup);
+        default:
+            return (0, chatterbox_1.buildChatterboxParams)(setup);
+    }
+}