@qvac/tts-ggml 0.9.2 → 0.10.1

package/test/integration/pocket.integration.test.js

@@ -0,0 +1,156 @@
+'use strict'
+const test = require('brittle')
+const TTSGgml = require('../../index')
+const process = require('bare-process')
+global.process = process
+const bundle = process.env.QVAC_POCKET_MODEL_DIR
+const text = 'Hello! We can generate speech with Fabric.'
+
+// Opt in with QVAC_POCKET_MODEL_DIR pointing at the converted four-file bundle.
+module.exports = test(
+  'Pocket native addon streams, cancels, recovers and resamples on reload',
+  { skip: !bundle },
+  async (t) => {
+    const model = new TTSGgml({
+      engine: 'pocket',
+      files: { modelDir: bundle },
+      opts: { stats: true }
+    })
+    try {
+      await model.load()
+      const run = async (rate) => {
+        const response = await model.run({ input: text })
+        const pcm = []
+        const indices = []
+        let last = 0
+        for await (const chunk of response.iterate()) {
+          t.is(chunk.sampleRate, rate)
+          indices.push(chunk.chunkIndex)
+          pcm.push(...chunk.outputArray)
+          if (chunk.isLast) {
+            last++
+            t.is(chunk.outputArray.length, 0)
+          }
+        }
+        t.is(last, 1)
+        t.alike(
+          indices,
+          indices.map((_, i) => i)
+        )
+        t.is(pcm.length, response.stats.totalSamples)
+        t.ok(pcm.some((x) => x !== 0))
+        t.ok(response.stats.firstAudioMs > 0)
+        return pcm
+      }
+      const original = await run(24000)
+      const sentenceStream = await model.runStream('Hello. Speech is ready.', {
+        maxChunkScalars: 16
+      })
+      await sentenceStream.onUpdate(() => {}).await()
+      t.ok(sentenceStream.stats.firstAudioMs > 0, 'runStream preserves native first-audio latency')
+      const textStream = await model.runStreaming(
+        (async function* () {
+          yield 'Hello.'
+          yield 'Speech is ready.'
+        })(),
+        { accumulateSentences: false }
+      )
+      await textStream.onUpdate(() => {}).await()
+      t.ok(textStream.stats.firstAudioMs > 0, 'runStreaming preserves native first-audio latency')
+
+      // Check that omitted steps match the explicit upstream/native default
+      // through the complete addon path. PCM parity validates configuration,
+      // not subjective quality or the absence of model-generated artifacts.
+      const explicit = new TTSGgml({
+        engine: 'pocket',
+        files: { modelDir: bundle },
+        steps: 1
+      })
+      try {
+        await explicit.load()
+        const reference = await explicit.run({ input: text })
+        const pcm = []
+        for await (const chunk of reference.iterate()) pcm.push(...chunk.outputArray)
+        t.is(pcm.length, original.length, 'default and explicit one-step lengths match')
+        t.ok(
+          pcm.every((v, i) => Math.abs(v - original[i]) <= 4),
+          'default native PCM matches explicit one-step synthesis'
+        )
+      } finally {
+        await explicit.destroy()
+      }
+      if (process.env.QVAC_POCKET_AUDIO_OUTPUT) {
+        require('../utils/wav-helper').createWav(
+          new Int16Array(original),
+          24000,
+          process.env.QVAC_POCKET_AUDIO_OUTPUT
+        )
+      }
+      const response = await model.run({ input: text.repeat(5) })
+      let cancelPromise
+      const outcomePromise = response.await().then(
+        () => ({ completed: true }),
+        (error) => ({ error })
+      )
+      response.onUpdate((chunk) => {
+        if (!cancelPromise && chunk.outputArray.length) {
+          cancelPromise = response.cancel()
+          // Attach a rejection handler immediately; await the original promise
+          // below so cancellation failures still fail the integration test.
+          cancelPromise.catch(() => {})
+        }
+      })
+      const outcome = await outcomePromise
+      t.ok(cancelPromise, 'requested cancellation after first PCM')
+      if (cancelPromise) await cancelPromise
+      t.ok(
+        outcome.error && /cancel|abort/i.test(String(outcome.error)),
+        'cancelled synthesis rejects instead of completing'
+      )
+      const recovered = await run(24000)
+      t.is(recovered.length, original.length)
+      t.ok(
+        recovered.every((v, i) => Math.abs(v - original[i]) <= 4),
+        'deterministic PCM after cancellation'
+      )
+      await model.reload({ outputSampleRate: 44100 })
+      const resampled = await run(44100)
+      t.ok(Math.abs(resampled.length / 44100 - original.length / 24000) < 1 / 44100)
+      await t.exception(model.reload({ referenceAudio: `${bundle}/missing-reload-test.wav` }))
+      t.is(
+        model.getState().weightsLoaded,
+        false,
+        'failed native activation leaves the model unloaded'
+      )
+      await t.exception(model.run({ input: text }), /not loaded/)
+      await model.load()
+      const restored = await run(44100)
+      t.is(
+        restored.length,
+        resampled.length,
+        'load restores the last successful sample rate and voice'
+      )
+      t.ok(
+        restored.every((v, i) => Math.abs(v - resampled[i]) <= 4),
+        'PCM recovers after failed reload'
+      )
+      const empty = await model.run({ input: '   ' })
+      await t.exception(empty.await())
+      await run(44100)
+      // Verify the packaged native dependency includes the merged EOS-tail
+      // fix: the old token-only budget threw after emitting partial audio.
+      await model.reload({ outputSampleRate: 24000, framesAfterEos: 100, eosThreshold: -1e30 })
+      const tail = await model.run({ input: 'Hi.' })
+      let tailSamples = 0
+      let tailCompleted = 0
+      for await (const chunk of tail.iterate()) {
+        tailSamples += chunk.outputArray.length
+        if (chunk.isLast) tailCompleted++
+      }
+      t.is(tailCompleted, 1, 'explicit EOS tail completes normally')
+      t.is(tailSamples, 100 * 1920, 'all 100 EOS-tail frames are delivered')
+    } finally {
+      await model.destroy()
+    }
+  }
+)

