@qvac/tts-ggml 0.10.0 → 0.11.0

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

@@ -0,0 +1,63 @@
+'use strict'
+
+const test = require('brittle')
+const process = require('bare-process')
+const TTSGgml = require('@qvac/tts-ggml')
+
+function request(overrides = {}) {
+  return {
+    engineType: 'moss-sfx',
+    mossSoundEffectPath: '/nonexistent/moss-sfx.gguf',
+    prompt: 'Rain on a tin roof.',
+    seconds: 8,
+    useGPU: false,
+    ...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 reports unreadable models', (t) => {
+  const fit = TTSGgml.assessFit(request())
+  t.is(fit.status, 'error')
+  t.is(fit.reason, 'model-unreadable')
+  t.is(fit.modelVariant, 'moss-sfx')
+})
+
+test(
+  'MOSS sound-effect fit projects real-model CPU workloads',
+  {
+    skip: !process.env.QVAC_TEST_MOSS_SFX_GGUF
+  },
+  (t) => {
+    const model = process.env.QVAC_TEST_MOSS_SFX_GGUF
+    const cfg = { mossSoundEffectPath: model }
+    const fit = TTSGgml.assessFit(request(cfg))
+    t.ok(fit.status === 'fits' || fit.status === 'does-not-fit')
+    t.is(fit.modelVariant, 'moss-sfx')
+    t.ok(fit.deviceIsCpu)
+    t.ok(fit.deviceSharesHostMemory)
+    t.ok(fit.weightsBytes > 0)
+    t.ok(fit.lmComputeBytes > 0)
+    t.ok(fit.hostBytes > 0)
+    t.is(
+      fit.deviceBytes,
+      fit.weightsBytes + fit.stateBytes + fit.lmComputeBytes + fit.codecComputeBytes
+    )
+    const shorter = 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 }))
+    t.is(noHeadroom.status, 'does-not-fit')
+    const invalid = TTSGgml.assessFit(request({ ...cfg, seconds: 0 }))
+    t.is(invalid.status, 'error')
+    t.is(invalid.reason, 'invalid-arguments')
+  }
+)

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

@@ -0,0 +1,96 @@
+'use strict'
+
+const path = require('bare-path')
+const proc = require('bare-process')
+const test = require('brittle')
+
+const TTSGgml = require('@qvac/tts-ggml')
+
+const SFX_SAMPLE_RATE = 48000
+const TENTHS_PER_SECOND = 10
+const TEST_TIMEOUT_MS = 1800000
+const PROMPT = 'A glass falls and shatters on a tile floor.'
+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 modelDir = (proc.env && proc.env[MODEL_DIR_ENV]) || ''
+const skipWithoutModels = modelDir === ''
+const noGpu = proc.env && proc.env.NO_GPU === 'true'
+
+function createSfxModel(useGPU = false) {
+  return new TTSGgml({
+    engine: TTSGgml.ENGINE_MOSS_SFX,
+    files: { modelDir: path.resolve(modelDir) },
+    config: { useGPU },
+    seed: 0,
+    opts: { stats: true }
+  })
+}
+
+function collectChunk(result, data) {
+  if (!data || !data.outputArray) return
+  result.samples += data.outputArray.length
+  if (data.sampleRate) result.sampleRate = data.sampleRate
+}
+
+async function generate(model, fields) {
+  const response = await model.run({ input: PROMPT, type: 'text', steps: QUICK_STEPS, ...fields })
+  const result = { samples: 0, sampleRate: null }
+  await response.onUpdate((data) => collectChunk(result, data)).await()
+  result.stats = response.stats
+  return result
+}
+
+function samplesAtNativeDuration(seconds) {
+  return Math.round(seconds * TENTHS_PER_SECOND) * (SFX_SAMPLE_RATE / TENTHS_PER_SECOND)
+}
+
+function assertClip(t, label, result, seconds) {
+  t.is(result.sampleRate, SFX_SAMPLE_RATE, `${label} reports 48 kHz`)
+  t.is(
+    result.samples,
+    samplesAtNativeDuration(seconds),
+    `${label} lasts exactly ${seconds} s, rounded to 0.1 s as the engine documents`
+  )
+  t.ok(result.stats, `${label} returns runtime stats`)
+  t.is(result.stats.totalSamples, result.samples, `${label} reports the emitted samples`)
+  t.ok(result.stats.totalTime > 0, `${label} reports its generation time`)
+}
+
+test(
+  'MOSS-SFX integration: a prompt generates the requested duration on CPU',
+  { timeout: TEST_TIMEOUT_MS, skip: skipWithoutModels },
+  async (t) => {
+    const model = createSfxModel()
+    await model.load()
+    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')
+    } finally {
+      await model.unload()
+    }
+  }
+)
+
+test(
+  'MOSS-SFX integration: seconds and the negative prompt change per call',
+  { timeout: TEST_TIMEOUT_MS, skip: skipWithoutModels || noGpu },
+  async (t) => {
+    const model = createSfxModel(true)
+    await model.load()
+    try {
+      const short = await generate(model, { seconds: SHORT_SECONDS })
+      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')
+    } finally {
+      await model.unload()
+    }
+  }
+)

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

