@qvac/tts-ggml 0.9.2 → 0.10.1

package/lib/fit.d.ts

@@ -0,0 +1,127 @@
+/**
+ * Settings every voice takes, spelled as `createInstance` takes them. A fit
+ * request is a load config plus the workload below, so the projection reads
+ * the same keys and applies the same defaults as the load it describes.
+ */
+interface TtsFitCommon {
+    /** Layers to offload. Unset defers to `useGPU`. */
+    nGpuLayers?: number;
+    /** All layers or none, when `nGpuLayers` is unset. */
+    useGPU?: boolean;
+    vulkanDevice?: number;
+    backendsDir?: string;
+    /** LavaSR enhancer; a non-empty path turns enhancement on. */
+    lavasrEnhancerPath?: string;
+    /** LavaSR denoiser, applied before the enhancer. */
+    lavasrDenoiserPath?: string;
+    /** Free memory that must remain for the projection to count as fitting. Defaults to 256 MiB. */
+    marginBytes?: number;
+}
+export interface SupertonicFitRequest extends TtsFitCommon {
+    engineType: 'supertonic';
+    supertonicModelPath: string;
+    /** `auto` | `f32` | `f16` | `q8_0`; changes the weight footprint. */
+    precision?: 'auto' | 'f32' | 'f16' | 'q8_0';
+    /** -1 auto, 0 off, 1 on. */
+    f16Weights?: number;
+    /** 0 takes the GGUF's own default. */
+    steps?: number;
+    textTokens?: number;
+    audioSeconds?: number;
+}
+export interface ParlerFitRequest extends TtsFitCommon {
+    engineType: 'parler';
+    parlerModelPath: string;
+    descriptionTokens?: number;
+    promptTokens?: number;
+    /** 0 takes the checkpoint's default generation length. */
+    maxFrames?: number;
+}
+export interface ChatterboxFitRequest extends TtsFitCommon {
+    engineType: 'chatterbox';
+    t3ModelPath: string;
+    s3genModelPath: string;
+    nCtx?: number;
+    kvCacheType?: 'f32' | 'f16' | 'q8_0';
+    textTokens?: number;
+    predictTokens?: number;
+}
+export interface Audio8FitRequest extends TtsFitCommon {
+    engineType: 'audio8';
+    audio8LmPath: string;
+    audio8CodecDecoderPath: string;
+    /** Supplying it projects voice cloning, which the decoder alone cannot do. */
+    audio8CodecEncoderPath?: string;
+    promptTokens?: number;
+    maxFrames?: number;
+    referenceSeconds?: number;
+}
+export interface CosyvoiceFitRequest extends TtsFitCommon {
+    engineType: 'cosyvoice3';
+    cosyvoiceLlmModelPath: string;
+    cosyvoiceFlowModelPath: string;
+    cosyvoiceHiftModelPath: string;
+    cosyvoiceVoiceModelPath: string;
+    textTokens?: number;
+    /** 0 derives the runtime cap from the text length. */
+    speechTokens?: number;
+}
+export interface MossFitRequest extends TtsFitCommon {
+    engineType: 'moss';
+    mossBackbonePath: string;
+    mossCodecDecoderPath?: string;
+    mossCodecEncoderPath?: string;
+}
+export type TtsFitRequest = SupertonicFitRequest | ParlerFitRequest | ChatterboxFitRequest | Audio8FitRequest | CosyvoiceFitRequest | MossFitRequest;
+/** 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';
+export interface TtsFitResult {
+    status: TtsFitStatus;
+    /**
+     * The engine's own wording, e.g. `model-unreadable`, `workload-too-large`.
+     * `unsupported-engine` names a voice the addon loads and the fitter does
+     * not cover.
+     */
+    reason: string;
+    /** Which pipeline was projected, e.g. `chatterbox-t3-turbo`. */
+    modelVariant: string;
+    deviceName: string;
+    deviceIsCpu: boolean;
+    /** The device pool is system RAM, so host bytes compete with device bytes. */
+    deviceSharesHostMemory: boolean;
+    deviceFreeBytes: number;
+    deviceTotalBytes: number;
+    deviceBytes: number;
+    weightsBytes: number;
+    stateBytes: number;
+    /** 0 for a pipeline with no language-model stage, such as supertonic. */
+    lmComputeBytes: number;
+    /** 0 for a pipeline with no separate codec stage. */
+    codecComputeBytes: number;
+    hostBytes: number;
+    /**
+     * The LavaSR stages' size on disk, 0 when none was named. They have no
+     * fitter, so this is a size on disk. It is counted in neither `deviceBytes`
+     * nor `hostBytes`.
+     */
+    lavasrFileBytes: number;
+    report: string;
+}
+/**
+ * Projects one voice against the memory free right now, reading GGUF metadata
+ * and never weight data. The registry's weightless copy of each file answers
+ * the same as the file itself, so this can run before anything is downloaded.
+ *
+ * The request is a `createInstance` config plus the workload, and the engine's
+ * own config builder reads it, so a load that runs and a fit that describes it
+ * resolve their settings the same way.
+ *
+ * `engineType` picks the fitter, the same key a load uses, and is required
+ * here: a fit request carries none of the file keys a load is inferred from.
+ * A model the engine cannot read comes back as `status: "error"`, as does a
+ * voice with no fitter; a broken request, or a host with no native binding,
+ * throws.
+ */
+export declare function assessFit(request: TtsFitRequest): TtsFitResult;
+export {};

