@qvac/tts-ggml 0.12.0 → 0.14.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/gpu-smoke.test.js

@@ -46,15 +46,11 @@ const {
 } = require('../utils/downloadModel')
 const { recordTtsStats } = require('../utils/perf-helper')
 const { TTS_TEST_THREADS } = require('../utils/testThreads')
+const { assertDesktopGpuBackend } = require('../utils/desktopGpuBackend')
 
 const platform = os.platform()
 const isMobile = platform === 'ios' || platform === 'android'
 const isApple = platform === 'darwin' || platform === 'ios'
-const GPU_BACKEND_IDS = { metal: 1, cuda: 2, vulkan: 3, opencl: 4 }
-// CI rows whose prebuild bundles more than one usable GPU backend (the linux
-// runners carry CUDA and Vulkan) pin the engine cascade through
-// TTS_CPP_GPU_BACKEND; the assertions expect whatever the row pinned and fall
-// back to the platform's cascade default when unset.
 const PINNED_GPU_BACKEND = (proc.env && proc.env.TTS_CPP_GPU_BACKEND) || ''
 // Parler GPU coverage is validated on Apple, the Android Device Farm, and the
 // linux CUDA lane. Keep desktop Vulkan out until dedicated runs prove it there.
@@ -153,12 +149,7 @@ function assertGpuBackend(t, engineTag, stats, allowPolicyCpu = false) {
   if (platform === 'darwin' || platform === 'ios') {
     t.is(id, 1, `${engineTag}/${platform}: expected Metal backendId=1, got ${name}`)
   } else if (platform === 'linux' || platform === 'win32') {
-    const expectedId = GPU_BACKEND_IDS[PINNED_GPU_BACKEND] || GPU_BACKEND_IDS.vulkan
-    t.is(
-      id,
-      expectedId,
-      `${engineTag}/${platform}: expected ${backendIdToName(expectedId)} backendId=${expectedId}, got ${name}`
-    )
+    assertDesktopGpuBackend(t, `${engineTag}/${platform}`, dev, id, PINNED_GPU_BACKEND)
   } else if (platform === 'android') {
     t.ok(
       id === 3 || id === 4,

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

@@ -34,6 +34,7 @@ const {
 const { resolveRefWavPath } = require('../utils/runChatterboxTTS')
 const { TTS_TEST_THREADS } = require('../utils/testThreads')
 const { GPU_ONLY_USE_GPU } = require('../utils/gpuOnly')
+const { assertDesktopGpuBackend } = require('../utils/desktopGpuBackend')
 
 const platform = os.platform()
 const isMobile = platform === 'ios' || platform === 'android'
@@ -42,11 +43,6 @@ const isMobile = platform === 'ios' || platform === 'android'
 // fallback from a failure to a warning (e.g. a Linux host with no Vulkan SDK).
 const NO_GPU = proc.env && proc.env.NO_GPU === 'true'
 const RELAX = proc.env && proc.env.QVAC_TTS_GPU_SMOKE_RELAX === '1'
-const GPU_BACKEND_IDS = { metal: 1, cuda: 2, vulkan: 3, opencl: 4 }
-// CI rows whose prebuild bundles more than one usable GPU backend (the linux
-// runners carry CUDA and Vulkan) pin the engine cascade through
-// TTS_CPP_GPU_BACKEND; the enhancer assertion expects whatever the row pinned
-// and falls back to the platform's cascade default when unset.
 const PINNED_GPU_BACKEND = (proc.env && proc.env.TTS_CPP_GPU_BACKEND) || ''
 
 const ENHANCED_RATE = 48000
@@ -92,10 +88,6 @@ function expectsGpu() {
   )
 }
 
-function expectedDesktopEnhancerBackendId() {
-  return GPU_BACKEND_IDS[PINNED_GPU_BACKEND] || GPU_BACKEND_IDS.vulkan
-}
-
 // Strict check that the LavaSR *enhancer* network engaged the GPU. Reads the
 // enhancer-specific backend surfaced by ChatterboxModel/SupertonicModel
 // runtimeStats (enhancerBackendDevice: -1 none / 0 CPU / 1 GPU;
@@ -134,12 +126,7 @@ function assertEnhancerGpuBackend(t, stats) {
   if (platform === 'darwin' || platform === 'ios') {
     t.is(id, 1, `enhancer/${platform}: expected Metal backendId=1, got ${backendIdToName(id)}`)
   } else if (platform === 'linux' || platform === 'win32') {
-    const expectedId = expectedDesktopEnhancerBackendId()
-    t.is(
-      id,
-      expectedId,
-      `enhancer/${platform}: expected ${backendIdToName(expectedId)} backendId=${expectedId}, got ${backendIdToName(id)}`
-    )
+    assertDesktopGpuBackend(t, `enhancer/${platform}`, dev, id, PINNED_GPU_BACKEND)
   } else if (platform === 'android') {
     t.ok(
       id === 3 || id === 4,

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-sfx.test.js

@@ -1,10 +1,12 @@
 'use strict'
 
 const path = require('bare-path')
+const fs = require('bare-fs')
 const proc = require('bare-process')
 const test = require('brittle')
 
 const TTSGgml = require('@qvac/tts-ggml')
+const { assertMossBackend } = require('../utils/mossBackend')
 
 const SFX_SAMPLE_RATE = 48000
 const TENTHS_PER_SECOND = 10
@@ -14,13 +16,35 @@ const MODEL_DIR_ENV = 'QVAC_TEST_MOSS_SFX_MODEL_DIR'
 const QUICK_STEPS = 2
 const SHORT_SECONDS = 1.5
 const LONGER_SECONDS = 2.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'
 
+if (proc.env && proc.env.QVAC_TEST_MOSS_FULL_GPU === 'true') {
+  if (noGpu || !['cuda', 'vulkan', 'metal', 'opencl'].includes(PINNED_GPU_BACKEND.toLowerCase())) {
+    throw new Error(
+      'MOSS-SFX full GPU validation requires an explicit GPU backend and NO_GPU=false'
+    )
+  }
+  if (
+    !modelDir ||
+    !fs.existsSync(modelDir) ||
+    !fs
+      .readdirSync(modelDir)
+      .some(
+        (name) =>
+          /^moss-sfx(-[a-z0-9_]+)*\.gguf$/i.test(name) &&
+          fs.statSync(path.join(modelDir, name)).isFile()
+      )
+  ) {
+    throw new Error(
+      'MOSS-SFX full GPU validation requires QVAC_TEST_MOSS_SFX_MODEL_DIR with a GGUF'
+    )
+  }
+}
+
 function createSfxModel(useGPU = false) {
   return new TTSGgml({
     engine: TTSGgml.ENGINE_MOSS_SFX,
@@ -70,7 +94,7 @@ test(
     try {
       const result = await generate(model, { seconds: SHORT_SECONDS })
       assertClip(t, 'cpu clip', result, SHORT_SECONDS)
-      t.is(result.stats.backendDevice, CPU_DEVICE, 'the clip ran on the CPU')
+      assertMossBackend(t, 'cpu clip', result.stats, false, PINNED_GPU_BACKEND)
     } finally {
       await model.unload()
     }
@@ -88,7 +112,8 @@ test(
       const longer = await generate(model, { seconds: LONGER_SECONDS, negativePrompt: 'music' })
       assertClip(t, 'short clip', short, SHORT_SECONDS)
       assertClip(t, 'longer clip', longer, LONGER_SECONDS)
-      t.is(short.stats.backendDevice, GPU_DEVICE, 'the clips ran on the GPU')
+      assertMossBackend(t, 'short clip', short.stats, true, PINNED_GPU_BACKEND)
+      assertMossBackend(t, 'longer clip', longer.stats, true, PINNED_GPU_BACKEND)
     } finally {
       await model.unload()
     }

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'])
+  })
+}