@@ -0,0 +1,110 @@
+'use strict'
+
+const path = require('bare-path')
+const proc = require('bare-process')
+const test = require('brittle')
+
+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 SPEECH_SAMPLE_RATE = 24000
+const TEST_TIMEOUT_MS = 1800000
+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 modelDir = (proc.env && proc.env[MODEL_DIR_ENV]) || ''
+const skipWithoutModels = modelDir === ''
+const noGpu = proc.env && proc.env.NO_GPU === 'true'
+
+function createSpeechModel(useGPU = false) {
+  return new TTSGgml({
+    threads: TTS_TEST_THREADS,
+    engine: TTSGgml.ENGINE_MOSS_SPEECH,
+    files: { modelDir: path.resolve(modelDir) },
+    config: { useGPU },
+    seed: 0,
+    opts: { stats: true }
+  })
+}
+
+function spokenQuestion() {
+  const wav = readWavAsFloat32(resolveRefWavPath({}))
+  return { audio: wav.samples, sampleRate: wav.sampleRate }
+}
+
+function collectReply(result, data) {
+  if (!data || !data.outputArray) return
+  result.samples += data.outputArray.length
+  if (data.sampleRate) result.sampleRate = data.sampleRate
+  if (typeof data.text === 'string') result.text += data.text
+}
+
+async function respond(model, fields) {
+  const response = await model.run({
+    type: 'text',
+    input: '',
+    maxNewTokens: MAX_NEW_TOKENS,
+    ...fields
+  })
+  const result = { samples: 0, sampleRate: null, text: '' }
+  await response.onUpdate((data) => collectReply(result, data)).await()
+  result.stats = response.stats
+  return result
+}
+
+function assertSpokenReply(t, label, result) {
+  t.is(result.sampleRate, SPEECH_SAMPLE_RATE, `${label} reports 24 kHz`)
+  t.ok(result.samples > 0, `${label} carries speech`)
+  t.ok(result.stats, `${label} returns runtime stats`)
+  t.is(result.stats.totalSamples, result.samples, `${label} reports the emitted samples`)
+  t.ok(result.stats.promptTokens > 0, `${label} reports its prompt length`)
+}
+
+test(
+  'MOSS-Speech integration: a spoken question gets a spoken answer on CPU',
+  { timeout: TEST_TIMEOUT_MS, skip: skipWithoutModels },
+  async (t) => {
+    const model = createSpeechModel()
+    await model.load()
+    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')
+    } finally {
+      await model.unload()
+    }
+  }
+)
+
+test(
+  'MOSS-Speech integration: text replies, reply cuts and a text turn on the GPU',
+  { timeout: TEST_TIMEOUT_MS, skip: skipWithoutModels || noGpu },
+  async (t) => {
+    const model = createSpeechModel(true)
+    await model.load()
+    try {
+      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')
+
+      const cut = await respond(model, { ...spokenQuestion(), maxReplySeconds: CUT_SECONDS })
+      assertSpokenReply(t, 'cut reply', cut)
+      t.ok(
+        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')
+
+      const typed = await respond(model, { input: 'What is the capital of France?' })
+      assertSpokenReply(t, 'reply to a typed question', typed)
+    } finally {
+      await model.unload()
+    }
+  }
+)

package/test/integration/moss.test.js

@@ -11,6 +11,7 @@ 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
@@ -34,7 +35,6 @@ const GPU_DEVICE = 1
 
 const modelDir = (proc.env && proc.env[MODEL_DIR_ENV]) || ''
 const skipWithoutModels = modelDir === ''
-const noGpu = proc.env && proc.env.NO_GPU === 'true'
 
 function createMossModel(extra = {}, useGPU = false) {
   return new TTSGgml({
@@ -184,7 +184,7 @@ test(
 
 test(
   'MOSS TTS: useGPU=true synthesizes on a GPU backend',
-  { timeout: TEST_TIMEOUT_MS, skip: skipWithoutModels || noGpu },
+  { timeout: TEST_TIMEOUT_MS, skip: skipWithoutModels || NO_GPU },
   async (t) => {
     await withLoadedModel(
       {},
@@ -231,25 +231,29 @@ test(
 
 test(
   'MOSS TTS: durationTokens steers the length of the synthesized speech',
-  { timeout: TEST_TIMEOUT_MS, skip: skipWithoutModels },
+  { 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)`
-      )
-    })
+    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 },
+  { 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}`)
@@ -273,7 +277,8 @@ test(
           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)

package/test/integration/multiple-runs.test.js

@@ -30,13 +30,15 @@ const {
 const { loadSupertonicTTS, runSupertonicTTS } = require('../utils/runSupertonicTTS')
 const { ensureChatterboxModels, ensureSupertonicModel } = require('../utils/downloadModel')
 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'
 
-// Lifecycle / sequential-run 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.
+// Lifecycle / sequential-run tests, not GPU policy tests. The Chatterbox ones
+// run several syntheses, so they run on the GPU only and are skipped on CPU-only
+// runners (NO_GPU=true); the Supertonic reload keeps the package default
+// (`useGPU: false`). Tests that *are* about GPU live in gpu-smoke.test.js.
 
 function getBaseDir() {
   return isMobile && global.testDir ? global.testDir : '.'
@@ -50,7 +52,7 @@ const PHRASES = [
 
 test(
   'Chatterbox: multiple sequential runs reuse the same engine instance',
-  { timeout: 1800000 },
+  { timeout: 1800000, skip: NO_GPU },
   async (t) => {
     const baseDir = getBaseDir()
     const download = await ensureChatterboxModels({ targetDir: path.join(baseDir, 'models') })
@@ -77,7 +79,8 @@ test(
       threads: TTS_TEST_THREADS,
       modelDir: download.targetDir,
       refWavPath,
-      language: 'en'
+      language: 'en',
+      useGPU: GPU_ONLY_USE_GPU
     })
     try {
       const timings = []
@@ -111,7 +114,7 @@ test(
 
 test(
   'Chatterbox: fresh instance per run (app-restart simulation)',
-  { timeout: 1800000 },
+  { timeout: 1800000, skip: NO_GPU },
   async (t) => {
     const baseDir = getBaseDir()
     const download = await ensureChatterboxModels({ targetDir: path.join(baseDir, 'models') })
@@ -142,7 +145,8 @@ test(
         threads: TTS_TEST_THREADS,
         modelDir: download.targetDir,
         refWavPath,
-        language: 'en'
+        language: 'en',
+        useGPU: GPU_ONLY_USE_GPU
       })
       const loadMs = Date.now() - t0
       try {
@@ -175,58 +179,63 @@ test(
   }
 )
 
-test('Chatterbox: reload() between runs preserves stability', { timeout: 1800000 }, async (t) => {
-  const baseDir = getBaseDir()
-  const download = await ensureChatterboxModels({ targetDir: path.join(baseDir, 'models') })
-  if (!download.success) {
-    t.fail(
-      'Chatterbox GGUFs not available - registry fetch failed. Run `npm run download-models:registry` or stage models locally.'
-    )
-    return
-  }
+test(
+  'Chatterbox: reload() between runs preserves stability',
+  { timeout: 1800000, skip: NO_GPU },
+  async (t) => {
+    const baseDir = getBaseDir()
+    const download = await ensureChatterboxModels({ targetDir: path.join(baseDir, 'models') })
+    if (!download.success) {
+      t.fail(
+        'Chatterbox GGUFs not available - registry fetch failed. Run `npm run download-models:registry` or stage models locally.'
+      )
+      return
+    }
 
-  // Mobile-aware resolution: on iOS / Android the asset is staged into
-  // `Library/Caches/jfk.wav` via `global.assetPaths`; on desktop falls
-  // back to the in-tree `test/reference-audio/jfk.wav`. The bundled
-  // path is not readable from native code on iOS, which would trip
-  // `ModelFileNotFound` the moment `model.load()` reaches the C++
-  // `ChatterboxModel::validateConfig` check.
-  const refWavPath = resolveRefWavPath({})
-  if (!fs.existsSync(refWavPath)) {
-    t.pass('Skipped: reference audio missing')
-    return
-  }
+    // Mobile-aware resolution: on iOS / Android the asset is staged into
+    // `Library/Caches/jfk.wav` via `global.assetPaths`; on desktop falls
+    // back to the in-tree `test/reference-audio/jfk.wav`. The bundled
+    // path is not readable from native code on iOS, which would trip
+    // `ModelFileNotFound` the moment `model.load()` reaches the C++
+    // `ChatterboxModel::validateConfig` check.
+    const refWavPath = resolveRefWavPath({})
+    if (!fs.existsSync(refWavPath)) {
+      t.pass('Skipped: reference audio missing')
+      return
+    }
 
-  const model = await loadChatterboxTTS({
-    threads: TTS_TEST_THREADS,
-    modelDir: download.targetDir,
-    refWavPath,
-    language: 'en'
-  })
-  try {
-    const r1 = await runChatterboxTTS(
-      model,
-      { text: 'First run before reload.' },
-      { minSamples: 5000 }
-    )
-    t.ok(r1.passed, 'first run before reload should pass')
+    const model = await loadChatterboxTTS({
+      threads: TTS_TEST_THREADS,
+      modelDir: download.targetDir,
+      refWavPath,
+      language: 'en',
+      useGPU: GPU_ONLY_USE_GPU
+    })
+    try {
+      const r1 = await runChatterboxTTS(
+        model,
+        { text: 'First run before reload.' },
+        { minSamples: 5000 }
+      )
+      t.ok(r1.passed, 'first run before reload should pass')
 
-    await model.reload({ language: 'en' })
-    t.pass('reload() resolved')
+      await model.reload({ language: 'en' })
+      t.pass('reload() resolved')
 
-    const r2 = await runChatterboxTTS(
-      model,
-      { text: 'Second run after reload.' },
-      { minSamples: 5000 }
-    )
-    t.ok(r2.passed, 'second run after reload should pass')
-    t.ok(r2.data.sampleCount > 0, 'reloaded model produces audio')
-  } finally {
-    try {
-      await model.unload()
-    } catch (_e) {}
+      const r2 = await runChatterboxTTS(
+        model,
+        { text: 'Second run after reload.' },
+        { minSamples: 5000 }
+      )
+      t.ok(r2.passed, 'second run after reload should pass')
+      t.ok(r2.data.sampleCount > 0, 'reloaded model produces audio')
+    } finally {
+      try {
+        await model.unload()
+      } catch (_e) {}
+    }
   }
-})
+)
 
 test('Supertonic: reload() between runs preserves stability', { timeout: 1800000 }, async (t) => {
   const baseDir = getBaseDir()
@@ -272,7 +281,7 @@ test('Supertonic: reload() between runs preserves stability', { timeout: 1800000
 
 test(
   'Engine swap: chatterbox -> supertonic -> chatterbox in separate instances',
-  { timeout: 1800000 },
+  { timeout: 1800000, skip: NO_GPU },
   async (t) => {
     const baseDir = getBaseDir()
     const cb = await ensureChatterboxModels({ targetDir: path.join(baseDir, 'models') })
@@ -300,7 +309,8 @@ test(
       threads: TTS_TEST_THREADS,
       modelDir: cb.targetDir,
       refWavPath,
-      language: 'en'
+      language: 'en',
+      useGPU: GPU_ONLY_USE_GPU
     })
     try {
       const r = await runChatterboxTTS(c1, { text: 'Hello from chatterbox.' }, { minSamples: 5000 })
@@ -316,7 +326,7 @@ test(
       supertonicModelPath: st.path,
       voice: 'F1',
       language: 'en',
-      useGPU: false
+      useGPU: GPU_ONLY_USE_GPU
     })
     try {
       const r = await runSupertonicTTS(s1, { text: 'Hello from supertonic.' }, { minSamples: 5000 })
@@ -331,7 +341,8 @@ test(
       threads: TTS_TEST_THREADS,
       modelDir: cb.targetDir,
       refWavPath,
-      language: 'en'
+      language: 'en',
+      useGPU: GPU_ONLY_USE_GPU
     })
     try {
       const r = await runChatterboxTTS(

package/test/integration/output-sample-rate.test.js

@@ -13,6 +13,7 @@ const TTSGgml = require('@qvac/tts-ggml')
 
 const { ensureSupertonicModel, ensureParlerModel } = require('../utils/downloadModel')
 const { TTS_TEST_THREADS } = require('../utils/testThreads')
+const { SKIP_PARLER_GPU_ONLY, PARLER_GPU_ONLY_USE_GPU } = require('../utils/gpuOnly')
 
 const platform = os.platform()
 const isMobile = platform === 'ios' || platform === 'android'
@@ -123,7 +124,7 @@ test(
 
 test(
   'Parler: outputSampleRate=16000 resamples and reports 16 kHz',
-  { timeout: 600000 },
+  { timeout: 600000, skip: SKIP_PARLER_GPU_ONLY },
   async (t) => {
     const baseDir = getBaseDir()
     const dl = await ensureParlerModel({ targetDir: path.join(baseDir, 'models') })
@@ -140,6 +141,7 @@ test(
       files: { parlerModel: dl.path },
       voice: 'Laura',
       seed: 42,
+      config: { useGPU: PARLER_GPU_ONLY_USE_GPU },
       opts: { stats: true }
     })
     await native.load()
@@ -160,7 +162,7 @@ test(
       files: { parlerModel: dl.path },
       voice: 'Laura',
       seed: 42,
-      config: { outputSampleRate: 16000 },
+      config: { outputSampleRate: 16000, useGPU: PARLER_GPU_ONLY_USE_GPU },
       opts: { stats: true }
     })
     await resampled.load()

package/test/integration/parler-wer.test.js

@@ -7,9 +7,9 @@
 // chatterbox WER leg in addon.test.js (whisper ASR + wordErrorRate).
 //
 // macOS-desktop only (isDarwin): the whisper WER infra is desktop-only
-// across the tts-ggml suite. Runs on both the Metal GPU runner and the
-// no_gpu CPU runner (backend chosen like the quant loop). large-v1 is
-// RAM-gated; both tiers skip cleanly if their GGUF isn't staged.
+// across the tts-ggml suite. Runs on the Metal GPU runner only and is skipped
+// on CPU-only runners (NO_GPU=true). large-v1 is RAM-gated; both tiers skip
+// cleanly if their GGUF isn't staged.
 
 const os = require('bare-os')
 const path = require('bare-path')
@@ -27,10 +27,9 @@ const isApple = platform === 'darwin' || platform === 'ios'
 const NO_GPU = proc.env && proc.env.NO_GPU === 'true'
 const LARGE_MIN_RAM_BYTES = 16 * 1024 ** 3
 
-// Calibrated 2026-07-24: the CPU (no_gpu) runner is 0.0% WER at any seed; the
-// Metal/GPU runner diverges (FP reorder) — seed 42 is 0% on Apple-Silicon but
-// 22.2% on Intel-Mac Metal — so 0.35 tolerates the GPU variance while the CPU
-// leg stays effectively strict (greedy would be 50-100%, so this still asserts it).
+// Calibrated 2026-07-24: Metal diverges by FP reorder — seed 42 is 0% on
+// Apple-Silicon but 22.2% on Intel-Mac Metal — so 0.35 tolerates the GPU
+// variance while still asserting the words (greedy would be 50-100%).
 const WER_THRESHOLD = 0.35
 
 // Clear English sentences, all >= 9 words (a single ASR slip stays <= ~0.11,
@@ -51,7 +50,7 @@ function getBaseDir() {
 for (const { variant } of PARLER_WER_TIERS) {
   test(
     `Parler WER (${variant}): English synthesis transcribes within ${(WER_THRESHOLD * 100).toFixed(0)}%`,
-    { timeout: 1800000, skip: !isDarwin },
+    { timeout: 1800000, skip: !isDarwin || NO_GPU },
     async (t) => {
       if (variant === 'large' && os.totalmem() < LARGE_MIN_RAM_BYTES) {
         t.pass(