package/lib/fit.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assessFit = assessFit;
+const backends_1 = require("./backends");
+/**
+ * Projects one voice against the memory free right now, reading GGUF metadata
+ * and never weight data. The registry's weightless copy of each file answers
+ * the same as the file itself, so this can run before anything is downloaded.
+ *
+ * The request is a `createInstance` config plus the workload, and the engine's
+ * own config builder reads it, so a load that runs and a fit that describes it
+ * resolve their settings the same way.
+ *
+ * `engineType` picks the fitter, the same key a load uses, and is required
+ * here: a fit request carries none of the file keys a load is inferred from.
+ * A model the engine cannot read comes back as `status: "error"`, as does a
+ * voice with no fitter; a broken request, or a host with no native binding,
+ * throws.
+ */
+function assessFit(request) {
+    // eslint-disable-next-line @typescript-eslint/no-require-imports -- native binding is resolved lazily from package prebuilds.
+    const binding = require('../binding.js');
+    return binding.assessFit({
+        ...request,
+        backendsDir: typeof request.backendsDir === 'string' && request.backendsDir.length > 0
+            ? request.backendsDir
+            : (0, backends_1.resolveBackendsDir)()
+    });
+}

package/lib/pocketConfig.d.ts

@@ -0,0 +1,10 @@
+import type { TTSConfigurationParams } from '../tts';
+interface PocketFiles {
+    modelDir?: string;
+    pocketFlowModel?: string;
+    pocketMimiModel?: string;
+    pocketFrontend?: string;
+    pocketVoice?: string;
+}
+export declare function buildPocketParams(files: PocketFiles, optionInput: object, configInput: object): TTSConfigurationParams;
+export {};

package/lib/pocketConfig.js

