@qvac/tts-ggml 0.11.1 → 0.13.0

package/test/integration/fit.test.js

@@ -64,7 +64,7 @@ test('a projection is internally consistent', { timeout: TEST_TIMEOUT_MS }, asyn
   const model = await supertonicPath(t)
   if (model === null) return
 
-  const fit = TTSGgml.assessFit({
+  const fit = await TTSGgml.assessFit({
     engineType: 'supertonic',
     supertonicModelPath: model,
     useGPU: true
@@ -84,13 +84,13 @@ test('a weightless copy projects the same', { timeout: TEST_TIMEOUT_MS }, async
   const model = await supertonicPath(t)
   if (model === null) return
 
-  const full = TTSGgml.assessFit({
+  const full = await TTSGgml.assessFit({
     engineType: 'supertonic',
     supertonicModelPath: model,
     useGPU: true
   })
   if (!projected(t, full)) return
-  const stub = TTSGgml.assessFit({
+  const stub = await TTSGgml.assessFit({
     engineType: 'supertonic',
     supertonicModelPath: weightlessCopy(tempDir(t), model, 1024 * 1024),
     useGPU: true
@@ -106,12 +106,12 @@ test('the load’s offload keys reach the projection', { timeout: TEST_TIMEOUT_M
   const model = await supertonicPath(t)
   if (model === null) return
 
-  const cpu = TTSGgml.assessFit({
+  const cpu = await TTSGgml.assessFit({
     engineType: 'supertonic',
     supertonicModelPath: model,
     useGPU: false
   })
-  const pinned = TTSGgml.assessFit({
+  const pinned = await TTSGgml.assessFit({
     engineType: 'supertonic',
     supertonicModelPath: model,
     nGpuLayers: 0
@@ -129,7 +129,7 @@ test('a LavaSR stage is sized beside the projection', { timeout: TEST_TIMEOUT_MS
   const enhancer = path.join(dir, 'enhancer.gguf')
   fs.writeFileSync(enhancer, Buffer.alloc(4096, 1))
 
-  const fit = TTSGgml.assessFit({
+  const fit = await TTSGgml.assessFit({
     engineType: 'supertonic',
     supertonicModelPath: model,
     useGPU: true,
@@ -141,8 +141,97 @@ test('a LavaSR stage is sized beside the projection', { timeout: TEST_TIMEOUT_MS
   t.ok(fit.lavasrFileBytes < fit.deviceBytes, 'reported beside the projection')
 })
 
-test('MOSS routes to its fitter when a model cannot be read', (t) => {
-  const fit = TTSGgml.assessFit({
+test('fitting keeps the event loop responsive', { timeout: TEST_TIMEOUT_MS }, async (t) => {
+  const model = await supertonicPath(t)
+  if (model === null) return
+
+  const request = { engineType: 'supertonic', supertonicModelPath: model, useGPU: true }
+
+  let pending = true
+  let turns = 0
+  const spin = () => {
+    if (!pending) return
+    turns++
+    setImmediate(spin)
+  }
+  setImmediate(spin)
+
+  const first = TTSGgml.assessFit(request)
+  t.ok(first instanceof Promise, 'the call returns before the projection')
+  const fits = await Promise.all([
+    first,
+    ...Array.from({ length: 15 }, () => TTSGgml.assessFit(request))
+  ])
+  pending = false
+
+  t.comment(`${turns} loop turns before the fits settled`)
+  t.ok(turns > 0, 'the loop turned while the fitter ran')
+  for (const fit of fits) {
+    t.not(fit.reason, 'model-unreadable', 'every queued projection ran')
+  }
+})
+
+test(
+  'concurrent fits keep their own requests and all settle',
+  { timeout: TEST_TIMEOUT_MS },
+  async (t) => {
+    const model = await supertonicPath(t)
+    if (model === null) return
+
+    const dir = tempDir(t)
+    const enhancer = path.join(dir, 'enhancer.gguf')
+    fs.writeFileSync(enhancer, Buffer.alloc(4096, 1))
+
+    const request = {
+      engineType: 'supertonic',
+      supertonicModelPath: model,
+      useGPU: false,
+      lavasrEnhancerPath: enhancer
+    }
+    const first = TTSGgml.assessFit(request)
+    request.lavasrEnhancerPath = ''
+    const second = TTSGgml.assessFit(request)
+    const missing = TTSGgml.assessFit({
+      engineType: 'supertonic',
+      supertonicModelPath: '/nonexistent/model.gguf'
+    })
+    const [a, b, c] = await Promise.all([first, second, missing])
+
+    t.is(a.lavasrFileBytes, 4096, 'the first call owns its original request')
+    t.is(b.lavasrFileBytes, 0, 'the second call owns its changed request')
+    t.is(c.status, 'error', 'an error outcome does not strand queued callers')
+  }
+)
+
+test('a fit settles while a loaded model unloads', { timeout: TEST_TIMEOUT_MS }, async (t) => {
+  const model = await supertonicPath(t)
+  if (model === null) return
+
+  const voice = new TTSGgml({
+    engine: TTSGgml.ENGINE_SUPERTONIC,
+    files: { supertonicModel: model },
+    voice: 'F1',
+    config: { language: 'en', useGPU: false }
+  })
+  await voice.load()
+  try {
+    const fit = TTSGgml.assessFit({
+      engineType: 'supertonic',
+      supertonicModelPath: model,
+      useGPU: false
+    })
+    await voice.unload()
+    const result = await fit
+    t.ok(result.deviceTotalBytes > 0, 'the projection measured a device')
+  } finally {
+    try {
+      await voice.unload()
+    } catch (_e) {}
+  }
+})
+
+test('MOSS routes to its fitter when a model cannot be read', async (t) => {
+  const fit = await TTSGgml.assessFit({
     engineType: 'moss',
     mossBackbonePath: '/models/moss-tts-delay.gguf',
     mossCodecDecoderPath: '/models/moss-codec-decoder.gguf',
@@ -156,8 +245,8 @@ test('MOSS routes to its fitter when a model cannot be read', (t) => {
   t.is(fit.modelVariant, 'moss')
 })
 
-test('a model that cannot be read is an outcome, not a throw', (t) => {
-  const fit = TTSGgml.assessFit({
+test('a model that cannot be read is an outcome, not a rejection', async (t) => {
+  const fit = await TTSGgml.assessFit({
     engineType: 'supertonic',
     supertonicModelPath: '/nonexistent/model.gguf'
   })
@@ -165,14 +254,22 @@ test('a model that cannot be read is an outcome, not a throw', (t) => {
   t.is(fit.status, 'error')
 })
 
-test('a count that is not a count is refused', (t) => {
-  t.exception(
-    () =>
-      TTSGgml.assessFit({
-        engineType: 'supertonic',
-        supertonicModelPath: '/models/supertonic.gguf',
-        textTokens: -1
-      }),
+test('a count that is not a count is refused', async (t) => {
+  await t.exception(
+    TTSGgml.assessFit({
+      engineType: 'supertonic',
+      supertonicModelPath: '/models/supertonic.gguf',
+      textTokens: -1
+    }),
     /non-negative count/
   )
 })
+
+test('a broken request rejects', async (t) => {
+  let promise
+  t.execution(() => {
+    promise = TTSGgml.assessFit({})
+  }, 'the call itself does not throw')
+  t.ok(promise instanceof Promise)
+  await t.exception(promise, /engineType is required/)
+})

package/test/integration/moss-fit.test.js

@@ -5,7 +5,7 @@ const process = require('bare-process')
 const test = require('brittle')
 const TTSGgml = require('@qvac/tts-ggml')
 
-test('MOSS fit requires explicit, representable workload counts', (t) => {
+test('MOSS fit requires explicit, representable workload counts', async (t) => {
   const request = {
     engineType: 'moss',
     mossBackbonePath: '/models/moss-tts-delay.gguf',
@@ -15,18 +15,18 @@ test('MOSS fit requires explicit, representable workload counts', (t) => {
     streaming: false
   }
   for (const invalid of [NaN, Infinity, -1, 0.5, 2147483648]) {
-    t.exception(() => TTSGgml.assessFit({ ...request, promptRows: invalid }))
-    t.exception(() => TTSGgml.assessFit({ ...request, referenceSamples: invalid }))
+    await t.exception(TTSGgml.assessFit({ ...request, promptRows: invalid }))
+    await t.exception(TTSGgml.assessFit({ ...request, referenceSamples: invalid }))
   }
-  t.exception(() => TTSGgml.assessFit({ ...request, promptRows: undefined }))
-  t.exception(() => TTSGgml.assessFit({ ...request, streaming: undefined }))
-  t.exception(() => TTSGgml.assessFit({ ...request, threads: -1 }))
-  t.exception(() => TTSGgml.assessFit({ ...request, durationTokens: -1 }))
-  t.exception(() => TTSGgml.assessFit({ ...request, streamChunkTokens: -1 }))
-  t.exception(() => TTSGgml.assessFit({ ...request, useGPU: true, nGpuLayers: 0 }))
+  await t.exception(TTSGgml.assessFit({ ...request, promptRows: undefined }))
+  await t.exception(TTSGgml.assessFit({ ...request, streaming: undefined }))
+  await t.exception(TTSGgml.assessFit({ ...request, threads: -1 }))
+  await t.exception(TTSGgml.assessFit({ ...request, durationTokens: -1 }))
+  await t.exception(TTSGgml.assessFit({ ...request, streamChunkTokens: -1 }))
+  await t.exception(TTSGgml.assessFit({ ...request, useGPU: true, nGpuLayers: 0 }))
 })
 
-test('MOSS metadata-only fit covers batch, streaming and cloning', (t) => {
+test('MOSS metadata-only fit covers batch, streaming and cloning', async (t) => {
   const modelDir = process.env.QVAC_TEST_MOSS_MODEL_DIR
   if (!modelDir) {
     t.comment('Set QVAC_TEST_MOSS_MODEL_DIR to exercise real MOSS GGUFs')
@@ -40,14 +40,14 @@ test('MOSS metadata-only fit covers batch, streaming and cloning', (t) => {
     referenceSamples: 0,
     streaming: false
   }
-  const batch = TTSGgml.assessFit(request)
+  const batch = await TTSGgml.assessFit(request)
   t.not(batch.status, 'error', batch.report)
   t.ok(batch.weightsBytes > 0)
   t.ok(batch.lmComputeBytes > 0)
   t.ok(batch.codecComputeBytes > 0)
-  const stream = TTSGgml.assessFit({ ...request, streaming: true })
+  const stream = await TTSGgml.assessFit({ ...request, streaming: true })
   t.not(stream.status, 'error', stream.report)
-  const cloning = TTSGgml.assessFit({
+  const cloning = await TTSGgml.assessFit({
     ...request,
     mossCodecEncoderPath: path.join(modelDir, 'moss-codec-encoder-f16.gguf'),
     referenceSamples: 24000

package/test/integration/moss-sfx-fit.test.js

@@ -15,17 +15,17 @@ function request(overrides = {}) {
   }
 }
 
-test('MOSS sound-effect fit rejects missing workload and invalid load controls', (t) => {
-  t.exception(() => TTSGgml.assessFit(request({ prompt: undefined })))
-  t.exception(() => TTSGgml.assessFit(request({ seconds: undefined })))
-  t.exception(() => TTSGgml.assessFit(request({ seconds: NaN })))
-  t.exception(() => TTSGgml.assessFit(request({ threads: -1 })))
-  t.exception(() => TTSGgml.assessFit(request({ useGPU: true, nGpuLayers: 0 })))
-  t.exception(() => TTSGgml.assessFit(request({ marginBytes: -1 })))
+test('MOSS sound-effect fit rejects missing workload and invalid load controls', async (t) => {
+  await t.exception(TTSGgml.assessFit(request({ prompt: undefined })))
+  await t.exception(TTSGgml.assessFit(request({ seconds: undefined })))
+  await t.exception(TTSGgml.assessFit(request({ seconds: NaN })))
+  await t.exception(TTSGgml.assessFit(request({ threads: -1 })))
+  await t.exception(TTSGgml.assessFit(request({ useGPU: true, nGpuLayers: 0 })))
+  await t.exception(TTSGgml.assessFit(request({ marginBytes: -1 })))
 })
 
-test('MOSS sound-effect fit reports unreadable models', (t) => {
-  const fit = TTSGgml.assessFit(request())
+test('MOSS sound-effect fit reports unreadable models', async (t) => {
+  const fit = await TTSGgml.assessFit(request())
   t.is(fit.status, 'error')
   t.is(fit.reason, 'model-unreadable')
   t.is(fit.modelVariant, 'moss-sfx')
@@ -36,10 +36,10 @@ test(
   {
     skip: !process.env.QVAC_TEST_MOSS_SFX_GGUF
   },
-  (t) => {
+  async (t) => {
     const model = process.env.QVAC_TEST_MOSS_SFX_GGUF
     const cfg = { mossSoundEffectPath: model }
-    const fit = TTSGgml.assessFit(request(cfg))
+    const fit = await TTSGgml.assessFit(request(cfg))
     t.ok(fit.status === 'fits' || fit.status === 'does-not-fit')
     t.is(fit.modelVariant, 'moss-sfx')
     t.ok(fit.deviceIsCpu)
@@ -51,12 +51,12 @@ test(
       fit.deviceBytes,
       fit.weightsBytes + fit.stateBytes + fit.lmComputeBytes + fit.codecComputeBytes
     )
-    const shorter = TTSGgml.assessFit(request({ ...cfg, seconds: 1 }))
+    const shorter = await TTSGgml.assessFit(request({ ...cfg, seconds: 1 }))
     t.is(shorter.weightsBytes, fit.weightsBytes)
     t.is(shorter.lmComputeBytes, fit.lmComputeBytes)
-    const noHeadroom = TTSGgml.assessFit(request({ ...cfg, marginBytes: Number.MAX_VALUE }))
+    const noHeadroom = await TTSGgml.assessFit(request({ ...cfg, marginBytes: Number.MAX_VALUE }))
     t.is(noHeadroom.status, 'does-not-fit')
-    const invalid = TTSGgml.assessFit(request({ ...cfg, seconds: 0 }))
+    const invalid = await TTSGgml.assessFit(request({ ...cfg, seconds: 0 }))
     t.is(invalid.status, 'error')
     t.is(invalid.reason, 'invalid-arguments')
   }

package/test/integration/moss-speech.test.js

@@ -8,6 +8,9 @@ const TTSGgml = require('@qvac/tts-ggml')
 const { resolveRefWavPath } = require('../utils/runChatterboxTTS')
 const { readWavAsFloat32 } = require('../utils/wav-helper')
 const { TTS_TEST_THREADS } = require('../utils/testThreads')
+const { assertMossBackend } = require('../utils/mossBackend')
+const { createMossGpuValidation } = require('../utils/mossGpuValidation')
+const { GPU_ONLY_USE_GPU } = require('../utils/gpuOnly')
 
 const SPEECH_SAMPLE_RATE = 24000
 const TEST_TIMEOUT_MS = 1800000
@@ -15,12 +18,13 @@ const MODEL_DIR_ENV = 'QVAC_TEST_MOSS_SPEECH_MODEL_DIR'
 const MAX_NEW_TOKENS = 120
 const CUT_SECONDS = 2
 const CUT_MARGIN_SECONDS = 0.5
-const CPU_DEVICE = 0
-const GPU_DEVICE = 1
+const PINNED_GPU_BACKEND = (proc.env && proc.env.TTS_CPP_GPU_BACKEND) || ''
 
 const modelDir = (proc.env && proc.env[MODEL_DIR_ENV]) || ''
 const skipWithoutModels = modelDir === ''
 const noGpu = proc.env && proc.env.NO_GPU === 'true'
+const sourceAudio = resolveRefWavPath({})
+const validation = createMossGpuValidation(proc.env || {}, sourceAudio, GPU_ONLY_USE_GPU)
 
 function createSpeechModel(useGPU = false) {
   return new TTSGgml({
@@ -34,7 +38,7 @@ function createSpeechModel(useGPU = false) {
 }
 
 function spokenQuestion() {
-  const wav = readWavAsFloat32(resolveRefWavPath({}))
+  const wav = readWavAsFloat32(sourceAudio)
   return { audio: wav.samples, sampleRate: wav.sampleRate }
 }
 
@@ -75,10 +79,11 @@ test(
     try {
       const result = await respond(model, spokenQuestion())
       assertSpokenReply(t, 'cpu reply', result)
-      t.is(result.stats.backendDevice, CPU_DEVICE, 'the reply ran on the CPU')
+      assertMossBackend(t, 'cpu reply', result.stats, false, PINNED_GPU_BACKEND)
     } finally {
       await model.unload()
     }
+    validation.completed('CPU spoken reply')
   }
 )
 
@@ -92,6 +97,7 @@ test(
       const textReply = await respond(model, { ...spokenQuestion(), textReply: true })
       t.is(textReply.samples, 0, 'a text reply carries no audio')
       t.ok(textReply.text.trim().length > 0, 'a text reply carries the answer')
+      assertMossBackend(t, 'text reply', textReply.stats, true, PINNED_GPU_BACKEND)
 
       const cut = await respond(model, { ...spokenQuestion(), maxReplySeconds: CUT_SECONDS })
       assertSpokenReply(t, 'cut reply', cut)
@@ -99,12 +105,20 @@ test(
         cut.samples <= (CUT_SECONDS + CUT_MARGIN_SECONDS) * SPEECH_SAMPLE_RATE,
         'maxReplySeconds bounds the spoken reply'
       )
-      t.is(cut.stats.backendDevice, GPU_DEVICE, 'the replies ran on the GPU')
+      assertMossBackend(t, 'cut reply', cut.stats, true, PINNED_GPU_BACKEND)
 
       const typed = await respond(model, { input: 'What is the capital of France?' })
       assertSpokenReply(t, 'reply to a typed question', typed)
+      assertMossBackend(t, 'typed reply', typed.stats, true, PINNED_GPU_BACKEND)
     } finally {
       await model.unload()
     }
+    validation.completed('GPU text/audio replies and reply cuts')
   }
 )
+
+if (validation.enabled) {
+  test('MOSS-Speech: full GPU validation completed every required case', (t) => {
+    validation.assertComplete(t, ['CPU spoken reply', 'GPU text/audio replies and reply cuts'])
+  })
+}

package/test/integration/moss.test.js

@@ -12,6 +12,12 @@ 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 { assertMossBackend } = require('../utils/mossBackend')
+const {
+  createMossGpuValidation,
+  ENCODER_RE,
+  DIALOGUE_BACKBONE_RE
+} = require('../utils/mossGpuValidation')
 
 const MOSS_SAMPLE_RATE = 24000
 const MOSS_STREAM_FRAMES = 10
@@ -19,8 +25,6 @@ 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.'
@@ -29,12 +33,12 @@ 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 PINNED_GPU_BACKEND = (proc.env && proc.env.TTS_CPP_GPU_BACKEND) || ''
 
 const modelDir = (proc.env && proc.env[MODEL_DIR_ENV]) || ''
 const skipWithoutModels = modelDir === ''
+const sourceAudio = resolveRefWavPath({})
+const validation = createMossGpuValidation(proc.env || {}, sourceAudio, GPU_ONLY_USE_GPU)
 
 function createMossModel(extra = {}, useGPU = false) {
   return new TTSGgml({
@@ -133,9 +137,8 @@ function recordMoss(t, label, result, wallMs) {
   )
 }
 
-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`)
+function assertBackend(t, label, stats, useGPU = false) {
+  assertMossBackend(t, label, stats, useGPU, PINNED_GPU_BACKEND)
 }
 
 async function withLoadedModel(extra, body, useGPU = false) {
@@ -156,31 +159,40 @@ test(
       const started = Date.now()
       const result = await synthesize(model, SYNTHESIS_TEXT)
       assertAudio(t, 'MOSS batch', result)
-      assertCpuBackend(t, 'MOSS batch', result.stats)
+      assertBackend(t, 'MOSS batch', result.stats)
       t.is(nonEmptyChunks(result).length, 1, 'batch synthesis emits one buffer')
       recordMoss(t, 'moss batch', result, Date.now() - started)
     })
+    validation.completed('CPU batch')
   }
 )
 
-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'
+for (const useGPU of [false, true]) {
+  test(
+    `MOSS TTS: native chunk streaming emits frame-sized chunks (${useGPU ? 'GPU' : 'CPU'})`,
+    { timeout: TEST_TIMEOUT_MS, skip: skipWithoutModels || (useGPU && NO_GPU) },
+    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)
+          assertBackend(t, 'MOSS stream', result.stats, useGPU)
+          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)
+        },
+        useGPU
       )
-      recordMoss(t, 'moss stream', result, Date.now() - started)
-    })
-  }
-)
+      validation.completed(`${useGPU ? 'GPU' : 'CPU'} streaming`)
+    }
+  )
+}
 
 test(
   'MOSS TTS: useGPU=true synthesizes on a GPU backend',
@@ -192,42 +204,48 @@ test(
         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')
+        assertBackend(t, 'MOSS GPU', result.stats, true)
         recordMoss(t, 'moss gpu', result, Date.now() - started)
       },
       true
     )
+    validation.completed('GPU batch')
   }
 )
 
-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)
+for (const useGPU of [false, true]) {
+  test(
+    `MOSS TTS: voice cloning synthesizes from a reference recording (${useGPU ? 'GPU' : 'CPU'})`,
+    { timeout: TEST_TIMEOUT_MS, skip: skipWithoutModels || (useGPU && NO_GPU) },
+    async (t) => {
+      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)
+            assertBackend(t, 'MOSS clone', result.stats, useGPU)
+            recordMoss(t, 'moss clone', result, Date.now() - started)
+          },
+          useGPU
+        )
+      } finally {
+        fs.unlinkSync(referenceAudio)
+      }
+      validation.completed(`${useGPU ? 'GPU' : 'CPU'} cloning`)
     }
-  }
-)
+  )
+}
 
 test(
   'MOSS TTS: durationTokens steers the length of the synthesized speech',
@@ -238,9 +256,11 @@ test(
       async (model) => {
         const short = await synthesize(model, SYNTHESIS_TEXT)
         assertAudio(t, 'MOSS short target', short)
+        assertBackend(t, 'MOSS short target', short.stats, GPU_ONLY_USE_GPU)
         await model.reload({ durationTokens: LONG_DURATION_TOKENS })
         const long = await synthesize(model, SYNTHESIS_TEXT)
         assertAudio(t, 'MOSS long target', long)
+        assertBackend(t, 'MOSS long target', long.stats, GPU_ONLY_USE_GPU)
         t.ok(
           long.samples.length > short.samples.length,
           `a longer target yields longer speech (${short.samples.length} -> ${long.samples.length} samples)`
@@ -248,6 +268,7 @@ test(
       },
       GPU_ONLY_USE_GPU
     )
+    validation.completed('GPU duration/reload')
   }
 )
 
@@ -259,7 +280,6 @@ test(
       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
@@ -276,6 +296,7 @@ test(
           const started = Date.now()
           const result = await synthesize(model, DIALOGUE_TEXT)
           assertAudio(t, 'MOSS dialogue', result)
+          assertBackend(t, 'MOSS dialogue', result.stats, GPU_ONLY_USE_GPU)
           recordMoss(t, 'moss dialogue', result, Date.now() - started)
         },
         GPU_ONLY_USE_GPU
@@ -283,5 +304,21 @@ test(
     } finally {
       removeFiles(references)
     }
+    validation.completed('GPU TTSD dialogue')
   }
 )
+
+if (validation.enabled) {
+  test('MOSS TTS: full GPU validation completed every required case', (t) => {
+    validation.assertComplete(t, [
+      'CPU batch',
+      'CPU streaming',
+      'GPU streaming',
+      'GPU batch',
+      'CPU cloning',
+      'GPU cloning',
+      'GPU duration/reload',
+      'GPU TTSD dialogue'
+    ])
+  })
+}

package/test/mobile/integration.auto.cjs

@@ -50,6 +50,14 @@ async function runLavasrEnhancerTest (options = {}) { // eslint-disable-line no-
   return runIntegrationModule('../integration/lavasr-enhancer.test.js', options)
 }
 
+async function runMossFitTest (options = {}) { // eslint-disable-line no-unused-vars
+  return runIntegrationModule('../integration/moss-fit.test.js', options)
+}
+
+async function runMossSfxFitTest (options = {}) { // eslint-disable-line no-unused-vars
+  return runIntegrationModule('../integration/moss-sfx-fit.test.js', options)
+}
+
 async function runMossSfxTest (options = {}) { // eslint-disable-line no-unused-vars
   return runIntegrationModule('../integration/moss-sfx.test.js', options)
 }
@@ -118,6 +126,8 @@ module.exports = {
   runFitTest,
   runGpuSmokeTest,
   runLavasrEnhancerTest,
+  runMossFitTest,
+  runMossSfxFitTest,
   runMossSfxTest,
   runMossSpeechTest,
   runMossTest,

package/test/mobile/test-groups.json

@@ -33,7 +33,9 @@
       "runMultipleRunsTest",
       "runGpuSmokeTest",
       "runOutputSampleRateTest",
-      "runVoiceControlsTest"
+      "runVoiceControlsTest",
+      "runMossFitTest",
+      "runMossSfxFitTest"
     ]
   },
   "android": {
@@ -69,7 +71,9 @@
       "runMultipleRunsTest",
       "runGpuSmokeTest",
       "runOutputSampleRateTest",
-      "runVoiceControlsTest"
+      "runVoiceControlsTest",
+      "runMossFitTest",
+      "runMossSfxFitTest"
     ]
   }
 }