@qvac/tts-ggml 0.12.0 → 0.14.0

package/lib/engineSetup.d.ts

@@ -0,0 +1,153 @@
+/**
+ * The state the wrapper resolves from its constructor options, grouped by
+ * responsibility. Everything that builds native parameters, validates options
+ * or applies a reload reads (and, for reloadable fields, writes) one of these
+ * groups instead of the wrapper instance itself.
+ */
+import type { EngineType } from "./engineIds";
+import type { NormalizedFiles } from "./modelFiles";
+import type { TTSConfigurationParams } from "../tts";
+export interface TTSGgmlRuntimeConfig {
+    /**
+     * Language code; default "en". Chatterbox MTL accepts
+     * es/fr/de/pt/it/zh/ja/ko/... CosyVoice3: reserved / not yet effective — the
+     * text-normalization frontend is not yet integrated, so it is accepted but
+     * not acted on.
+     */
+    language?: string;
+    /**
+     * Route inference through a GPU backend (Metal / Vulkan / OpenCL) if
+     * available. Defaults to `false`. Audio8 uses Vulkan on Linux and Windows;
+     * CosyVoice3 selects Metal on Apple, Vulkan on desktop Linux / Windows, and
+     * OpenCL/Adreno on Android (Mali / Xclipse decline to CPU); the other
+     * GPU-capable engines select a backend for the host platform.
+     */
+    useGPU?: boolean;
+    /**
+     * Desired output sample rate in Hz (8000-192000); omit to keep the engine's
+     * native rate. Resamples the native output (24 kHz for Chatterbox and
+     * CosyVoice3; 44.1 kHz for Supertonic, Parler, and Audio8), or the 48 kHz
+     * LavaSR-enhanced signal, before emitting. `TTSOutputChunk.sampleRate`
+     * reports the resulting rate.
+     *
+     * 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;
+    openclCacheDir?: string;
+    vulkanCacheDir?: string;
+}
+export interface ModelPaths {
+    voicesDir?: string;
+    supertonicModelPath?: string;
+    t3ModelPath?: string;
+    s3genModelPath?: string;
+    cosyvoiceModelDir?: string;
+    cosyvoiceLlmModelPath?: string;
+    cosyvoiceFlowModelPath?: string;
+    cosyvoiceHiftModelPath?: string;
+    cosyvoiceS3tokModelPath?: string;
+    cosyvoiceCampplusModelPath?: string;
+    cosyvoiceVocabPath?: string;
+    cosyvoiceMergesPath?: string;
+    cosyvoiceVoiceModelPath?: string;
+    parlerModelPath?: string;
+    audio8LmPath?: string;
+    audio8CodecDecoderPath?: string;
+    audio8CodecEncoderPath?: string;
+    mossBackbonePath?: string;
+    mossCodecDecoderPath?: string;
+    mossCodecEncoderPath?: string;
+    mossSoundEffectPath?: string;
+    mossSpeechModelPath?: string;
+    mossSpeechCodecPath?: string;
+    mecabDictPath?: string;
+    cangjieTsvPath?: string;
+}
+/**
+ * Synthesis options as the wrapper keeps them: aliases collapsed, the
+ * CosyVoice3 instruct rendered to its string. Reload rewrites the reloadable
+ * subset in place and rolls the whole object back when a reload is rejected.
+ */
+export interface SynthesisSettings {
+    referenceAudio?: string;
+    referenceText?: string;
+    greedy?: boolean;
+    voiceDir?: string;
+    seed?: number;
+    nGpuLayers?: number;
+    nCtx?: number;
+    kvCacheType?: "f32" | "f16" | "q8_0";
+    threads?: number;
+    streamChunkTokens?: number;
+    streamFirstChunkTokens?: number;
+    streamChunkTolerancePct?: number;
+    streamMinChunkTokens?: number;
+    streamLeftContextTokens?: number;
+    cfmSteps?: number;
+    cfgRate?: number;
+    batchCfmSteps?: number;
+    nPredict?: number;
+    maxSentenceChars?: number;
+    crossfadeMs?: number;
+    repeatPenalty?: number;
+    exaggeration?: number;
+    cfgWeight?: number;
+    minP?: number;
+    voiceJsonPath?: string;
+    prewarmText?: string;
+    vulkanDevice?: number;
+    flowCutPrompt?: boolean;
+    /** CosyVoice3-only: transcript of the reference audio for zero-shot cloning. */
+    promptText?: string;
+    /** CosyVoice3-only: the structured/raw instruct2 control, rendered to its string. */
+    instruct?: string;
+    voice?: string;
+    steps?: number;
+    speed?: number;
+    noiseNpyPath?: string;
+    /** Parler voice-description surface; the all-defaults render is the models' fallback caption. */
+    description?: string;
+    emotion?: string;
+    pitch?: string;
+    pace?: string;
+    expressivity?: string;
+    noise?: string;
+    reverb?: string;
+    quality?: string;
+    temperature?: number;
+    topK?: number;
+    topP?: number;
+    maxFrames?: number;
+    minNewTokens?: number;
+    normalizeNumbers?: boolean;
+    /** MOSS: fixed for the instance (reload rejects a change). */
+    dialogueReferences?: string[];
+    durationTokens?: number;
+}
+export interface BackendPaths {
+    enhancerGgufPath?: string;
+    denoiserGgufPath?: string;
+    backendsDir?: string;
+    openclCacheDir?: string;
+    vulkanCacheDir?: string;
+}
+export interface PocketSetup {
+    files: NormalizedFiles;
+    options: Record<string, unknown>;
+    params: TTSConfigurationParams;
+}
+export interface EngineSetup {
+    readonly engineType: EngineType;
+    readonly config: TTSGgmlRuntimeConfig;
+    /** Validated `config.outputSampleRate`; null keeps the engine's native rate. */
+    outputSampleRate: number | null;
+    readonly paths: ModelPaths;
+    readonly settings: SynthesisSettings;
+    readonly backend: BackendPaths;
+    pocket: PocketSetup | null;
+}

package/lib/engineSetup.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/engines/audio8.d.ts

@@ -0,0 +1,83 @@
+import type { TTSConfigurationParams } from "../../tts";
+import type { EngineSetup, ModelPaths } from "../engineSetup";
+import { type NormalizedFiles } from "../modelFiles";
+export declare const AUDIO8_LM_RE: RegExp;
+export declare const AUDIO8_DECODER_RE: RegExp;
+export declare const AUDIO8_ENCODER_RE: RegExp;
+export declare const AUDIO8_VOICE_KEYS: readonly ["referenceAudio", "referenceText"];
+export type Audio8VoiceKey = (typeof AUDIO8_VOICE_KEYS)[number];
+export type Audio8VoiceFieldsResolved = Partial<Record<Audio8VoiceKey, string>>;
+/**
+ * Voice cloning reference. Audio8's codec encoder turns `referenceAudio` into
+ * codes and they are prepended to the prompt as the speaker's own history, so
+ * no speaker encoder and no enrolment step are involved. `referenceText` is
+ * required alongside it there: the model conditions on it as the turn the
+ * recording answers, and a wrong one degrades the clone. Accepted at
+ * construction, on `reload()`, and per call (Audio8 only).
+ */
+export interface Audio8VoiceFields {
+    /**
+     * Chatterbox: voice-cloning reference audio path (wav). CosyVoice3:
+     * zero-shot / cross-lingual cloning reference (0.5-30 s hard limits,
+     * 5-15 s of clean speech recommended; multichannel input is downmixed to
+     * mono) — the native front-end tokenizes it (speech_tokenizer_v3),
+     * extracts the CAM++ speaker embedding and prompt mel at load, replacing
+     * the baked voice; requires the `cosyvoiceS3tokModel` +
+     * `cosyvoiceCampplusModel` files and fails the load (never silently falls
+     * back) when they are missing or the audio is unusable. Pair with
+     * `promptText` (the verbatim transcript) for zero-shot or omit it for
+     * cross-lingual. The reference is fixed at construction: `reload()`
+     * 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. 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;
+}
+/** The Audio8 sampler knobs a `reload()` may carry. */
+export interface Audio8SamplingFields {
+    greedy?: boolean;
+    temperature?: number;
+    topK?: number;
+    topP?: number;
+    maxFrames?: number;
+    seed?: number;
+    threads?: number;
+}
+/**
+ * Collect the Audio8 voice-cloning properties present on `source` (a run
+ * input, streaming options, or constructor options). Returns undefined when
+ * none are set.
+ */
+export declare function pickAudio8VoiceFields(source: Audio8VoiceFields | null | undefined): Audio8VoiceFieldsResolved | undefined;
+/**
+ * Mirrors Audio8Model::validateSampling, which stays the source of truth.
+ * Reload checks the merged knobs here because native only sees them when the
+ * instance is rebuilt: without this the refused value is already on the JS
+ * object by then, and the two would describe different samplers.
+ */
+export declare function assertAudio8SamplingValid(sampling: Audio8SamplingFields, where: string): void;
+export declare function resolveAudio8ModelPaths(files: NormalizedFiles): Pick<ModelPaths, "audio8LmPath" | "audio8CodecDecoderPath" | "audio8CodecEncoderPath">;
+/**
+ * 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
+ * both halves have to arrive together.
+ */
+export declare function assertAudio8VoiceConsistent(voice: Audio8VoiceFields, codecEncoderPath: string | undefined, where: string): void;
+export declare function assertAudio8Options(setup: EngineSetup): void;
+/**
+ * Extract + validate the per-call Audio8 voice fields from a run input or
+ * streaming options. Returns undefined when none are present.
+ */
+export declare function resolveAudio8JobFields(setup: EngineSetup, source: Audio8VoiceFields | null | undefined, where: string): Audio8VoiceFieldsResolved | undefined;
+export declare function buildAudio8Params(setup: EngineSetup): TTSConfigurationParams;
+/**
+ * Audio8 voice + sampling knobs are reloadable; they rebuild the engine's
+ * sampler and speaker history. Both merges are checked before either is
+ * written, so a rejected reload leaves the instance exactly as it was
+ * rather than half-moved onto the configuration that was refused.
+ */
+export declare function applyAudio8Reload(setup: EngineSetup, newConfig: Record<string, unknown>): void;

package/lib/engines/audio8.js

@@ -0,0 +1,262 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AUDIO8_VOICE_KEYS = exports.AUDIO8_ENCODER_RE = exports.AUDIO8_DECODER_RE = exports.AUDIO8_LM_RE = void 0;
+exports.pickAudio8VoiceFields = pickAudio8VoiceFields;
+exports.assertAudio8SamplingValid = assertAudio8SamplingValid;
+exports.resolveAudio8ModelPaths = resolveAudio8ModelPaths;
+exports.assertAudio8VoiceConsistent = assertAudio8VoiceConsistent;
+exports.assertAudio8Options = assertAudio8Options;
+exports.resolveAudio8JobFields = resolveAudio8JobFields;
+exports.buildAudio8Params = buildAudio8Params;
+exports.applyAudio8Reload = applyAudio8Reload;
+const engineIds_1 = require("../engineIds");
+const modelFiles_1 = require("../modelFiles");
+const nativeParams_1 = require("../nativeParams");
+const options_1 = require("../options");
+// Audio8 ships three GGUFs per quant tier, with the tier in the filename
+// (`audio8-lm-q8_0.gguf`); a bare `audio8-lm.gguf` matches too, as
+// forward-compat with a single-tier release.
+exports.AUDIO8_LM_RE = /^audio8-lm(-[a-z0-9_]+)?\.gguf$/i;
+exports.AUDIO8_DECODER_RE = /^audio8-codec-decoder(-[a-z0-9_]+)?\.gguf$/i;
+exports.AUDIO8_ENCODER_RE = /^audio8-codec-encoder(-[a-z0-9_]+)?\.gguf$/i;
+exports.AUDIO8_VOICE_KEYS = ["referenceAudio", "referenceText"];
+/**
+ * Collect the Audio8 voice-cloning properties present on `source` (a run
+ * input, streaming options, or constructor options). Returns undefined when
+ * none are set.
+ */
+function pickAudio8VoiceFields(source) {
+    if (source == null || typeof source !== "object")
+        return undefined;
+    const out = {};
+    let any = false;
+    for (const key of exports.AUDIO8_VOICE_KEYS) {
+        const value = source[key];
+        if (value != null && value !== "") {
+            out[key] = String(value);
+            any = true;
+        }
+    }
+    return any ? out : undefined;
+}
+const AUDIO8_NUMERIC_SAMPLING_FIELDS = [
+    "temperature",
+    "topK",
+    "topP",
+    "maxFrames",
+    "seed",
+    "threads",
+];
+function assertAudio8SamplingFinite(sampling, where) {
+    for (const field of AUDIO8_NUMERIC_SAMPLING_FIELDS) {
+        const value = sampling[field];
+        if (value === undefined || Number.isFinite(value))
+            continue;
+        throw new Error(`tts-ggml: ${where}: ${field} must be a finite number`);
+    }
+}
+function assertNotNegative(value, name, zeroMeans, where) {
+    if (value === undefined || value >= 0)
+        return;
+    throw new Error(`tts-ggml: ${where}: ${name} must be >= 0 (0 = ${zeroMeans})`);
+}
+function assertAudio8TopP(value, where) {
+    if (value === undefined || (value > 0 && value <= 1))
+        return;
+    throw new Error(`tts-ggml: ${where}: topP must be in (0, 1]`);
+}
+/**
+ * Mirrors Audio8Model::validateSampling, which stays the source of truth.
+ * Reload checks the merged knobs here because native only sees them when the
+ * instance is rebuilt: without this the refused value is already on the JS
+ * object by then, and the two would describe different samplers.
+ */
+function assertAudio8SamplingValid(sampling, where) {
+    assertAudio8SamplingFinite(sampling, where);
+    assertNotNegative(sampling.temperature, "temperature", "greedy", where);
+    assertNotNegative(sampling.topK, "topK", "no top-k cutoff", where);
+    assertNotNegative(sampling.maxFrames, "maxFrames", "engine default", where);
+    assertAudio8TopP(sampling.topP, where);
+}
+function resolveAudio8ModelPaths(files) {
+    return {
+        audio8LmPath: (0, modelFiles_1.firstNonEmpty)(files.audio8Lm, (0, modelFiles_1.findQuantRankedGguf)(files.modelDir, exports.AUDIO8_LM_RE)),
+        audio8CodecDecoderPath: (0, modelFiles_1.firstNonEmpty)(files.audio8CodecDecoder, (0, modelFiles_1.findQuantRankedGguf)(files.modelDir, exports.AUDIO8_DECODER_RE)),
+        audio8CodecEncoderPath: (0, modelFiles_1.firstNonEmpty)(files.audio8CodecEncoder, (0, modelFiles_1.findQuantRankedGguf)(files.modelDir, exports.AUDIO8_ENCODER_RE)),
+    };
+}
+/**
+ * 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
+ * both halves have to arrive together.
+ */
+function assertAudio8VoiceConsistent(voice, codecEncoderPath, where) {
+    if (!voice.referenceAudio && !voice.referenceText)
+        return;
+    if (!voice.referenceAudio) {
+        throw new Error(`tts-ggml: ${where}: referenceText needs a referenceAudio to ` +
+            "transcribe");
+    }
+    if (!voice.referenceText) {
+        throw new Error(`tts-ggml: ${where}: referenceAudio needs a referenceText saying ` +
+            "what the recording says");
+    }
+    if (!codecEncoderPath) {
+        throw new Error(`tts-ggml: ${where}: voice cloning needs the audio8 codec encoder ` +
+            "GGUF (files.audio8CodecEncoder)");
+    }
+}
+function assertAudio8Options(setup) {
+    if (setup.engineType === engineIds_1.ENGINE_AUDIO8) {
+        if (setup.backend.enhancerGgufPath || setup.backend.denoiserGgufPath) {
+            throw new Error("tts-ggml: the LavaSR enhancer/denoiser are not supported with " +
+                "the audio8 engine (native 44.1 kHz output needs no bandwidth " +
+                "extension). Drop lavasrEnhancer / lavasrDenoiser.");
+        }
+        assertAudio8VoiceConsistent({
+            referenceAudio: setup.settings.referenceAudio,
+            referenceText: setup.settings.referenceText,
+        }, setup.paths.audio8CodecEncoderPath, "constructor");
+        return;
+    }
+    const audio8Only = (0, options_1.setOptionNames)({
+        referenceText: setup.settings.referenceText,
+        greedy: setup.settings.greedy,
+    });
+    if (audio8Only.length > 0) {
+        throw new Error(`tts-ggml: ${audio8Only.join(", ")} are audio8-only options ` +
+            `(engine is ${setup.engineType})`);
+    }
+}
+/**
+ * The voice a per-call override actually synthesizes with. Mirrors
+ * Audio8Model::resolveVoice: a per-call recording replaces both halves, so
+ * it cannot inherit the configured transcript, which describes a different
+ * recording; a per-call transcript alone corrects the configured one.
+ */
+function mergeAudio8Voice(setup, fields) {
+    if (fields.referenceAudio) {
+        return {
+            referenceAudio: fields.referenceAudio,
+            referenceText: fields.referenceText,
+        };
+    }
+    return {
+        referenceAudio: setup.settings.referenceAudio,
+        referenceText: fields.referenceText ?? setup.settings.referenceText,
+    };
+}
+/**
+ * Extract + validate the per-call Audio8 voice fields from a run input or
+ * streaming options. Returns undefined when none are present.
+ */
+function resolveAudio8JobFields(setup, source, where) {
+    const fields = pickAudio8VoiceFields(source);
+    if (!fields)
+        return undefined;
+    if (setup.engineType !== engineIds_1.ENGINE_AUDIO8) {
+        throw new Error(`tts-ggml: ${where}: per-call referenceAudio/referenceText are ` +
+            `audio8-only (engine is ${setup.engineType})`);
+    }
+    assertAudio8VoiceConsistent(mergeAudio8Voice(setup, fields), setup.paths.audio8CodecEncoderPath, where);
+    return fields;
+}
+function buildAudio8Params(setup) {
+    // Backstop for callers that reach the params build by another route than
+    // the constructor or applyAudio8Reload, both of which check first.
+    assertAudio8VoiceConsistent({
+        referenceAudio: setup.settings.referenceAudio,
+        referenceText: setup.settings.referenceText,
+    }, setup.paths.audio8CodecEncoderPath, "reload");
+    const parameters = {
+        engineType: engineIds_1.ENGINE_AUDIO8,
+        audio8LmPath: setup.paths.audio8LmPath || "",
+        audio8CodecDecoderPath: setup.paths.audio8CodecDecoderPath || "",
+    };
+    if (setup.paths.audio8CodecEncoderPath) {
+        parameters.audio8CodecEncoderPath = setup.paths.audio8CodecEncoderPath;
+    }
+    if (setup.settings.referenceAudio != null) {
+        parameters.referenceAudio = setup.settings.referenceAudio;
+    }
+    if (setup.settings.referenceText != null) {
+        parameters.referenceText = setup.settings.referenceText;
+    }
+    if (setup.settings.greedy != null)
+        parameters.greedy = !!setup.settings.greedy;
+    (0, nativeParams_1.assignSamplingParams)(setup, parameters);
+    (0, nativeParams_1.assignBackendParams)(setup, parameters);
+    return parameters;
+}
+/**
+ * The voice a reload lands on. Same rule as mergeAudio8Voice and
+ * Audio8Model::resolveVoice: a new recording replaces both halves, because
+ * the configured transcript describes the recording being replaced. Reload
+ * reads `undefined` as "not supplied", so an explicit empty string reaches
+ * the guard instead of being ignored.
+ */
+function mergeAudio8ReloadVoice(setup, config) {
+    if (config.referenceAudio !== undefined) {
+        return {
+            referenceAudio: config.referenceAudio,
+            referenceText: config.referenceText,
+        };
+    }
+    return {
+        referenceAudio: setup.settings.referenceAudio,
+        referenceText: config.referenceText !== undefined
+            ? config.referenceText
+            : setup.settings.referenceText,
+    };
+}
+/**
+ * The knobs a reload lands on, merged the same way as the voice so the
+ * whole set can be checked before any of it is written.
+ */
+function mergeAudio8ReloadSampling(setup, config) {
+    return {
+        greedy: config.greedy ?? setup.settings.greedy,
+        temperature: config.temperature ?? setup.settings.temperature,
+        topK: config.topK ?? setup.settings.topK,
+        topP: config.topP ?? setup.settings.topP,
+        maxFrames: config.maxFrames ?? setup.settings.maxFrames,
+        seed: config.seed ?? setup.settings.seed,
+        threads: config.threads ?? setup.settings.threads,
+    };
+}
+function applyAudio8Sampling(setup, config) {
+    if (config.greedy !== undefined)
+        setup.settings.greedy = config.greedy;
+    if (config.temperature !== undefined) {
+        setup.settings.temperature = config.temperature;
+    }
+    if (config.topK !== undefined)
+        setup.settings.topK = config.topK;
+    if (config.topP !== undefined)
+        setup.settings.topP = config.topP;
+    if (config.maxFrames !== undefined) {
+        setup.settings.maxFrames = config.maxFrames;
+    }
+    if (config.seed !== undefined)
+        setup.settings.seed = config.seed;
+    if (config.threads !== undefined)
+        setup.settings.threads = config.threads;
+}
+/**
+ * Audio8 voice + sampling knobs are reloadable; they rebuild the engine's
+ * sampler and speaker history. Both merges are checked before either is
+ * written, so a rejected reload leaves the instance exactly as it was
+ * rather than half-moved onto the configuration that was refused.
+ */
+function applyAudio8Reload(setup, newConfig) {
+    if (setup.engineType !== engineIds_1.ENGINE_AUDIO8)
+        return;
+    const config = newConfig;
+    const voice = mergeAudio8ReloadVoice(setup, config);
+    const sampling = mergeAudio8ReloadSampling(setup, config);
+    assertAudio8VoiceConsistent(voice, setup.paths.audio8CodecEncoderPath, "reload");
+    assertAudio8SamplingValid(sampling, "reload");
+    setup.settings.referenceAudio = voice.referenceAudio;
+    setup.settings.referenceText = voice.referenceText;
+    applyAudio8Sampling(setup, sampling);
+}

package/lib/engines/chatterbox.d.ts

@@ -0,0 +1,10 @@
+import type { TTSConfigurationParams } from "../../tts";
+import type { EngineSetup, ModelPaths } from "../engineSetup";
+import { type NormalizedFiles } from "../modelFiles";
+export declare const CHATTERBOX_T3_TURBO = "chatterbox-t3-turbo.gguf";
+export declare const CHATTERBOX_T3_MTL = "chatterbox-t3-mtl.gguf";
+export declare const CHATTERBOX_S3GEN_DEFAULT = "chatterbox-s3gen.gguf";
+export declare const CHATTERBOX_S3GEN_MTL = "chatterbox-s3gen-mtl.gguf";
+export declare function hasChatterboxModelDir(modelDir: string): boolean;
+export declare function resolveChatterboxModelPaths(files: NormalizedFiles): Pick<ModelPaths, "t3ModelPath" | "s3genModelPath">;
+export declare function buildChatterboxParams(setup: EngineSetup): TTSConfigurationParams;

package/lib/engines/chatterbox.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CHATTERBOX_S3GEN_MTL = exports.CHATTERBOX_S3GEN_DEFAULT = exports.CHATTERBOX_T3_MTL = exports.CHATTERBOX_T3_TURBO = void 0;
+exports.hasChatterboxModelDir = hasChatterboxModelDir;
+exports.resolveChatterboxModelPaths = resolveChatterboxModelPaths;
+exports.buildChatterboxParams = buildChatterboxParams;
+/* eslint-disable @typescript-eslint/no-require-imports -- Bare modules expose CommonJS export shapes. */
+const path = require("bare-path");
+const engineIds_1 = require("../engineIds");
+const modelFiles_1 = require("../modelFiles");
+const nativeParams_1 = require("../nativeParams");
+exports.CHATTERBOX_T3_TURBO = "chatterbox-t3-turbo.gguf";
+exports.CHATTERBOX_T3_MTL = "chatterbox-t3-mtl.gguf";
+exports.CHATTERBOX_S3GEN_DEFAULT = "chatterbox-s3gen.gguf";
+exports.CHATTERBOX_S3GEN_MTL = "chatterbox-s3gen-mtl.gguf";
+function hasChatterboxModelDir(modelDir) {
+    return ((0, modelFiles_1.fileExistsSafe)(path.join(modelDir, exports.CHATTERBOX_T3_TURBO)) ||
+        (0, modelFiles_1.fileExistsSafe)(path.join(modelDir, exports.CHATTERBOX_T3_MTL)));
+}
+function resolveChatterboxModelDirPaths(modelDir) {
+    const turboT3 = path.join(modelDir, exports.CHATTERBOX_T3_TURBO);
+    const multilingualT3 = path.join(modelDir, exports.CHATTERBOX_T3_MTL);
+    const defaultS3 = path.join(modelDir, exports.CHATTERBOX_S3GEN_DEFAULT);
+    const multilingualS3 = path.join(modelDir, exports.CHATTERBOX_S3GEN_MTL);
+    if ((0, modelFiles_1.fileExistsSafe)(multilingualT3) &&
+        !(0, modelFiles_1.fileExistsSafe)(turboT3)) {
+        return {
+            t3: multilingualT3,
+            s3: (0, modelFiles_1.fileExistsSafe)(multilingualS3)
+                ? multilingualS3
+                : defaultS3,
+        };
+    }
+    return { t3: turboT3, s3: defaultS3 };
+}
+function resolveChatterboxModelPaths(files) {
+    if (!files.modelDir) {
+        return { t3ModelPath: files.t3Model, s3genModelPath: files.s3genModel };
+    }
+    const resolved = resolveChatterboxModelDirPaths(files.modelDir);
+    return {
+        t3ModelPath: (0, modelFiles_1.firstNonEmpty)(files.t3Model, resolved.t3),
+        s3genModelPath: (0, modelFiles_1.firstNonEmpty)(files.s3genModel, resolved.s3),
+    };
+}
+function buildChatterboxParams(setup) {
+    const parameters = {
+        engineType: engineIds_1.ENGINE_CHATTERBOX,
+        t3ModelPath: setup.paths.t3ModelPath || "",
+        s3genModelPath: setup.paths.s3genModelPath || "",
+        language: setup.config.language || "en",
+    };
+    (0, nativeParams_1.assignCommonNativeParams)(setup, parameters);
+    if (setup.settings.referenceAudio != null) {
+        parameters.referenceAudio = setup.settings.referenceAudio;
+    }
+    if (setup.settings.voiceDir != null)
+        parameters.voiceDir = setup.settings.voiceDir;
+    if (setup.settings.nCtx != null)
+        parameters.nCtx = setup.settings.nCtx | 0;
+    if (setup.settings.kvCacheType != null) {
+        parameters.kvCacheType = String(setup.settings.kvCacheType);
+    }
+    if (setup.settings.streamChunkTokens != null) {
+        parameters.streamChunkTokens = setup.settings.streamChunkTokens | 0;
+    }
+    if (setup.settings.streamFirstChunkTokens != null) {
+        parameters.streamFirstChunkTokens =
+            setup.settings.streamFirstChunkTokens | 0;
+    }
+    if (setup.settings.cfmSteps != null) {
+        parameters.cfmSteps = setup.settings.cfmSteps | 0;
+    }
+    if (setup.settings.streamLeftContextTokens != null) {
+        parameters.streamLeftContextTokens = setup.settings.streamLeftContextTokens | 0;
+    }
+    if (setup.settings.batchCfmSteps != null) {
+        parameters.batchCfmSteps = setup.settings.batchCfmSteps | 0;
+    }
+    if (setup.settings.cfgRate != null) {
+        parameters.cfgRate = Number(setup.settings.cfgRate);
+    }
+    if (setup.settings.nPredict != null)
+        parameters.nPredict = setup.settings.nPredict | 0;
+    if (setup.settings.maxSentenceChars != null) {
+        parameters.maxSentenceChars = setup.settings.maxSentenceChars | 0;
+    }
+    if (setup.settings.crossfadeMs != null) {
+        parameters.crossfadeMs = setup.settings.crossfadeMs | 0;
+    }
+    (0, nativeParams_1.assignSamplingParams)(setup, parameters);
+    if (setup.settings.repeatPenalty != null) {
+        parameters.repeatPenalty = Number(setup.settings.repeatPenalty);
+    }
+    if (setup.settings.exaggeration != null) {
+        parameters.exaggeration = Number(setup.settings.exaggeration);
+    }
+    if (setup.settings.cfgWeight != null) {
+        parameters.cfgWeight = Number(setup.settings.cfgWeight);
+    }
+    if (setup.settings.minP != null)
+        parameters.minP = Number(setup.settings.minP);
+    if (setup.settings.speed != null)
+        parameters.speed = Number(setup.settings.speed);
+    if (setup.paths.mecabDictPath) {
+        parameters.mecabDictPath = setup.paths.mecabDictPath;
+    }
+    if (setup.paths.cangjieTsvPath) {
+        parameters.cangjieTsvPath = setup.paths.cangjieTsvPath;
+    }
+    return parameters;
+}