@@ -0,0 +1,145 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildPocketParams = buildPocketParams;
+const bare_path_1 = __importDefault(require("bare-path"));
+const DEFAULT_SAMPLING_STEPS = 1;
+const UNSUPPORTED_OPTIONS = [
+    'voice',
+    'voiceName',
+    'voiceDir',
+    'speed',
+    'noiseNpyPath',
+    'kvCacheType',
+    'streamChunkTokens',
+    'streamFirstChunkTokens',
+    'cfmSteps',
+    'cfgRate',
+    'streamLeftContextTokens',
+    'promptText',
+    'referenceText',
+    'instruct',
+    'description',
+    'voiceDescription',
+    'emotion',
+    'pace',
+    'pitch',
+    'expressivity',
+    'noise',
+    'reverb',
+    'quality',
+    'greedy',
+    'topK',
+    'topP',
+    'maxFrames',
+    'minNewTokens',
+    'normalizeNumbers',
+    'enhancer',
+    'denoiser'
+];
+const NUMERIC_OPTIONS = {
+    threads: [1, 1024],
+    nCtx: [1, 8192],
+    maxTokens: [1, 1024],
+    steps: [1, 64],
+    framesAfterEos: [-1, 100],
+    seed: [0, 4294967295],
+    temperature: [0, 10, false],
+    noiseClamp: [0, 3.402823466e38, false],
+    eosThreshold: [-3.402823466e38, 3.402823466e38, false],
+    outputSampleRate: [8000, 192000]
+};
+function resolveAsset(root, value, name) {
+    return value || (root ? bare_path_1.default.join(root, name) : '');
+}
+function resolveModelFiles(files, options) {
+    return {
+        engineType: 'pocket',
+        pocketFlowModelPath: resolveAsset(files.modelDir, files.pocketFlowModel, 'flow-lm.gguf'),
+        pocketMimiModelPath: resolveAsset(files.modelDir, files.pocketMimiModel, 'mimi.gguf'),
+        pocketFrontendPath: resolveAsset(files.modelDir, files.pocketFrontend, 'frontend.json'),
+        pocketVoicePath: files.pocketVoice ||
+            (options.referenceAudio ? '' : resolveAsset(files.modelDir, undefined, 'voice.gguf')),
+        referenceAudio: typeof options.referenceAudio === 'string' ? options.referenceAudio : '',
+        language: 'en',
+        useGPU: false,
+        steps: DEFAULT_SAMPLING_STEPS
+    };
+}
+function validateEngineOptions(options, config) {
+    if (options.referenceAudio !== undefined && typeof options.referenceAudio !== 'string')
+        throw new Error('Pocket referenceAudio must be a path string');
+    if (config.language !== undefined && config.language !== 'en')
+        throw new Error('Pocket currently supports English (en) only');
+    if (config.useGPU !== undefined && config.useGPU !== false)
+        throw new Error('Pocket currently supports CPU only (useGPU: false)');
+    if (options.nGpuLayers !== undefined && options.nGpuLayers !== 0)
+        throw new Error('Pocket requires nGpuLayers: 0');
+    if (options.steps !== undefined &&
+        options.numInferenceSteps !== undefined &&
+        options.steps !== options.numInferenceSteps)
+        throw new Error('Pocket steps conflicts with numInferenceSteps');
+}
+function rejectUnsupportedOptions(options) {
+    for (const key of UNSUPPORTED_OPTIONS) {
+        if (options[key] !== undefined)
+            throw new Error('Pocket does not support ' + key);
+    }
+}
+function numericOptionValue(key, options, config) {
+    if (key === 'outputSampleRate')
+        return config.outputSampleRate;
+    if (key === 'steps')
+        return options.steps === undefined ? options.numInferenceSteps : options.steps;
+    return options[key];
+}
+function validateNumericOption(key, value, min, max, integer) {
+    if (typeof value !== 'number' ||
+        !Number.isFinite(value) ||
+        value < min ||
+        value > max ||
+        (integer && !Number.isInteger(value))) {
+        throw new Error('Invalid Pocket ' +
+            key +
+            ': expected ' +
+            (integer ? 'an integer' : 'a number') +
+            ' between ' +
+            min +
+            ' and ' +
+            max);
+    }
+    return value;
+}
+function applyNumericOptions(params, options, config) {
+    for (const [key, [min, max, integer = true]] of Object.entries(NUMERIC_OPTIONS)) {
+        const value = numericOptionValue(key, options, config);
+        if (value !== undefined)
+            params[key] = validateNumericOption(key, value, min, max, integer);
+    }
+}
+function validateRequiredFiles(params) {
+    for (const key of ['pocketFlowModelPath', 'pocketMimiModelPath', 'pocketFrontendPath']) {
+        if (typeof params[key] !== 'string' || !params[key])
+            throw new Error('Pocket requires ' + key);
+    }
+}
+function validateVoiceConditioning(params) {
+    if (typeof params.pocketVoicePath !== 'string' ||
+        typeof params.referenceAudio !== 'string' ||
+        !!params.pocketVoicePath === !!params.referenceAudio) {
+        throw new Error('Pocket requires exactly one prepared voice file or referenceAudio WAV');
+    }
+}
+function buildPocketParams(files, optionInput, configInput) {
+    const options = optionInput;
+    const config = configInput;
+    validateEngineOptions(options, config);
+    rejectUnsupportedOptions(options);
+    const params = resolveModelFiles(files, options);
+    applyNumericOptions(params, options, config);
+    validateRequiredFiles(params);
+    validateVoiceConditioning(params);
+    return params;
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@qvac/tts-ggml",
-  "version": "0.9.2",
-  "description": "Text to Speech (TTS) addon for qvac (ggml backend, wrapping the chatterbox + supertonic + parler + cosyvoice3 + audio8 engines from tts-cpp)",
+  "version": "0.10.1",
+  "description": "Text to Speech (TTS) addon for qvac (ggml backend, wrapping the chatterbox + supertonic + parler + cosyvoice3 + audio8 + moss + Pocket engines from tts-cpp)",
   "addon": true,
   "engines": {
     "bare": ">=1.19.0"
@@ -73,11 +73,13 @@
     "example:supertonic-mtl": "bare examples/supertonic-mtl-tts.js \"Hello from the multilingual Supertonic engine.\"",
     "example:supertonic-mtl-sweep": "bare examples/supertonic-mtl-sweep-tts.js",
     "example:supertonic-sentence-stream": "bare examples/supertonic-sentence-stream-tts.js",
+    "example:supertonic-chunk-stream": "bare examples/supertonic-chunk-stream-tts.js",
     "example:cosyvoice": "bare examples/cosyvoice-tts.js \"Hello from CosyVoice three.\"",
     "example:cosyvoice-enhanced": "bare examples/cosyvoice-enhanced.js \"Hello from CosyVoice three.\"",
     "example:parler": "bare examples/parler-tts.js \"Hey, how are you doing today?\"",
     "example:parler-enhanced": "bare examples/parler-enhanced.js \"Hello from enhanced Parler.\"",
     "example:audio8": "bare examples/audio8-tts.js \"Audio eight speaks on-device.\"",
+    "example:moss": "bare examples/moss-tts.js \"MOSS speaks on-device.\"",
     "lint": "npm run lint:js && npm run lint:ts && npm run test:types",
     "lint:js": "prettier --check \"test/**/*.js\" \"scripts/__tests__/package-contract.test.js\" \"scripts/__tests__/binding-loader.test.js\" \"binding.js\" \"addon-unavailable.js\" && lunte \"test/**/*.js\" \"scripts/__tests__/package-contract.test.js\" \"scripts/__tests__/binding-loader.test.js\" \"binding.js\" \"addon-unavailable.js\"",
     "lint:ts": "eslint \"src/**/*.ts\" --max-warnings=0",
@@ -87,6 +89,7 @@
     "test:node": "node --test scripts/__tests__/*.test.js",
     "test": "npm run test:types && npm run test:unit && npm run test:integration",
     "test:integration": "npm run build:ts && brittle-bare test/integration/**/*.test.js",
+    "test:integration:smoke": "npm run build:ts && brittle-bare test/integration/supertonic.test.js",
     "test:benchmark:rtf": "npm run build:ts && brittle-bare test/benchmark/rtf-benchmark.test.js",
     "test:benchmark:rtf:matrix": "node scripts/run-rtf-benchmark-matrix.js",
     "test:benchmark:streaming": "npm run build:ts && brittle-bare test/benchmark/streaming-benchmark.test.js",
@@ -104,7 +107,10 @@
     "setup:venv": "bash scripts/setup-venv.sh",
     "convert-models": "bash scripts/convert-models.sh",
     "setup-models": "bash scripts/setup-venv.sh && bash scripts/convert-models.sh",
-    "download-models:registry": "node scripts/download-tts-ggml-models.js"
+    "download-models:registry": "node scripts/download-tts-ggml-models.js",
+    "download-models:smoke": "node scripts/download-tts-ggml-models.js --group supertonic",
+    "example:pocket": "bare examples/pocket-tts.js",
+    "test:pocket": "npm run build:ts && brittle-bare test/integration/pocket.integration.test.js"
   },
   "files": [
     "addonLogging.js",
@@ -134,7 +140,8 @@
     "test/utils/textMetrics.js",
     "test/data/sentences-medium.js",
     "test/data/sentences-long.js",
-    "LICENSE"
+    "LICENSE",
+    "docs"
   ],
   "exports": {
     "./package": "./package.json",
@@ -209,10 +216,10 @@
   },
   "types": "index.d.ts",
   "optionalDependencies": {
-    "@qvac/tts-ggml-linux-x64": "0.9.2",
-    "@qvac/tts-ggml-linux-arm64": "0.9.2",
-    "@qvac/tts-ggml-darwin-arm64": "0.9.2",
-    "@qvac/tts-ggml-darwin-x64": "0.9.2",
-    "@qvac/tts-ggml-win32-x64": "0.9.2"
+    "@qvac/tts-ggml-linux-x64": "0.10.1",
+    "@qvac/tts-ggml-linux-arm64": "0.10.1",
+    "@qvac/tts-ggml-darwin-arm64": "0.10.1",
+    "@qvac/tts-ggml-darwin-x64": "0.10.1",
+    "@qvac/tts-ggml-win32-x64": "0.10.1"
   }
 }