package/test/integration/supertonic-mtl.test.js

@@ -14,6 +14,7 @@ const TTSGgml = require('@qvac/tts-ggml')
 const { runSupertonicTTS } = require('../utils/runSupertonicTTS')
 const { ensureSupertonicMtlModel } = require('../utils/downloadModel')
 const { recordTtsStats } = require('../utils/perf-helper')
+const { TTS_TEST_THREADS } = require('../utils/testThreads')
 
 const platform = os.platform()
 const isMobile = platform === 'ios' || platform === 'android'
@@ -31,6 +32,7 @@ const MTL_SENTENCES = [
 
 async function loadSupertonicMtlTTS(params) {
   const model = new TTSGgml({
+    threads: TTS_TEST_THREADS,
     engine: TTSGgml.ENGINE_SUPERTONIC,
     files: { supertonicModel: params.supertonicModelPath },
     voice: params.voice || 'F1',

package/test/integration/supertonic.test.js

@@ -12,6 +12,7 @@ const test = require('brittle')
 const { loadSupertonicTTS, runSupertonicTTS } = require('../utils/runSupertonicTTS')
 const { ensureSupertonicModel } = require('../utils/downloadModel')
 const { recordTtsStats } = require('../utils/perf-helper')
+const { TTS_TEST_THREADS } = require('../utils/testThreads')
 
 const platform = os.platform()
 const isMobile = platform === 'ios' || platform === 'android'
@@ -46,6 +47,7 @@ test(
     }
 
     const model = await loadSupertonicTTS({
+      threads: TTS_TEST_THREADS,
       supertonicModelPath: download.path,
       voice: 'F1',
       language: 'en',
@@ -140,6 +142,7 @@ test(
 
     const TTSGgml = require('@qvac/tts-ggml')
     const model = new TTSGgml({
+      threads: TTS_TEST_THREADS,
       engine: TTSGgml.ENGINE_SUPERTONIC,
       files: { supertonicModel: download.path },
       voice: 'F1',
@@ -196,6 +199,71 @@ test(
   }
 )
 
+test(
+  'Supertonic TTS (ggml): native chunk streaming (streamChunkTokens) emits engine chunks',
+  { timeout: 600000 },
+  async (t) => {
+    const baseDir = getBaseDir()
+    const download = await ensureSupertonicModel({ targetDir: path.join(baseDir, 'models') })
+    if (!download.success) {
+      t.fail(
+        'Supertonic GGUF not available - registry fetch failed. Run `npm run download-models:registry` or stage models locally.'
+      )
+      return
+    }
+
+    const TTSGgml = require('@qvac/tts-ggml')
+    const model = new TTSGgml({
+      threads: TTS_TEST_THREADS,
+      engine: TTSGgml.ENGINE_SUPERTONIC,
+      files: { supertonicModel: download.path },
+      voice: 'F1',
+      streamChunkTokens: 40,
+      streamFirstChunkTokens: 30,
+      config: { language: 'en', useGPU: false },
+      opts: { stats: true }
+    })
+    await model.load()
+    try {
+      const text =
+        'Native streaming splits one request inside the engine. Each chunk is ' +
+        'synthesized and emitted as soon as it is ready, so playback can start ' +
+        'before the whole paragraph has been rendered.'
+      const response = await model.run({ type: 'text', input: text })
+      const chunkIndices = []
+      const isLastFlags = []
+      let totalSamples = 0
+      let lastSampleRate = null
+      await response
+        .onUpdate((d) => {
+          if (d && d.outputArray) {
+            chunkIndices.push(d.chunkIndex)
+            isLastFlags.push(!!d.isLast)
+            totalSamples += d.outputArray.length
+            if (d.sampleRate) lastSampleRate = d.sampleRate
+          }
+        })
+        .await()
+
+      t.ok(chunkIndices.length >= 2, `engine emitted multiple chunks (got ${chunkIndices.length})`)
+      for (let i = 0; i < chunkIndices.length; i++) {
+        t.is(chunkIndices[i], i, `chunk ${i} carries chunkIndex=${i}`)
+      }
+      t.is(isLastFlags.filter(Boolean).length, 1, 'exactly one isLast=true emitted')
+      t.is(isLastFlags[isLastFlags.length - 1], true, 'final chunk carries isLast=true')
+      t.is(lastSampleRate, 44100, 'native streaming chunks report 44.1 kHz')
+      t.ok(totalSamples > 0, 'stream produced audio samples')
+      if (response.stats) {
+        t.is(response.stats.totalSamples, totalSamples, 'stats count exactly the streamed samples')
+      }
+    } finally {
+      try {
+        await model.unload()
+      } catch (_e) {}
+    }
+  }
+)
+
 test(
   'Supertonic TTS (ggml): runStreaming with async iterator emits one job per yielded sentence',
   { timeout: 600000 },
@@ -211,6 +279,7 @@ test(
 
     const TTSGgml = require('@qvac/tts-ggml')
     const model = new TTSGgml({
+      threads: TTS_TEST_THREADS,
       engine: TTSGgml.ENGINE_SUPERTONIC,
       files: { supertonicModel: download.path },
       voice: 'F1',
@@ -265,6 +334,7 @@ test(
     }
 
     const model = await loadSupertonicTTS({
+      threads: TTS_TEST_THREADS,
       supertonicModelPath: download.path,
       voice: 'F1',
       steps: 4,

package/test/integration/supertonic3-quant.test.js

@@ -24,6 +24,7 @@ const test = require('brittle')
 const TTSGgml = require('@qvac/tts-ggml')
 const { runSupertonicTTS } = require('../utils/runSupertonicTTS')
 const { ensureSupertonic3Model } = require('../utils/downloadModel')
+const { TTS_TEST_THREADS } = require('../utils/testThreads')
 
 const platform = os.platform()
 const isMobile = platform === 'ios' || platform === 'android'
@@ -50,6 +51,7 @@ const SENTENCES = [
 
 async function loadSupertonic3TTS(params) {
   const model = new TTSGgml({
+    threads: TTS_TEST_THREADS,
     engine: TTSGgml.ENGINE_SUPERTONIC,
     files: { supertonicModel: params.supertonicModelPath },
     voice: params.voice || 'F1',

package/test/integration/voice-controls.test.js

@@ -0,0 +1,56 @@
+'use strict'
+
+// Model-free: tts-cpp's conditioning vocabulary, read through the native
+// binding by TTSGgml.getVoiceControls(), must agree with what the JS layer
+// accepts per engine, so the JS validation tables cannot drift from the
+// library they front.
+
+const test = require('brittle')
+const TTSGgml = require('../../index.js')
+const { TTS_TEST_THREADS } = require('../utils/testThreads')
+
+const ENGINE_FILES = {
+  [TTSGgml.ENGINE_CHATTERBOX]: { t3Model: './t3.gguf', s3genModel: './s3gen.gguf' },
+  [TTSGgml.ENGINE_SUPERTONIC]: { supertonicModel: './supertonic.gguf' },
+  [TTSGgml.ENGINE_COSYVOICE3]: { cosyvoiceModelDir: './cosyvoice3' },
+  [TTSGgml.ENGINE_PARLER]: { parlerModel: './parler.gguf' },
+  [TTSGgml.ENGINE_AUDIO8]: { audio8Lm: './lm.gguf', audio8CodecDecoder: './decoder.gguf' }
+}
+
+function acceptedBy(engine, key, values) {
+  return values.filter((value) => {
+    try {
+      const model = new TTSGgml({
+        threads: TTS_TEST_THREADS,
+        engine,
+        files: ENGINE_FILES[engine],
+        [key]: value
+      })
+      return model.getEngineType() === engine
+    } catch (_err) {
+      return false
+    }
+  })
+}
+
+test('getVoiceControls: native vocabulary matches the JS validation tables', (t) => {
+  const catalog = TTSGgml.getVoiceControls()
+  t.ok(catalog.emotions.length > 0, 'canonical emotions are listed')
+  t.ok(catalog.paces.includes('moderate'), 'canonical paces include moderate')
+
+  for (const engine of Object.keys(ENGINE_FILES)) {
+    const native = catalog.engines[engine]
+    t.ok(native, `${engine} is in the native catalog`)
+    if (!native) continue
+    t.alike(
+      acceptedBy(engine, 'emotion', catalog.emotions),
+      native.emotions,
+      `${engine}: the emotions the JS layer accepts are the native subset`
+    )
+    t.alike(
+      acceptedBy(engine, 'pace', catalog.paces),
+      native.paces,
+      `${engine}: the paces the JS layer accepts are the native subset`
+    )
+  }
+})

package/test/mobile/integration.auto.cjs

@@ -38,6 +38,10 @@ async function runCosyvoice3Test (options = {}) { // eslint-disable-line no-unus
   return runIntegrationModule('../integration/cosyvoice3.test.js', options)
 }
 
+async function runFitTest (options = {}) { // eslint-disable-line no-unused-vars
+  return runIntegrationModule('../integration/fit.test.js', options)
+}
+
 async function runGpuSmokeTest (options = {}) { // eslint-disable-line no-unused-vars
   return runIntegrationModule('../integration/gpu-smoke.test.js', options)
 }
@@ -46,6 +50,10 @@ async function runLavasrEnhancerTest (options = {}) { // eslint-disable-line no-
   return runIntegrationModule('../integration/lavasr-enhancer.test.js', options)
 }
 
+async function runMossTest (options = {}) { // eslint-disable-line no-unused-vars
+  return runIntegrationModule('../integration/moss.test.js', options)
+}
+
 async function runMultipleRunsTest (options = {}) { // eslint-disable-line no-unused-vars
   return runIntegrationModule('../integration/multiple-runs.test.js', options)
 }
@@ -82,6 +90,10 @@ async function runSupertonic3QuantTest (options = {}) { // eslint-disable-line n
   return runIntegrationModule('../integration/supertonic3-quant.test.js', options)
 }
 
+async function runVoiceControlsTest (options = {}) { // eslint-disable-line no-unused-vars
+  return runIntegrationModule('../integration/voice-controls.test.js', options)
+}
+
 module.exports = {
   runAddonTest,
   runAudio8Test,
@@ -91,8 +103,10 @@ module.exports = {
   runCosyvoice3CloneTest,
   runCosyvoice3LavasrTest,
   runCosyvoice3Test,
+  runFitTest,
   runGpuSmokeTest,
   runLavasrEnhancerTest,
+  runMossTest,
   runMultipleRunsTest,
   runOutputSampleRateTest,
   runParlerWerTest,
@@ -101,5 +115,6 @@ module.exports = {
   runStreamingBenchmarkTest,
   runSupertonicMtlTest,
   runSupertonicTest,
-  runSupertonic3QuantTest
+  runSupertonic3QuantTest,
+  runVoiceControlsTest
 }

package/test/mobile/pocket-worklet-host.cpp

@@ -0,0 +1,92 @@
+// Standalone iOS Simulator host for the packaged Pocket Bare worklet test.
+// Uses the same exported Bare Kit C API as react-native-bare-kit/shared/
+// BareKitModule.cc. Keep IPC initialization after bare_worklet_start().
+// This tests a worklet process, not a signed app or a physical device.
+#include <chrono>
+#include <cstdio>
+#include <cstdlib>
+#include <string>
+#include <thread>
+
+#include <dlfcn.h>
+extern "C" {
+struct bare_worklet_s;
+using bare_worklet_t = bare_worklet_s;
+struct bare_ipc_s;
+using bare_ipc_t = bare_ipc_s;
+struct uv_buf_t {
+  char* base;
+  size_t len;
+};
+struct bare_worklet_options_t {
+  size_t memory_limit;
+  const char* assets;
+};
+int bare_worklet_alloc(bare_worklet_t**);
+int bare_worklet_init(bare_worklet_t*, const bare_worklet_options_t*);
+int bare_worklet_start(
+    bare_worklet_t*, const char*, const uv_buf_t*, int, const char*[]);
+int bare_worklet_terminate(bare_worklet_t*);
+void bare_worklet_destroy(bare_worklet_t*);
+int bare_ipc_alloc(bare_ipc_t**);
+int bare_ipc_init(bare_ipc_t*, bare_worklet_t*);
+int bare_ipc_read(bare_ipc_t*, void**, size_t*);
+void bare_ipc_destroy(bare_ipc_t*);
+}
+void check(int code, const char* stage) {
+  if (code) {
+    std::fprintf(stderr, "%s: %d\n", stage, code);
+    std::exit(2);
+  }
+}
+int main(int argc, char** argv) {
+  if (argc < 2)
+    return 2;
+  // A broken native job must not leave an orphaned simulator process if its
+  // termination path hangs. Ordinary completion exits before this deadline.
+  std::thread([] {
+    std::this_thread::sleep_for(std::chrono::seconds(120));
+    std::fprintf(stderr, "Worklet host exceeded its hard deadline\n");
+    std::_Exit(124);
+  }).detach();
+  for (int i = 2; i < argc; ++i)
+    if (!dlopen(argv[i], RTLD_NOW | RTLD_GLOBAL)) {
+      std::fprintf(stderr, "%s\n", dlerror());
+      return 3;
+    }
+  bare_worklet_t* worklet;
+  bare_ipc_t* ipc;
+  check(bare_worklet_alloc(&worklet), "worklet alloc");
+  bare_worklet_options_t options{0, nullptr};
+  check(bare_worklet_init(worklet, &options), "worklet init");
+  check(
+      bare_worklet_start(worklet, argv[1], nullptr, 0, nullptr),
+      "worklet start");
+  check(bare_ipc_alloc(&ipc), "ipc alloc");
+  check(bare_ipc_init(ipc, worklet), "ipc init");
+  std::string received;
+  const auto deadline =
+      std::chrono::steady_clock::now() + std::chrono::seconds(90);
+  while (std::chrono::steady_clock::now() < deadline) {
+    void* data = nullptr;
+    size_t len = 0;
+    int result = bare_ipc_read(ipc, &data, &len);
+    if (result == 0)
+      received.append(static_cast<const char*>(data), len);
+    else if (result != -1) {
+      std::fprintf(stderr, "ipc read %d\n", result);
+      break;
+    }
+    if (received.find('\n') != std::string::npos)
+      break;
+    std::this_thread::sleep_for(std::chrono::milliseconds(10));
+  }
+  std::printf("WORKLET_RESULT %s\n", received.c_str());
+  std::fflush(stdout);
+  check(bare_worklet_terminate(worklet), "worklet terminate");
+  bare_ipc_destroy(ipc);
+  std::free(ipc);
+  bare_worklet_destroy(worklet);
+  std::free(worklet);
+  return received.find("\"passed\":true") != std::string::npos ? 0 : 1;
+}

package/test/mobile/pocket-worklet.cjs

@@ -0,0 +1,47 @@
+'use strict'
+
+// Bundle with bare-pack --linked for the mobile target. The host provides
+// QVAC_POCKET_MODEL_DIR and reads one JSON result from BareKit.IPC. Exporting
+// the integration-test promise lets this worklet report completion without
+// relying on beforeExit, since the host's IPC connection keeps it alive.
+/* global BareKit, Bare */
+let sent = false
+let assertions = 0
+let failed = false
+const tap = []
+const send = (result) => {
+  if (sent) return
+  sent = true
+  BareKit.IPC.write(
+    Buffer.from(JSON.stringify({ ...result, assertions, tap, versions: Bare.versions }) + '\n')
+  )
+}
+Bare.on('uncaughtException', (error) =>
+  send({ passed: false, error: String(error.stack || error) })
+)
+Bare.on('unhandledRejection', (error) =>
+  send({ passed: false, error: String(error.stack || error) })
+)
+
+const originalLog = console.log.bind(console)
+console.log = (...args) => {
+  originalLog(...args)
+  tap.push(args.map(String).join(' '))
+  const line = String(args[0] || '')
+  if (/^\s+(?:not )?ok \d/.test(line)) assertions++
+  if (/^\s*not ok \d/.test(line)) failed = true
+}
+
+const process = require('bare-process')
+global.process = process
+if (!process.env.QVAC_POCKET_MODEL_DIR) {
+  send({
+    passed: false,
+    error: 'QVAC_POCKET_MODEL_DIR is required; mobile validation must not skip inference'
+  })
+} else {
+  Promise.resolve(require('../integration/pocket.integration.test.js')).then(
+    () => send({ passed: !failed && assertions > 0 && !Bare.exitCode }),
+    (error) => send({ passed: false, error: String(error.stack || error) })
+  )
+}

package/test/mobile/test-groups.json

@@ -10,7 +10,8 @@
       "runChatterboxMtlTest"
     ],
     "supertonic": [
-      "runSupertonicTest"
+      "runSupertonicTest",
+      "runFitTest"
     ],
     "supertonic-mtl": [
       "runSupertonicMtlTest"
@@ -31,7 +32,8 @@
     "cross-model-compatibility": [
       "runMultipleRunsTest",
       "runGpuSmokeTest",
-      "runOutputSampleRateTest"
+      "runOutputSampleRateTest",
+      "runVoiceControlsTest"
     ]
   },
   "android": {
@@ -44,7 +46,8 @@
       "runChatterboxMtlTest"
     ],
     "supertonic": [
-      "runSupertonicTest"
+      "runSupertonicTest",
+      "runFitTest"
     ],
     "supertonic-mtl": [
       "runSupertonicMtlTest"
@@ -65,7 +68,8 @@
     "cross-model-compatibility": [
       "runMultipleRunsTest",
       "runGpuSmokeTest",
-      "runOutputSampleRateTest"
+      "runOutputSampleRateTest",
+      "runVoiceControlsTest"
     ]
   }
 }

package/test/utils/runCosyvoiceTTS.js

@@ -54,6 +54,7 @@ function buildCosyvoiceLoadOptions(params = {}) {
   // the logits, so without it a before/after diff measures the sampler rather
   // than the conditioning.
   if (params.seed !== undefined) options.seed = params.seed
+  if (params.threads !== undefined) options.threads = params.threads
   return options
 }
 

package/test/utils/runTTS.js

@@ -235,25 +235,20 @@ async function runTTS(model, params, expectation = {}, options = {}) {
 
     const stats = response.stats || jobStats
 
+    // Every engine stat passes through, with only the three rates rounded for
+    // logging. An allowlist here used to drop fields the engine reported
+    // (gpuUnsupported, then the per-engine stage stats), so tests read what
+    // the addon emitted rather than a curated subset.
     const roundedStats = stats
       ? {
+          ...stats,
           totalTime: stats.totalTime ? Number(stats.totalTime.toFixed(4)) : stats.totalTime,
           tokensPerSecond: stats.tokensPerSecond
             ? Number(stats.tokensPerSecond.toFixed(2))
             : stats.tokensPerSecond,
           realTimeFactor: stats.realTimeFactor
             ? Number(stats.realTimeFactor.toFixed(5))
-            : stats.realTimeFactor,
-          audioDurationMs: stats.audioDurationMs,
-          totalSamples: stats.totalSamples,
-          backendDevice: stats.backendDevice,
-          backendId: stats.backendId,
-          // The allowlist above dropped gpuUnsupported, so gpu-smoke's
-          // policy-CPU escape hatch (allowPolicyCpu && dev===0 &&
-          // stats.gpuUnsupported) never saw the flag the engine set and the
-          // Chatterbox/Mali fallback failed the strict assertion. Pass it
-          // through (runSupertonicTTS already returns the raw stats object).
-          gpuUnsupported: stats.gpuUnsupported
+            : stats.realTimeFactor
         }
       : null
 

package/tts.d.ts

@@ -1,5 +1,5 @@
 export interface TTSConfigurationParams {
-    [key: string]: string | number | boolean | undefined;
+    [key: string]: string | number | boolean | string[] | undefined;
 }
 export interface TTSJobData {
     type: string;
@@ -14,6 +14,7 @@ export interface TTSJobData {
     noise?: string;
     reverb?: string;
     quality?: string;
+    instruct?: string;
     referenceAudio?: string;
     referenceText?: string;
 }
@@ -23,10 +24,20 @@ export interface TTSWeightData {
     completed: boolean;
 }
 export type TTSOutputCallback = (addon: unknown, event: unknown, data: unknown, error: unknown) => void;
+/** getVoiceControls() payload, keyed by tts-cpp's engine names. */
+export interface NativeVoiceControls {
+    emotions: string[];
+    paces: string[];
+    engines: Record<string, {
+        emotions: string[];
+        paces: string[];
+    }>;
+}
 export interface TTSBinding {
+    getVoiceControls(): NativeVoiceControls;
     createInstance(owner: TTSInterface, configuration: TTSConfigurationParams, outputCallback: TTSOutputCallback | null): object;
     activate(handle: object | null): Promise<void>;
-    runJob(handle: object | null, data: TTSJobData): void;
+    runJob(handle: object | null, data: TTSJobData): boolean | void | Promise<boolean | void>;
     loadWeights(handle: object | null, weightsData: TTSWeightData): void;
     cancel(handle: object | null): Promise<void>;
     destroyInstance(handle: object): Promise<void> | void;

package/tts.js

@@ -35,10 +35,11 @@ class TTSInterface {
             });
         }
     }
-    // eslint-disable-next-line @typescript-eslint/require-await -- preserves the established promise-returning wrapper API.
     async runJob(data) {
         try {
-            this._binding.runJob(this._handle, data);
+            if (await this._binding.runJob(this._handle, data) === false) {
+                throw new Error("Native addon rejected the job");
+            }
         }
         catch (error) {
             throw new error_1.QvacErrorAddonTTSGgml({