@qvac/tts-ggml 0.12.0 → 0.13.0

package/README.md

@@ -29,7 +29,8 @@ Xclipse/Mali → Vulkan). Parler supports Apple/Metal, linux CUDA, and the
 validated Android paths, including Vulkan on ARM Mali (see
 [Backends & GPU acceleration](#backends--gpu-acceleration)). Audio8 supports
 CUDA/Vulkan offload on Linux and Vulkan on Windows. MOSS GPU offload is
-validated on Apple/Metal.
+validated on Apple/Metal; desktop CUDA/Vulkan validation requires the native
+and registry prerequisites described under [MOSS](#moss).
 
 [qvac-tts-cpp]: https://github.com/tetherto/qvac-fabric-speech.cpp/tree/master/engines/tts
 
@@ -1060,6 +1061,82 @@ falls back to CPU and sets `response.stats.gpuUnsupported`.  `backendsDir`
 reaches MOSS like every other engine, so builds that load ggml backends at
 runtime find them.
 
+The same controls apply to MOSS-TTSD and MOSS-Speech. `nGpuLayers` is a
+boolean GPU request for these engines (zero = CPU, non-zero = GPU), not a
+partial layer count. The addon forwards these controls to the native engine;
+it does not choose a different backend or change the CPU default.
+`response.stats.backendId` identifies the language-model backend (2 = CUDA,
+3 = Vulkan); it is not a measurement of every codec operation.
+
+The combined desktop CUDA/Vulkan speech changes in
+[Vulkan #308](https://github.com/tetherto/qvac-fabric-speech.cpp/pull/308),
+including [CUDA #321](https://github.com/tetherto/qvac-fabric-speech.cpp/pull/321),
+merged to native master at `84b02694001cfea863167776dbc185474a816656`.
+This checkout consumes the merged [registry #423](https://github.com/tetherto/qvac-registry-vcpkg/pull/423)
+at `e31be272ecdf9f20970302ebf8a2943d47803001`: `speech-cpp` 2026-10-12#1
+pins that merged revision, and `ggml-speech` 2026-10-07#1 pins
+`06f1b66806626a635904f31db6914ad2d0e71197`. The earlier native `f4d4c257`
+passed ten smaller-model CUDA/Vulkan cases; those results do not establish GPU
+validation of the final native revision or the packaged addon. Rebuild the addon
+before running its GPU tests. Native desktop results also do not establish
+Android support or speech-quality signoff.
+
+The registry `baseline` is the main commit containing #423. The shared exact
+`speech-cpp` overrides and backend implementation are already on qvac main.
+This baseline update completes the TTS registry configuration; packaged-addon
+CUDA/Vulkan inference still requires validation on provisioned GPU hosts before
+claiming a validated release.
+
+From `packages/tts-ggml`, resolve the checked-in manifest without building or
+downloading models (with `VCPKG_ROOT` set):
+
+```sh
+vcpkg install --dry-run --triplet x64-linux --x-feature=cuda --x-feature=vulkan
+```
+
+On a macOS host without a Linux cross-compiler, prefix that dry-run command
+with `VCPKG_FEATURE_FLAGS=-compilertracking` to check registry resolution only.
+For a bounded native build on a suitably provisioned Linux GPU host:
+
+```sh
+CMAKE_BUILD_PARALLEL_LEVEL=2 VCPKG_MAX_CONCURRENCY=2 npm run build:cuda
+```
+
+The normal PR workflow requires approval of the `fork-ci` environment for
+external forks. Obtain that approval through the existing gate; a manual
+workflow dispatch is not a substitute for fork approval.
+
+On a desktop with those prerequisites, stage the TTS and TTSD backbones,
+codec decoder/encoder and the bundled `test/reference-audio/jfk.wav`, plus
+the Speech model/codec. Set
+`QVAC_TEST_MOSS_MODEL_DIR` and `QVAC_TEST_MOSS_SPEECH_MODEL_DIR` to their
+respective directories. Run each available backend in a fresh process:
+
+```sh
+QVAC_TEST_MOSS_FULL_GPU=true TTS_CPP_GPU_BACKEND=cuda npx --no-install brittle-bare test/integration/moss.test.js test/integration/moss-speech.test.js
+QVAC_TEST_MOSS_FULL_GPU=true TTS_CPP_GPU_BACKEND=vulkan npx --no-install brittle-bare test/integration/moss.test.js test/integration/moss-speech.test.js
+```
+
+The tests check the exact pinned backend, `backendDevice` and
+`gpuUnsupported` for TTS batch/streaming/cloning, TTSD dialogue, and Speech
+text/audio replies. CPU control cases still require CPU even with a GPU pin.
+`QVAC_TEST_MOSS_FULL_GPU=true` fails before model loading unless both model
+directories, the TTS/TTSD/Speech backbones, all three codec GGUFs, and the
+reference WAV exist. It also requires an explicit backend pin (case-insensitive),
+rejects `NO_GPU=true` and mobile CPU-only cases, and checks that every required
+case completes. Run both files together without test filters: a successful full
+run has 12 passing tests, including the two completion checks, and no skips.
+Preflight only checks asset presence; actual model loading and inference must
+also pass. These commands cover TTS, TTSD and Speech, not MOSS-SoundEffect (SFX).
+No addon CUDA/Vulkan hardware run has been completed for this test change yet.
+
+Without strict mode, developer behavior is unchanged: an unpinned run accepts
+the normal GPU cascade, missing model directories skip tests, and missing
+encoder/TTSD assets omit cloning/dialogue cases. Such runs are not full GPU
+validation. `npm run test:node` covers backend selection and strict validation
+failures without loading models. Do not load these multi-GB models on
+memory-constrained hosts.
+
 ## MOSS-SoundEffect
 
 MOSS-SoundEffect-v2 generates a sound effect from a text description: a Qwen3
@@ -1348,12 +1425,14 @@ const {
 
 `assessFit` projects a load against the memory free right now. It reads GGUF metadata and never weight data, so the registry's weightless copy of each file answers the same as the file itself and the projection can run before anything is downloaded. It is a module export, not an instance method: nothing is loaded to call it.
 
+`assessFit` returns a Promise. Fits run one at a time within this addon.
+
 A request is a `createInstance` config plus the workload, so it carries the same keys the load takes and the engine's own config builder reads it.
 
 ```js
 const TTSGgml = require('@qvac/tts-ggml')
 
-const fit = TTSGgml.assessFit({
+const fit = await TTSGgml.assessFit({
   engineType: 'supertonic',
   supertonicModelPath: '/models/supertonic.gguf',
   useGPU: true,
@@ -1393,7 +1472,7 @@ Everything else comes from the load config: `nGpuLayers` and `useGPU` carry the
 
 `deviceSharesHostMemory` reports that the device pool is system RAM, so host bytes compete with device bytes.
 
-A model the engine cannot read is `status: "error"`, as is a voice with no fitter, which reports `reason: "unsupported-engine"`. MOSS-TTS, MOSS-TTSD and MOSS-SoundEffect are supported. MOSS-Speech has no SDK fit projection. A broken request, or a host with no native binding, throws.
+A model the engine cannot read resolves to `status: "error"`, as does a voice with no fitter, which reports `reason: "unsupported-engine"`. MOSS-TTS, MOSS-TTSD and MOSS-SoundEffect are supported. MOSS-Speech has no SDK fit projection. A broken request, or a host with no native binding, rejects.
 
 MOSS-TTS and MOSS-TTSD share the `moss` fitter. `promptRows` is the complete
 native prompt length, including special tokens, encoded speaker references and
@@ -1404,7 +1483,7 @@ The fitter does not open reference recordings. Use the TTSD backbone to assess
 dialogue, supplying its complete prompt and total reference workload.
 
 ```js
-const fit = TTSGgml.assessFit({
+const fit = await TTSGgml.assessFit({
   engineType: 'moss',
   mossBackbonePath: './moss-tts-delay-f16.gguf',
   mossCodecDecoderPath: './moss-codec-decoder-f16.gguf',
@@ -1426,7 +1505,7 @@ The supertonic fitter covers the fused graph path: a validated GPU, or a CPU wit
 ### MOSS-SoundEffect fit
 
 ```js
-const fit = TTSGgml.assessFit({
+const fit = await TTSGgml.assessFit({
   engineType: 'moss-sfx',
   mossSoundEffectPath: './moss-sfx-v2-q8_0.gguf',
   prompt: 'Rain falling on a tin roof.',
@@ -1581,7 +1660,8 @@ build becomes loadable once `npm run link:platform` (run by
 
 The vcpkg port is hosted in
 [`tetherto/qvac-registry-vcpkg`][registry] and pulls
-[`qvac-tts.cpp`][qvac-tts-cpp] at a pinned REF.  See
+[`qvac-fabric-speech.cpp`](https://github.com/tetherto/qvac-fabric-speech.cpp)
+(`engines/tts`) at a pinned REF.  See
 [`vcpkg-configuration.json`](./vcpkg-configuration.json) for the
 baseline commit.
 

package/examples/moss-sfx-fit.js

@@ -8,11 +8,18 @@ if (!model || !prompt || seconds === undefined) {
   throw new Error('Usage: bare examples/moss-sfx-fit.js <model.gguf> <prompt> <seconds>')
 }
 
-const fit = TTSGgml.assessFit({
-  engineType: 'moss-sfx',
-  mossSoundEffectPath: model,
-  prompt,
-  seconds: Number(seconds),
-  useGPU: false
+async function main() {
+  const fit = await TTSGgml.assessFit({
+    engineType: 'moss-sfx',
+    mossSoundEffectPath: model,
+    prompt,
+    seconds: Number(seconds),
+    useGPU: false
+  })
+  console.log(fit.report || `${fit.status}: ${fit.reason}`)
+}
+
+main().catch((err) => {
+  console.error(err)
+  process.exit(1)
 })
-console.log(fit.report || `${fit.status}: ${fit.reason}`)

package/lib/fit.d.ts

@@ -139,9 +139,9 @@ export interface TtsFitResult {
  *
  * `engineType` picks the fitter, the same key a load uses, and is required
  * here: a fit request carries none of the file keys a load is inferred from.
- * A model the engine cannot read comes back as `status: "error"`, as does a
+ * A model the engine cannot read resolves to `status: "error"`, as does a
  * voice with no fitter; a broken request, or a host with no native binding,
- * throws.
+ * rejects. Fits run one at a time within this addon.
  */
-export declare function assessFit(request: TtsFitRequest): TtsFitResult;
+export declare function assessFit(request: TtsFitRequest): Promise<TtsFitResult>;
 export {};

package/lib/fit.js

@@ -12,12 +12,12 @@ exports.assessFit = assessFit;
  *
  * `engineType` picks the fitter, the same key a load uses, and is required
  * here: a fit request carries none of the file keys a load is inferred from.
- * A model the engine cannot read comes back as `status: "error"`, as does a
+ * A model the engine cannot read resolves to `status: "error"`, as does a
  * voice with no fitter; a broken request, or a host with no native binding,
- * throws.
+ * rejects. Fits run one at a time within this addon.
  */
-function assessFit(request) {
+async function assessFit(request) {
     // eslint-disable-next-line @typescript-eslint/no-require-imports -- the native binding loads on first use.
     const binding = require('../binding.js');
-    return binding.assessFit(request);
+    return await binding.assessFit(request);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@qvac/tts-ggml",
-  "version": "0.12.0",
+  "version": "0.13.0",
   "description": "Text to Speech (TTS) addon for qvac (ggml backend, wrapping the chatterbox + supertonic + parler + cosyvoice3 + audio8 + moss + moss-sfx + moss-speech + Pocket engines from tts-cpp)",
   "qvac": {
     "ggml-speech": "2026-10-07#1"
@@ -126,6 +126,11 @@
     "test/pocket-worklet",
     "test/reference-audio",
     "test/utils/runTTS.js",
+    "test/utils/mossBackend.js",
+    "test/utils/mossGpuValidation.js",
+    "test/utils/gpuOnly.js",
+    "test/utils/testThreads.js",
+    "test/utils/perf-helper.js",
     "test/utils/runChatterboxTTS.js",
     "test/utils/runSupertonicTTS.js",
     "test/utils/runParlerTTS.js",
@@ -200,7 +205,7 @@
   },
   "dependencies": {
     "@qvac/error": "^0.1.0",
-    "@qvac/infer-base": "^0.6.2",
+    "@qvac/infer-base": "^0.8.0",
     "@qvac/langdetect-text": "^0.1.2",
     "@qvac/logging": "^0.1.0",
     "bare-fs": "^4.5.6",
@@ -212,16 +217,16 @@
     "bare-url": "^2.4.3"
   },
   "optionalDependencies": {
-    "@qvac/tts-ggml-linux-x64": "0.12.0",
-    "@qvac/tts-ggml-linux-arm64": "0.12.0",
-    "@qvac/tts-ggml-darwin-arm64": "0.12.0",
-    "@qvac/tts-ggml-darwin-x64": "0.12.0",
-    "@qvac/tts-ggml-win32-x64": "0.12.0"
+    "@qvac/tts-ggml-linux-x64": "0.13.0",
+    "@qvac/tts-ggml-linux-arm64": "0.13.0",
+    "@qvac/tts-ggml-darwin-arm64": "0.13.0",
+    "@qvac/tts-ggml-darwin-x64": "0.13.0",
+    "@qvac/tts-ggml-win32-x64": "0.13.0"
   },
   "types": "index.d.ts",
   "peerDependencies": {
-    "@qvac/tts-ggml-android-arm64": "0.12.0",
-    "@qvac/tts-ggml-ios": "0.12.0"
+    "@qvac/tts-ggml-android-arm64": "0.13.0",
+    "@qvac/tts-ggml-ios": "0.13.0"
   },
   "peerDependenciesMeta": {
     "@qvac/tts-ggml-android-arm64": {

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