@qvac/tts-ggml 0.9.2 → 0.10.1

package/test/integration/lavasr-enhancer.test.js

@@ -32,6 +32,8 @@ const {
   ensureParlerModel
 } = require('../utils/downloadModel')
 const { resolveRefWavPath } = require('../utils/runChatterboxTTS')
+const { TTS_TEST_THREADS } = require('../utils/testThreads')
+const { GPU_ONLY_USE_GPU } = require('../utils/gpuOnly')
 
 const platform = os.platform()
 const isMobile = platform === 'ios' || platform === 'android'
@@ -159,6 +161,13 @@ async function runAndCollect(model, text) {
   return { samples, sampleRate, stats: response.stats || null }
 }
 
+// A CPU engine keeps the denoiser on its scalar core, which runtimeStats
+// reports as CPU (denoiserBackendDevice 0, denoiserBackendId 0).
+function assertDenoiserOnCpu(t, stats, label) {
+  t.is(stats.denoiserBackendDevice, 0, `${label}: useGPU:false -> denoiser on CPU`)
+  t.is(stats.denoiserBackendId, 0, `${label}: denoiser backend reported as CPU`)
+}
+
 // Every chunk that carries audio must be tagged at the enhanced 48 kHz rate
 // rather than the engine's native rate — the mislabel this feature prevents.
 function assertStreamedChunksReportEnhancedRate(t, updates) {
@@ -202,6 +211,7 @@ function assertStreamTerminatesOnce(t, updates, terminal) {
 
 async function runParlerBatch(files) {
   const model = new TTSGgml({
+    threads: TTS_TEST_THREADS,
     engine: TTSGgml.ENGINE_PARLER,
     files,
     voice: 'Laura',
@@ -225,6 +235,7 @@ test('Chatterbox: enhancer + streamChunkTokens constructs and forwards both', (t
   // construct and forward both knobs to the addon (which runs the streaming
   // enhancer per chunk).
   const model = new TTSGgml({
+    threads: TTS_TEST_THREADS,
     engine: TTSGgml.ENGINE_CHATTERBOX,
     files: {
       t3Model: './models/chatterbox-t3-turbo.gguf',
@@ -247,6 +258,7 @@ test('Parler: enhancer + streamChunkTokens constructs and forwards both', (t) =>
   // Parler used to reject the enhancer outright; it now enhances both the batch
   // path and native chunk streaming (seam-free via the streaming enhancer).
   const model = new TTSGgml({
+    threads: TTS_TEST_THREADS,
     engine: TTSGgml.ENGINE_PARLER,
     files: {
       parlerModel: './models/parler-mini-v1-q8_0.gguf',
@@ -266,6 +278,7 @@ test('Parler: enhancer + streamChunkTokens constructs and forwards both', (t) =>
 
 test('Parler: denoiser forwards on the batch path and is rejected while streaming', (t) => {
   const model = new TTSGgml({
+    threads: TTS_TEST_THREADS,
     engine: TTSGgml.ENGINE_PARLER,
     files: {
       parlerModel: './models/parler-mini-v1-q8_0.gguf',
@@ -281,6 +294,7 @@ test('Parler: denoiser forwards on the batch path and is rejected while streamin
   t.exception(
     () =>
       new TTSGgml({
+        threads: TTS_TEST_THREADS,
         engine: TTSGgml.ENGINE_PARLER,
         files: {
           parlerModel: './models/parler-mini-v1-q8_0.gguf',
@@ -299,6 +313,7 @@ test('CosyVoice3: enhancer + streamChunkTokens constructs and forwards both', (t
   // batch path and on native chunk streaming, so both knobs must reach the
   // addon together.
   const model = new TTSGgml({
+    threads: TTS_TEST_THREADS,
     engine: TTSGgml.ENGINE_COSYVOICE3,
     files: {
       cosyvoiceModelDir: './models/cosyvoice3',
@@ -318,6 +333,7 @@ test('CosyVoice3: enhancer + streamChunkTokens constructs and forwards both', (t
 
 test('CosyVoice3: denoiser is forwarded for batch but rejected with streaming', (t) => {
   const batch = new TTSGgml({
+    threads: TTS_TEST_THREADS,
     engine: TTSGgml.ENGINE_COSYVOICE3,
     files: {
       cosyvoiceModelDir: './models/cosyvoice3',
@@ -334,6 +350,7 @@ test('CosyVoice3: denoiser is forwarded for batch but rejected with streaming',
   t.exception(
     () =>
       new TTSGgml({
+        threads: TTS_TEST_THREADS,
         engine: TTSGgml.ENGINE_COSYVOICE3,
         files: {
           cosyvoiceModelDir: './models/cosyvoice3',
@@ -351,6 +368,7 @@ test('enhancer with an unknown type is rejected at construction', (t) => {
   t.exception(
     () =>
       new TTSGgml({
+        threads: TTS_TEST_THREADS,
         engine: TTSGgml.ENGINE_SUPERTONIC,
         files: {
           supertonicModel: './models/supertonic.gguf',
@@ -366,6 +384,7 @@ test('enhancer with an unknown type is rejected at construction', (t) => {
 
 test('enhancer block with no GGUF path leaves enhancement off (no throw)', (t) => {
   const model = new TTSGgml({
+    threads: TTS_TEST_THREADS,
     engine: TTSGgml.ENGINE_SUPERTONIC,
     files: { supertonicModel: './models/supertonic.gguf' },
     enhancer: { type: 'lavasr' },
@@ -420,7 +439,12 @@ for (const [engineName, engine, files] of [
   ]
 ]) {
   test(`${engineName}: enhancer + useGPU:true forwards useGPU alongside the enhancer path`, (t) => {
-    const model = new TTSGgml({ engine, files, config: { language: 'en', useGPU: true } })
+    const model = new TTSGgml({
+      threads: TTS_TEST_THREADS,
+      engine,
+      files,
+      config: { language: 'en', useGPU: true }
+    })
     const params = model._buildTtsParams()
     t.is(params.useGPU, true, 'useGPU:true forwarded to the addon (drives EnhancerOptions.use_gpu)')
     t.is(
@@ -431,7 +455,12 @@ for (const [engineName, engine, files] of [
   })
 
   test(`${engineName}: enhancer + useGPU:false keeps the enhancer on CPU`, (t) => {
-    const model = new TTSGgml({ engine, files, config: { language: 'en', useGPU: false } })
+    const model = new TTSGgml({
+      threads: TTS_TEST_THREADS,
+      engine,
+      files,
+      config: { language: 'en', useGPU: false }
+    })
     const params = model._buildTtsParams()
     t.is(
       params.useGPU,
@@ -446,7 +475,13 @@ for (const [engineName, engine, files] of [
   })
 
   test(`${engineName}: enhancer + nGpuLayers!=0 forwards the GPU layer count`, (t) => {
-    const model = new TTSGgml({ engine, files, nGpuLayers: 99, config: { language: 'en' } })
+    const model = new TTSGgml({
+      threads: TTS_TEST_THREADS,
+      engine,
+      files,
+      nGpuLayers: 99,
+      config: { language: 'en' }
+    })
     const params = model._buildTtsParams()
     t.is(params.nGpuLayers, 99, 'nGpuLayers forwarded (non-zero => enhancer requests the GPU)')
     t.is(
@@ -479,6 +514,7 @@ test(
     }
 
     const model = new TTSGgml({
+      threads: TTS_TEST_THREADS,
       engine: TTSGgml.ENGINE_SUPERTONIC,
       files: { supertonicModel: dl.path, lavasrEnhancer: enh.path },
       voice: 'F1',
@@ -525,6 +561,7 @@ test(
     }
 
     const model = new TTSGgml({
+      threads: TTS_TEST_THREADS,
       engine: TTSGgml.ENGINE_SUPERTONIC,
       files: { supertonicModel: dl.path },
       voice: 'F1',
@@ -566,6 +603,7 @@ test(
     const dir = dl.targetDir || modelsDir
 
     const model = new TTSGgml({
+      threads: TTS_TEST_THREADS,
       engine: TTSGgml.ENGINE_CHATTERBOX,
       files: {
         modelDir: dir,
@@ -595,7 +633,7 @@ test(
 
 test(
   'Chatterbox + LavaSR enhancer + native chunk streaming emits 48 kHz chunks',
-  { timeout: 900000 },
+  { timeout: 900000, skip: NO_GPU },
   async (t) => {
     const baseDir = getBaseDir()
     const enh = await ensureLavaSREnhancerGguf({
@@ -615,6 +653,7 @@ test(
     const dir = dl.targetDir || modelsDir
 
     const model = new TTSGgml({
+      threads: TTS_TEST_THREADS,
       engine: TTSGgml.ENGINE_CHATTERBOX,
       files: {
         modelDir: dir,
@@ -624,7 +663,7 @@ test(
       },
       referenceAudio: resolveRefWavPath({}),
       streamChunkTokens: 25, // native chunk streaming + enhancer (the path)
-      config: { language: 'en', useGPU: false },
+      config: { language: 'en', useGPU: GPU_ONLY_USE_GPU },
       opts: { stats: true }
     })
     await model.load()
@@ -675,6 +714,7 @@ test(
     }
 
     const model = new TTSGgml({
+      threads: TTS_TEST_THREADS,
       engine: TTSGgml.ENGINE_PARLER,
       files: { parlerModel: dl.path, lavasrEnhancer: enh.path },
       voice: 'Laura',
@@ -718,6 +758,7 @@ test(
     }
 
     const model = new TTSGgml({
+      threads: TTS_TEST_THREADS,
       engine: TTSGgml.ENGINE_PARLER,
       files: { parlerModel: dl.path },
       voice: 'Laura',
@@ -731,6 +772,8 @@ test(
       t.ok(r.samples > 0, 'synthesis produced audio')
       t.ok(r.stats, 'runtimeStats returned (constructed with stats:true)')
       t.is(r.stats.enhancerBackendDevice, -1, 'no enhancer loaded -> enhancerBackendDevice=-1')
+      t.is(r.stats.denoiserBackendDevice, -1, 'no denoiser loaded -> denoiserBackendDevice=-1')
+      t.is(r.stats.denoiserBackendId, -1, 'no denoiser loaded -> denoiserBackendId=-1')
     } finally {
       try {
         await model.unload()
@@ -759,6 +802,7 @@ test(
     }
 
     const model = new TTSGgml({
+      threads: TTS_TEST_THREADS,
       engine: TTSGgml.ENGINE_PARLER,
       files: { parlerModel: dl.path, lavasrEnhancer: enh.path },
       voice: 'Laura',
@@ -815,6 +859,7 @@ test(
     }
 
     const model = new TTSGgml({
+      threads: TTS_TEST_THREADS,
       engine: TTSGgml.ENGINE_PARLER,
       files: { parlerModel: dl.path, lavasrEnhancer: enh.path },
       voice: 'Laura',
@@ -882,6 +927,7 @@ test(
       -1,
       'denoiser alone loads no enhancer (enhancerBackendDevice=-1)'
     )
+    assertDenoiserOnCpu(t, denoisedOnly.stats, 'denoiser alone')
 
     const enh = await ensureLavaSREnhancerGguf({
       targetDir: path.join(baseDir, 'models', 'lavasr')
@@ -909,6 +955,7 @@ test(
       0,
       'useGPU:false -> enhancer on CPU (enhancerBackendDevice=0)'
     )
+    assertDenoiserOnCpu(t, denoisedAndEnhanced.stats, 'denoiser + enhancer')
   }
 )
 
@@ -941,6 +988,7 @@ test(
     }
 
     const model = new TTSGgml({
+      threads: TTS_TEST_THREADS,
       engine: TTSGgml.ENGINE_SUPERTONIC,
       files: { supertonicModel: dl.path, lavasrEnhancer: enh.path },
       voice: 'F1',
@@ -964,6 +1012,59 @@ test(
   }
 )
 
+test(
+  'Supertonic + LavaSR denoiser on GPU (useGPU:true) runs the denoiser on the engine device',
+  { timeout: 600000, skip: NO_GPU },
+  async (t) => {
+    const baseDir = getBaseDir()
+    const den = await ensureLavaSRDenoiserGguf({
+      targetDir: path.join(baseDir, 'models', 'lavasr')
+    })
+    if (!den.success) {
+      t.comment('LavaSR denoiser GGUF not staged; skipping.')
+      t.pass('skipped — no denoiser GGUF')
+      return
+    }
+    const dl = await ensureSupertonicModel({ targetDir: path.join(baseDir, 'models') })
+    if (!dl.success) {
+      t.fail('Supertonic GGUF not available — registry fetch failed.')
+      return
+    }
+
+    const model = new TTSGgml({
+      threads: TTS_TEST_THREADS,
+      engine: TTSGgml.ENGINE_SUPERTONIC,
+      files: { supertonicModel: dl.path, lavasrDenoiser: den.path },
+      voice: 'F1',
+      config: { language: 'en', useGPU: true },
+      opts: { stats: true }
+    })
+    await model.load()
+    try {
+      const r = await runAndCollect(model, 'The denoiser follows the engine onto the GPU.')
+      t.is(r.sampleRate, 44100, 'denoising preserves the native 44.1 kHz')
+      t.ok(r.samples > 0, 'denoised synthesis produced audio')
+      const { backendDevice, backendId, denoiserBackendDevice, denoiserBackendId } = r.stats
+      console.log(
+        `[denoiser/GPU] backendDevice=${backendDevice} denoiserBackendDevice=` +
+          `${denoiserBackendDevice} denoiserBackendId=${denoiserBackendId} ` +
+          `(${backendIdToName(denoiserBackendId)})`
+      )
+      t.not(denoiserBackendDevice, -1, 'denoiser was loaded (denoiserBackendDevice != -1)')
+      t.is(denoiserBackendDevice, backendDevice, 'denoiser runs on the engine device')
+      if (backendDevice === 1) {
+        t.is(denoiserBackendId, backendId, 'GPU denoiser uses the engine backend')
+      } else {
+        t.is(denoiserBackendId, 0, 'a CPU-fallback engine keeps the denoiser on CPU')
+      }
+    } finally {
+      try {
+        await model.unload()
+      } catch (_e) {}
+    }
+  }
+)
+
 test(
   'Chatterbox + LavaSR enhancer on GPU (useGPU:true, batch) runs the enhancer on the GPU and reports 48 kHz',
   { timeout: 900000, skip: NO_GPU },
@@ -986,6 +1087,7 @@ test(
     const dir = dl.targetDir || modelsDir
 
     const model = new TTSGgml({
+      threads: TTS_TEST_THREADS,
       engine: TTSGgml.ENGINE_CHATTERBOX,
       files: {
         modelDir: dir,

package/test/integration/moss.test.js

@@ -0,0 +1,287 @@
+'use strict'
+
+const fs = require('bare-fs')
+const os = require('bare-os')
+const path = require('bare-path')
+const proc = require('bare-process')
+const test = require('brittle')
+
+const TTSGgml = require('@qvac/tts-ggml')
+const { recordTtsStats } = require('../utils/perf-helper')
+const { resolveRefWavPath } = require('../utils/runChatterboxTTS')
+const { readWavAsFloat32, createWav, resampleLinear } = require('../utils/wav-helper')
+const { TTS_TEST_THREADS } = require('../utils/testThreads')
+const { NO_GPU, GPU_ONLY_USE_GPU } = require('../utils/gpuOnly')
+
+const MOSS_SAMPLE_RATE = 24000
+const MOSS_STREAM_FRAMES = 10
+const MOSS_SAMPLES_PER_FRAME = 1920
+const TEST_TIMEOUT_MS = 1800000
+const SYNTHESIS_TEXT = 'The MOSS integration test checks this generated voice.'
+const MODEL_DIR_ENV = 'QVAC_TEST_MOSS_MODEL_DIR'
+const ENCODER_RE = /^moss-codec-encoder(-[a-z0-9_]+)?\.gguf$/i
+const DIALOGUE_BACKBONE_RE = /^moss-ttsd(-[a-z0-9_]+)?\.gguf$/i
+const DIALOGUE_TEXT =
+  '[S1] And so, my fellow Americans, [S2] ask what you can do for your country. ' +
+  '[S1] Did the build finish this morning? [S2] Yes, every single test passed.'
+const SPEAKER_ONE_SECONDS = [0, 3.29]
+const SPEAKER_TWO_SECONDS = [7.6, 10.6]
+const SHORT_DURATION_TOKENS = 25
+const LONG_DURATION_TOKENS = 100
+const INT16_FULL_SCALE = 32767
+const CPU_DEVICE = 0
+const CPU_BACKEND = 0
+const GPU_DEVICE = 1
+
+const modelDir = (proc.env && proc.env[MODEL_DIR_ENV]) || ''
+const skipWithoutModels = modelDir === ''
+
+function createMossModel(extra = {}, useGPU = false) {
+  return new TTSGgml({
+    threads: TTS_TEST_THREADS,
+    engine: TTSGgml.ENGINE_MOSS,
+    files: { modelDir: path.resolve(modelDir) },
+    config: { language: 'en', useGPU },
+    opts: { stats: true },
+    ...extra
+  })
+}
+
+function toInt16(samples) {
+  return Array.from(samples, (sample) => Math.round(sample * INT16_FULL_SCALE))
+}
+
+function resampleToMossRate(sourcePath) {
+  const source = readWavAsFloat32(sourcePath)
+  return resampleLinear(source.samples, source.sampleRate, MOSS_SAMPLE_RATE)
+}
+
+function writeMossWav(samples, tag) {
+  const target = path.join(os.tmpdir(), `moss-${tag}-${Date.now()}.wav`)
+  createWav(toInt16(samples), MOSS_SAMPLE_RATE, target)
+  return target
+}
+
+function writeReferenceAtMossRate(sourcePath) {
+  return writeMossWav(resampleToMossRate(sourcePath), 'reference')
+}
+
+function sliceSeconds(samples, [from, to]) {
+  return samples.slice(Math.round(from * MOSS_SAMPLE_RATE), Math.round(to * MOSS_SAMPLE_RATE))
+}
+
+function writeSpeakerReferences(sourcePath) {
+  const samples = resampleToMossRate(sourcePath)
+  return [
+    writeMossWav(sliceSeconds(samples, SPEAKER_ONE_SECONDS), 'speaker-1'),
+    writeMossWav(sliceSeconds(samples, SPEAKER_TWO_SECONDS), 'speaker-2')
+  ]
+}
+
+function removeFiles(paths) {
+  for (const file of paths) fs.unlinkSync(file)
+}
+
+function modelDirHas(pattern) {
+  return !skipWithoutModels && fs.readdirSync(modelDir).some((entry) => pattern.test(entry))
+}
+
+function hasEncoder() {
+  return modelDirHas(ENCODER_RE)
+}
+
+function hasDialogueBackbone() {
+  return modelDirHas(DIALOGUE_BACKBONE_RE)
+}
+
+function collectChunk(result, data) {
+  if (!data || !data.outputArray) return
+  result.chunks.push(data.outputArray.length)
+  result.samples = result.samples.concat(Array.from(data.outputArray))
+  if (data.sampleRate) result.sampleRate = data.sampleRate
+}
+
+async function synthesize(model, text) {
+  const response = await model.run({ input: text, type: 'text' })
+  const result = { samples: [], chunks: [], sampleRate: null }
+  await response.onUpdate((data) => collectChunk(result, data)).await()
+  result.stats = response.stats
+  return result
+}
+
+function assertAudio(t, label, result) {
+  t.ok(result.samples.length > 0, `${label} produced audio`)
+  t.is(result.sampleRate, MOSS_SAMPLE_RATE, `${label} reports 24 kHz`)
+  t.ok(result.stats, `${label} returns runtime stats`)
+  t.is(result.stats.totalSamples, result.samples.length, `${label} reports the emitted samples`)
+  t.ok(result.stats.generatedFrames > 0, `${label} reports generated codec frames`)
+  t.ok(result.stats.tokensPerSecond > 0, `${label} reports codec frames per second`)
+}
+
+function nonEmptyChunks(result) {
+  return result.chunks.filter((length) => length > 0)
+}
+
+function recordMoss(t, label, result, wallMs) {
+  t.comment(
+    recordTtsStats(label, result.stats, {
+      wallMs,
+      sampleCount: result.samples.length,
+      model: 'moss',
+      output: label
+    })
+  )
+}
+
+function assertCpuBackend(t, label, stats) {
+  t.is(stats.backendDevice, CPU_DEVICE, `${label} reports a CPU device`)
+  t.is(stats.backendId, CPU_BACKEND, `${label} reports the CPU backend`)
+}
+
+async function withLoadedModel(extra, body, useGPU = false) {
+  const model = createMossModel(extra, useGPU)
+  await model.load()
+  try {
+    await body(model)
+  } finally {
+    await model.unload()
+  }
+}
+
+test(
+  'MOSS TTS: batch synthesis through the public JS API',
+  { timeout: TEST_TIMEOUT_MS, skip: skipWithoutModels },
+  async (t) => {
+    await withLoadedModel({}, async (model) => {
+      const started = Date.now()
+      const result = await synthesize(model, SYNTHESIS_TEXT)
+      assertAudio(t, 'MOSS batch', result)
+      assertCpuBackend(t, 'MOSS batch', result.stats)
+      t.is(nonEmptyChunks(result).length, 1, 'batch synthesis emits one buffer')
+      recordMoss(t, 'moss batch', result, Date.now() - started)
+    })
+  }
+)
+
+test(
+  'MOSS TTS: native chunk streaming emits frame-sized chunks',
+  { timeout: TEST_TIMEOUT_MS, skip: skipWithoutModels },
+  async (t) => {
+    await withLoadedModel({ streamChunkTokens: MOSS_STREAM_FRAMES }, async (model) => {
+      const started = Date.now()
+      const result = await synthesize(model, SYNTHESIS_TEXT)
+      assertAudio(t, 'MOSS stream', result)
+      const chunks = nonEmptyChunks(result)
+      t.ok(chunks.length > 1, `streaming emits several chunks (got ${chunks.length})`)
+      t.ok(
+        chunks.every((length) => length <= MOSS_STREAM_FRAMES * MOSS_SAMPLES_PER_FRAME),
+        'no chunk exceeds the configured frame count'
+      )
+      recordMoss(t, 'moss stream', result, Date.now() - started)
+    })
+  }
+)
+
+test(
+  'MOSS TTS: useGPU=true synthesizes on a GPU backend',
+  { timeout: TEST_TIMEOUT_MS, skip: skipWithoutModels || NO_GPU },
+  async (t) => {
+    await withLoadedModel(
+      {},
+      async (model) => {
+        const started = Date.now()
+        const result = await synthesize(model, SYNTHESIS_TEXT)
+        assertAudio(t, 'MOSS GPU', result)
+        t.is(result.stats.backendDevice, GPU_DEVICE, 'MOSS GPU reports a GPU device')
+        t.not(result.stats.backendId, CPU_BACKEND, 'MOSS GPU does not report the CPU backend')
+        t.is(result.stats.gpuUnsupported, 0, 'MOSS GPU does not report a GPU fallback')
+        recordMoss(t, 'moss gpu', result, Date.now() - started)
+      },
+      true
+    )
+  }
+)
+
+test(
+  'MOSS TTS: voice cloning synthesizes from a reference recording',
+  { timeout: TEST_TIMEOUT_MS, skip: skipWithoutModels },
+  async (t) => {
+    const sourceAudio = resolveRefWavPath({})
+    if (!hasEncoder()) {
+      t.comment(`skipping: no moss-codec-encoder GGUF in ${modelDir}`)
+      return
+    }
+    if (!fs.existsSync(sourceAudio)) {
+      t.fail(`MOSS reference audio is missing: ${sourceAudio}`)
+      return
+    }
+    const referenceAudio = writeReferenceAtMossRate(sourceAudio)
+    try {
+      await withLoadedModel({ referenceAudio, seed: 7 }, async (model) => {
+        const started = Date.now()
+        const result = await synthesize(model, SYNTHESIS_TEXT)
+        assertAudio(t, 'MOSS clone', result)
+        recordMoss(t, 'moss clone', result, Date.now() - started)
+      })
+    } finally {
+      fs.unlinkSync(referenceAudio)
+    }
+  }
+)
+
+test(
+  'MOSS TTS: durationTokens steers the length of the synthesized speech',
+  { timeout: TEST_TIMEOUT_MS, skip: skipWithoutModels || NO_GPU },
+  async (t) => {
+    await withLoadedModel(
+      { durationTokens: SHORT_DURATION_TOKENS, seed: 7 },
+      async (model) => {
+        const short = await synthesize(model, SYNTHESIS_TEXT)
+        assertAudio(t, 'MOSS short target', short)
+        await model.reload({ durationTokens: LONG_DURATION_TOKENS })
+        const long = await synthesize(model, SYNTHESIS_TEXT)
+        assertAudio(t, 'MOSS long target', long)
+        t.ok(
+          long.samples.length > short.samples.length,
+          `a longer target yields longer speech (${short.samples.length} -> ${long.samples.length} samples)`
+        )
+      },
+      GPU_ONLY_USE_GPU
+    )
+  }
+)
+
+test(
+  'MOSS TTS: dialogue synthesis clones one reference per speaker',
+  { timeout: TEST_TIMEOUT_MS, skip: skipWithoutModels || NO_GPU },
+  async (t) => {
+    if (!hasDialogueBackbone() || !hasEncoder()) {
+      t.comment(`skipping: the TTSD backbone or the codec encoder is not in ${modelDir}`)
+      return
+    }
+    const sourceAudio = resolveRefWavPath({})
+    if (!fs.existsSync(sourceAudio)) {
+      t.fail(`MOSS reference audio is missing: ${sourceAudio}`)
+      return
+    }
+    const references = writeSpeakerReferences(sourceAudio)
+    try {
+      await withLoadedModel(
+        { dialogueReferences: references, seed: 7, files: { modelDir: path.resolve(modelDir) } },
+        async (model) => {
+          t.ok(
+            DIALOGUE_BACKBONE_RE.test(path.basename(model._mossBackbonePath)),
+            'dialogue picks the TTSD backbone'
+          )
+          const started = Date.now()
+          const result = await synthesize(model, DIALOGUE_TEXT)
+          assertAudio(t, 'MOSS dialogue', result)
+          recordMoss(t, 'moss dialogue', result, Date.now() - started)
+        },
+        GPU_ONLY_USE_GPU
+      )
+    } finally {
+      removeFiles(references)
+    }
+  }
+)