package/test/integration/addon.test.js

@@ -15,11 +15,12 @@ const {
 const { ensureChatterboxModels, ensureWhisperModel } = require('../utils/downloadModel')
 const { loadWhisper, runWhisper } = require('../utils/runWhisper')
 const { recordTtsStats } = require('../utils/perf-helper')
+const { TTS_TEST_THREADS } = require('../utils/testThreads')
+const { NO_GPU, GPU_ONLY_USE_GPU } = require('../utils/gpuOnly')
 
 const platform = os.platform()
 const isMobile = platform === 'ios' || platform === 'android'
 const isDarwin = platform === 'darwin'
-const forceNoGpu = os.getEnv('NO_GPU') === 'true'
 
 const INPUT_SENTENCES = (isMobile ? 'short' : os.getEnv('INPUT_SENTENCES')) || 'short'
 const useSplit = INPUT_SENTENCES !== 'short'
@@ -41,7 +42,7 @@ function getEnglishSentences() {
 
 test(
   'Chatterbox TTS (ggml): English synthesis + optional WER verification',
-  { timeout: 1800000 },
+  { timeout: 1800000, skip: NO_GPU },
   async (t) => {
     const baseDir = getBaseDir()
     const modelsDir = path.join(baseDir, 'models')
@@ -83,8 +84,10 @@ test(
       `\n=== English synthesis (${englishSentences.length} sentences, tier: ${INPUT_SENTENCES}, modelDir: ${resolvedModelDir}) ===`
     )
     const model = await loadChatterboxTTS({
+      threads: TTS_TEST_THREADS,
       modelDir: resolvedModelDir,
-      language: 'en'
+      language: 'en',
+      useGPU: GPU_ONLY_USE_GPU
     })
     t.ok(model, 'Chatterbox (ggml) model should be loaded')
 
@@ -250,8 +253,9 @@ test(
     // empty/undefined value flows through to the engine cleanly.
     const TTSGgml = require('@qvac/tts-ggml')
     const model = new TTSGgml({
+      threads: TTS_TEST_THREADS,
       files: { modelDir: download.targetDir },
-      config: { language: 'en', ...(forceNoGpu ? { useGPU: false } : {}) },
+      config: { language: 'en', ...(NO_GPU ? { useGPU: false } : {}) },
       opts: { stats: true }
     })
 
@@ -309,9 +313,10 @@ test(
     // resolve to (the latter is not readable from native code on iOS).
     const TTSGgml = require('@qvac/tts-ggml')
     const model = new TTSGgml({
+      threads: TTS_TEST_THREADS,
       files: { modelDir: download.targetDir },
       referenceAudio: resolveRefWavPath({}),
-      config: { language: 'en', outputSampleRate: 16000, ...(forceNoGpu ? { useGPU: false } : {}) },
+      config: { language: 'en', outputSampleRate: 16000, ...(NO_GPU ? { useGPU: false } : {}) },
       opts: { stats: true }
     })
     await model.load()
@@ -340,7 +345,7 @@ test(
 
 test(
   'Chatterbox TTS (ggml): native C++ chunk streaming via streamChunkTokens',
-  { timeout: 600000 },
+  { timeout: 600000, skip: NO_GPU },
   async (t) => {
     const baseDir = getBaseDir()
     const modelsDir = path.join(baseDir, 'models')
@@ -361,12 +366,13 @@ test(
     // rationale).
     const TTSGgml = require('@qvac/tts-ggml')
     const model = new TTSGgml({
+      threads: TTS_TEST_THREADS,
       files: { modelDir: download.targetDir },
       referenceAudio: resolveRefWavPath({}),
       streamChunkTokens: 25,
       streamFirstChunkTokens: 10,
       cfmSteps: 1,
-      config: { language: 'en', ...(forceNoGpu ? { useGPU: false } : {}) },
+      config: { language: 'en', useGPU: GPU_ONLY_USE_GPU },
       opts: { stats: true }
     })
     await model.load()

package/test/integration/audio8.test.js

@@ -10,6 +10,7 @@ const TTSGgml = require('@qvac/tts-ggml')
 const { ensureAudio8Models } = require('../utils/downloadModel')
 const { recordTtsStats } = require('../utils/perf-helper')
 const { resolveRefWavPath } = require('../utils/runChatterboxTTS')
+const { TTS_TEST_THREADS } = require('../utils/testThreads')
 
 const AUDIO8_SAMPLE_RATE = 44100
 const AUDIO8_MAX_FRAMES = 16
@@ -46,6 +47,7 @@ function resolveAudio8Files(models, useModelDir) {
 
 function createAudio8Model(models, useGPU, useModelDir) {
   return new TTSGgml({
+    threads: TTS_TEST_THREADS,
     engine: TTSGgml.ENGINE_AUDIO8,
     files: resolveAudio8Files(models, useModelDir),
     greedy: true,
@@ -84,6 +86,9 @@ function assertAudio(t, label, result) {
   )
   t.ok(result.stats.tokensPerSecond > 0, `${label} reports codec frames per second`)
   t.ok(result.stats.audioDurationMs > 0, `${label} reports audio duration`)
+  for (const key of ['prefillMs', 'fastDecodeMs', 'codecSynthMs', 'stageTotalMs']) {
+    t.ok(result.stats[key] > 0, `${label} reports the engine's ${key}`)
+  }
 }
 
 function sampleBytes(samples) {
@@ -145,6 +150,7 @@ test(
       assertAudio(t, 'Audio8 text-only', textOnly)
       t.is(textOnly.stats.backendDevice, CPU_DEVICE, 'text-only CPU run reports a CPU device')
       t.is(textOnly.stats.backendId, CPU_BACKEND, 'text-only CPU run reports the CPU backend')
+      t.is(textOnly.stats.voiceEncodeMs, 0, 'text-only run encodes no reference voice')
       recordAudio8(t, 'audio8 text-only', textOnly, Date.now() - textStarted)
 
       const cloneStarted = Date.now()
@@ -154,6 +160,7 @@ test(
       })
       assertAudio(t, 'Audio8 voice clone', cloned)
       t.is(cloned.stats.backendDevice, CPU_DEVICE, 'voice cloning remains on the requested CPU')
+      t.ok(cloned.stats.voiceEncodeMs > 0, 'voice cloning reports the reference encode time')
       t.ok(
         samplesDiffer(textOnly.samples, cloned.samples),
         'per-call reference audio changes the synthesized voice'

package/test/integration/chatterbox-mtl.test.js

@@ -25,13 +25,16 @@ const {
   ensureCangjieTsv
 } = require('../utils/downloadModel')
 const { recordTtsStats } = require('../utils/perf-helper')
+const { TTS_TEST_THREADS } = require('../utils/testThreads')
+const { NO_GPU, GPU_ONLY_USE_GPU } = require('../utils/gpuOnly')
 
 const platform = os.platform()
 const isMobile = platform === 'ios' || platform === 'android'
 
-// Language coverage test, not a GPU policy test: rely on the package
-// default (`useGPU: false`) rather than opting into GPU here.
-// Tests that *are* about GPU live in gpu-smoke.test.js.
+// Language coverage, not a GPU policy test. A single MTL synthesis already
+// takes close to a minute on the CPU-only runners, so these tests run on the
+// GPU only and are skipped there (NO_GPU=true). Tests that *are* about GPU live
+// in gpu-smoke.test.js.
 
 function getBaseDir() {
   return isMobile && global.testDir ? global.testDir : '.'
@@ -61,6 +64,7 @@ async function loadChatterboxMtlTTS(params) {
   }
 
   const model = new TTSGgml({
+    threads: TTS_TEST_THREADS,
     files: {
       modelDir: params.modelDir,
       t3Model: params.t3ModelPath,
@@ -81,7 +85,7 @@ async function loadChatterboxMtlTTS(params) {
 
 test(
   'Chatterbox MTL TTS (ggml): synthesizes across es/fr/de with shared engine',
-  { timeout: 1800000 },
+  { timeout: 1800000, skip: NO_GPU },
   async (t) => {
     const baseDir = getBaseDir()
     const download = await ensureChatterboxMtlModels({ targetDir: path.join(baseDir, 'models') })
@@ -96,7 +100,8 @@ test(
       modelDir: download.targetDir,
       t3ModelPath: path.join(download.targetDir, 'chatterbox-t3-mtl.gguf'),
       s3genModelPath: path.join(download.targetDir, 'chatterbox-s3gen-mtl.gguf'),
-      language: MTL_SENTENCES[0].lang
+      language: MTL_SENTENCES[0].lang,
+      useGPU: GPU_ONLY_USE_GPU
     })
     try {
       for (let i = 0; i < MTL_SENTENCES.length; i++) {
@@ -145,6 +150,10 @@ test(
               'backendDevice surfaced in stats'
             )
             t.ok(typeof result.data.stats.backendId === 'number', 'backendId surfaced in stats')
+            const { t3Tokens, t3Ms, s3genMs, denoiserBackendDevice } = result.data.stats
+            t.ok(t3Tokens > 0, 'stats report the speech tokens T3 emitted')
+            t.ok(t3Ms > 0 && s3genMs > 0, 'stats report the T3 and S3Gen stage times')
+            t.is(denoiserBackendDevice, -1, 'no denoiser loaded -> denoiserBackendDevice=-1')
           } else {
             t.fail('expected stats from MTL run')
           }
@@ -160,7 +169,7 @@ test(
 
 test(
   'Chatterbox MTL TTS (ggml): synthesizes Japanese with MeCab dictionary',
-  { timeout: 1800000 },
+  { timeout: 1800000, skip: NO_GPU },
   async (t) => {
     const baseDir = getBaseDir()
     const download = await ensureChatterboxMtlModels({ targetDir: path.join(baseDir, 'models') })
@@ -182,7 +191,8 @@ test(
       t3ModelPath: path.join(download.targetDir, 'chatterbox-t3-mtl.gguf'),
       s3genModelPath: path.join(download.targetDir, 'chatterbox-s3gen-mtl.gguf'),
       mecabDictDir: mecab.dir,
-      language: 'ja'
+      language: 'ja',
+      useGPU: GPU_ONLY_USE_GPU
     })
     try {
       const t0 = Date.now()
@@ -227,7 +237,7 @@ test(
 
 test(
   'Chatterbox MTL TTS (ggml): synthesizes Chinese with Cangjie table',
-  { timeout: 1800000 },
+  { timeout: 1800000, skip: NO_GPU },
   async (t) => {
     const baseDir = getBaseDir()
     const download = await ensureChatterboxMtlModels({ targetDir: path.join(baseDir, 'models') })
@@ -249,7 +259,8 @@ test(
       t3ModelPath: path.join(download.targetDir, 'chatterbox-t3-mtl.gguf'),
       s3genModelPath: path.join(download.targetDir, 'chatterbox-s3gen-mtl.gguf'),
       cangjieTsvPath: cangjie.path,
-      language: 'zh'
+      language: 'zh',
+      useGPU: GPU_ONLY_USE_GPU
     })
     try {
       const t0 = Date.now()

package/test/integration/chatterbox-speed.test.js

@@ -11,6 +11,8 @@ const path = require('bare-path')
 
 const { loadChatterboxTTS, runChatterboxTTS } = require('../utils/runChatterboxTTS')
 const { ensureChatterboxModels } = require('../utils/downloadModel')
+const { TTS_TEST_THREADS } = require('../utils/testThreads')
+const { NO_GPU, GPU_ONLY_USE_GPU } = require('../utils/gpuOnly')
 
 function getBaseDir() {
   const platform = os.platform()
@@ -29,7 +31,7 @@ const EXPECTATION = {
 
 test(
   'Chatterbox TTS (ggml): speed config adjusts duration, preserves backward compat',
-  { timeout: 1800000 },
+  { timeout: 1800000, skip: NO_GPU },
   async (t) => {
     const modelsDir = path.join(getBaseDir(), 'models')
 
@@ -47,7 +49,13 @@ test(
     // across loads, so the only difference between runs is the speed knob.
     async function sampleCountAt(speed) {
       const label = speed === undefined ? 'default' : String(speed)
-      const model = await loadChatterboxTTS({ modelDir, language: 'en', speed })
+      const model = await loadChatterboxTTS({
+        threads: TTS_TEST_THREADS,
+        modelDir,
+        language: 'en',
+        speed,
+        useGPU: GPU_ONLY_USE_GPU
+      })
       try {
         const r = await runChatterboxTTS(model, { text: TEXT }, EXPECTATION)
         t.ok(r.passed, `speed=${label}: passes synthesis expectations`)
@@ -94,7 +102,12 @@ test('Chatterbox TTS (ggml): out-of-range speed is rejected', { timeout: 600000
   // `speed` is bounded to [0.25, 4.0] by ChatterboxModel::validateConfig,
   // which runs at load time and surfaces as a rejected load.
   await t.exception(
-    loadChatterboxTTS({ modelDir: download.targetDir, language: 'en', speed: 5 }),
+    loadChatterboxTTS({
+      threads: TTS_TEST_THREADS,
+      modelDir: download.targetDir,
+      language: 'en',
+      speed: 5
+    }),
     'speed=5 (> 4.0) is rejected at load'
   )
 })