@qvac/tts-ggml 0.9.2 → 0.10.0

package/test/integration/moss.test.js

@@ -0,0 +1,282 @@
+'use strict'
+
+const fs = require('bare-fs')
+const os = require('bare-os')
+const path = require('bare-path')
+const proc = require('bare-process')
+const test = require('brittle')
+
+const TTSGgml = require('@qvac/tts-ggml')
+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 MOSS_SAMPLE_RATE = 24000
+const MOSS_STREAM_FRAMES = 10
+const MOSS_SAMPLES_PER_FRAME = 1920
+const TEST_TIMEOUT_MS = 1800000
+const SYNTHESIS_TEXT = 'The MOSS integration test checks this generated voice.'
+const MODEL_DIR_ENV = 'QVAC_TEST_MOSS_MODEL_DIR'
+const ENCODER_RE = /^moss-codec-encoder(-[a-z0-9_]+)?\.gguf$/i
+const DIALOGUE_BACKBONE_RE = /^moss-ttsd(-[a-z0-9_]+)?\.gguf$/i
+const DIALOGUE_TEXT =
+  '[S1] And so, my fellow Americans, [S2] ask what you can do for your country. ' +
+  '[S1] Did the build finish this morning? [S2] Yes, every single test passed.'
+const SPEAKER_ONE_SECONDS = [0, 3.29]
+const SPEAKER_TWO_SECONDS = [7.6, 10.6]
+const SHORT_DURATION_TOKENS = 25
+const LONG_DURATION_TOKENS = 100
+const INT16_FULL_SCALE = 32767
+const CPU_DEVICE = 0
+const CPU_BACKEND = 0
+const GPU_DEVICE = 1
+
+const 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({
+    threads: TTS_TEST_THREADS,
+    engine: TTSGgml.ENGINE_MOSS,
+    files: { modelDir: path.resolve(modelDir) },
+    config: { language: 'en', useGPU },
+    opts: { stats: true },
+    ...extra
+  })
+}
+
+function toInt16(samples) {
+  return Array.from(samples, (sample) => Math.round(sample * INT16_FULL_SCALE))
+}
+
+function resampleToMossRate(sourcePath) {
+  const source = readWavAsFloat32(sourcePath)
+  return resampleLinear(source.samples, source.sampleRate, MOSS_SAMPLE_RATE)
+}
+
+function writeMossWav(samples, tag) {
+  const target = path.join(os.tmpdir(), `moss-${tag}-${Date.now()}.wav`)
+  createWav(toInt16(samples), MOSS_SAMPLE_RATE, target)
+  return target
+}
+
+function writeReferenceAtMossRate(sourcePath) {
+  return writeMossWav(resampleToMossRate(sourcePath), 'reference')
+}
+
+function sliceSeconds(samples, [from, to]) {
+  return samples.slice(Math.round(from * MOSS_SAMPLE_RATE), Math.round(to * MOSS_SAMPLE_RATE))
+}
+
+function writeSpeakerReferences(sourcePath) {
+  const samples = resampleToMossRate(sourcePath)
+  return [
+    writeMossWav(sliceSeconds(samples, SPEAKER_ONE_SECONDS), 'speaker-1'),
+    writeMossWav(sliceSeconds(samples, SPEAKER_TWO_SECONDS), 'speaker-2')
+  ]
+}
+
+function removeFiles(paths) {
+  for (const file of paths) fs.unlinkSync(file)
+}
+
+function modelDirHas(pattern) {
+  return !skipWithoutModels && fs.readdirSync(modelDir).some((entry) => pattern.test(entry))
+}
+
+function hasEncoder() {
+  return modelDirHas(ENCODER_RE)
+}
+
+function hasDialogueBackbone() {
+  return modelDirHas(DIALOGUE_BACKBONE_RE)
+}
+
+function collectChunk(result, data) {
+  if (!data || !data.outputArray) return
+  result.chunks.push(data.outputArray.length)
+  result.samples = result.samples.concat(Array.from(data.outputArray))
+  if (data.sampleRate) result.sampleRate = data.sampleRate
+}
+
+async function synthesize(model, text) {
+  const response = await model.run({ input: text, type: 'text' })
+  const result = { samples: [], chunks: [], sampleRate: null }
+  await response.onUpdate((data) => collectChunk(result, data)).await()
+  result.stats = response.stats
+  return result
+}
+
+function assertAudio(t, label, result) {
+  t.ok(result.samples.length > 0, `${label} produced audio`)
+  t.is(result.sampleRate, MOSS_SAMPLE_RATE, `${label} reports 24 kHz`)
+  t.ok(result.stats, `${label} returns runtime stats`)
+  t.is(result.stats.totalSamples, result.samples.length, `${label} reports the emitted samples`)
+  t.ok(result.stats.generatedFrames > 0, `${label} reports generated codec frames`)
+  t.ok(result.stats.tokensPerSecond > 0, `${label} reports codec frames per second`)
+}
+
+function nonEmptyChunks(result) {
+  return result.chunks.filter((length) => length > 0)
+}
+
+function recordMoss(t, label, result, wallMs) {
+  t.comment(
+    recordTtsStats(label, result.stats, {
+      wallMs,
+      sampleCount: result.samples.length,
+      model: 'moss',
+      output: label
+    })
+  )
+}
+
+function assertCpuBackend(t, label, stats) {
+  t.is(stats.backendDevice, CPU_DEVICE, `${label} reports a CPU device`)
+  t.is(stats.backendId, CPU_BACKEND, `${label} reports the CPU backend`)
+}
+
+async function withLoadedModel(extra, body, useGPU = false) {
+  const model = createMossModel(extra, useGPU)
+  await model.load()
+  try {
+    await body(model)
+  } finally {
+    await model.unload()
+  }
+}
+
+test(
+  'MOSS TTS: batch synthesis through the public JS API',
+  { timeout: TEST_TIMEOUT_MS, skip: skipWithoutModels },
+  async (t) => {
+    await withLoadedModel({}, async (model) => {
+      const started = Date.now()
+      const result = await synthesize(model, SYNTHESIS_TEXT)
+      assertAudio(t, 'MOSS batch', result)
+      assertCpuBackend(t, 'MOSS batch', result.stats)
+      t.is(nonEmptyChunks(result).length, 1, 'batch synthesis emits one buffer')
+      recordMoss(t, 'moss batch', result, Date.now() - started)
+    })
+  }
+)
+
+test(
+  'MOSS TTS: native chunk streaming emits frame-sized chunks',
+  { timeout: TEST_TIMEOUT_MS, skip: skipWithoutModels },
+  async (t) => {
+    await withLoadedModel({ streamChunkTokens: MOSS_STREAM_FRAMES }, async (model) => {
+      const started = Date.now()
+      const result = await synthesize(model, SYNTHESIS_TEXT)
+      assertAudio(t, 'MOSS stream', result)
+      const chunks = nonEmptyChunks(result)
+      t.ok(chunks.length > 1, `streaming emits several chunks (got ${chunks.length})`)
+      t.ok(
+        chunks.every((length) => length <= MOSS_STREAM_FRAMES * MOSS_SAMPLES_PER_FRAME),
+        'no chunk exceeds the configured frame count'
+      )
+      recordMoss(t, 'moss stream', result, Date.now() - started)
+    })
+  }
+)
+
+test(
+  'MOSS TTS: useGPU=true synthesizes on a GPU backend',
+  { timeout: TEST_TIMEOUT_MS, skip: skipWithoutModels || noGpu },
+  async (t) => {
+    await withLoadedModel(
+      {},
+      async (model) => {
+        const started = Date.now()
+        const result = await synthesize(model, SYNTHESIS_TEXT)
+        assertAudio(t, 'MOSS GPU', result)
+        t.is(result.stats.backendDevice, GPU_DEVICE, 'MOSS GPU reports a GPU device')
+        t.not(result.stats.backendId, CPU_BACKEND, 'MOSS GPU does not report the CPU backend')
+        t.is(result.stats.gpuUnsupported, 0, 'MOSS GPU does not report a GPU fallback')
+        recordMoss(t, 'moss gpu', result, Date.now() - started)
+      },
+      true
+    )
+  }
+)
+
+test(
+  'MOSS TTS: voice cloning synthesizes from a reference recording',
+  { timeout: TEST_TIMEOUT_MS, skip: skipWithoutModels },
+  async (t) => {
+    const sourceAudio = resolveRefWavPath({})
+    if (!hasEncoder()) {
+      t.comment(`skipping: no moss-codec-encoder GGUF in ${modelDir}`)
+      return
+    }
+    if (!fs.existsSync(sourceAudio)) {
+      t.fail(`MOSS reference audio is missing: ${sourceAudio}`)
+      return
+    }
+    const referenceAudio = writeReferenceAtMossRate(sourceAudio)
+    try {
+      await withLoadedModel({ referenceAudio, seed: 7 }, async (model) => {
+        const started = Date.now()
+        const result = await synthesize(model, SYNTHESIS_TEXT)
+        assertAudio(t, 'MOSS clone', result)
+        recordMoss(t, 'moss clone', result, Date.now() - started)
+      })
+    } finally {
+      fs.unlinkSync(referenceAudio)
+    }
+  }
+)
+
+test(
+  'MOSS TTS: durationTokens steers the length of the synthesized speech',
+  { timeout: TEST_TIMEOUT_MS, skip: skipWithoutModels },
+  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)`
+      )
+    })
+  }
+)
+
+test(
+  'MOSS TTS: dialogue synthesis clones one reference per speaker',
+  { timeout: TEST_TIMEOUT_MS, skip: skipWithoutModels },
+  async (t) => {
+    if (!hasDialogueBackbone() || !hasEncoder()) {
+      t.comment(`skipping: the TTSD backbone or the codec encoder is not in ${modelDir}`)
+      return
+    }
+    const sourceAudio = resolveRefWavPath({})
+    if (!fs.existsSync(sourceAudio)) {
+      t.fail(`MOSS reference audio is missing: ${sourceAudio}`)
+      return
+    }
+    const references = writeSpeakerReferences(sourceAudio)
+    try {
+      await withLoadedModel(
+        { dialogueReferences: references, seed: 7, files: { modelDir: path.resolve(modelDir) } },
+        async (model) => {
+          t.ok(
+            DIALOGUE_BACKBONE_RE.test(path.basename(model._mossBackbonePath)),
+            'dialogue picks the TTSD backbone'
+          )
+          const started = Date.now()
+          const result = await synthesize(model, DIALOGUE_TEXT)
+          assertAudio(t, 'MOSS dialogue', result)
+          recordMoss(t, 'moss dialogue', result, Date.now() - started)
+        }
+      )
+    } finally {
+      removeFiles(references)
+    }
+  }
+)

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

@@ -29,6 +29,7 @@ const {
 } = require('../utils/runChatterboxTTS')
 const { loadSupertonicTTS, runSupertonicTTS } = require('../utils/runSupertonicTTS')
 const { ensureChatterboxModels, ensureSupertonicModel } = require('../utils/downloadModel')
+const { TTS_TEST_THREADS } = require('../utils/testThreads')
 
 const platform = os.platform()
 const isMobile = platform === 'ios' || platform === 'android'
@@ -73,6 +74,7 @@ test(
     }
 
     const model = await loadChatterboxTTS({
+      threads: TTS_TEST_THREADS,
       modelDir: download.targetDir,
       refWavPath,
       language: 'en'
@@ -137,6 +139,7 @@ test(
     for (let i = 0; i < N; i++) {
       const t0 = Date.now()
       const model = await loadChatterboxTTS({
+        threads: TTS_TEST_THREADS,
         modelDir: download.targetDir,
         refWavPath,
         language: 'en'
@@ -195,6 +198,7 @@ test('Chatterbox: reload() between runs preserves stability', { timeout: 1800000
   }
 
   const model = await loadChatterboxTTS({
+    threads: TTS_TEST_THREADS,
     modelDir: download.targetDir,
     refWavPath,
     language: 'en'
@@ -235,6 +239,7 @@ test('Supertonic: reload() between runs preserves stability', { timeout: 1800000
   }
 
   const model = await loadSupertonicTTS({
+    threads: TTS_TEST_THREADS,
     supertonicModelPath: download.path,
     voice: 'F1',
     language: 'en',
@@ -291,7 +296,12 @@ test(
       return
     }
 
-    const c1 = await loadChatterboxTTS({ modelDir: cb.targetDir, refWavPath, language: 'en' })
+    const c1 = await loadChatterboxTTS({
+      threads: TTS_TEST_THREADS,
+      modelDir: cb.targetDir,
+      refWavPath,
+      language: 'en'
+    })
     try {
       const r = await runChatterboxTTS(c1, { text: 'Hello from chatterbox.' }, { minSamples: 5000 })
       t.ok(r.passed, 'first chatterbox instance OK')
@@ -302,6 +312,7 @@ test(
     }
 
     const s1 = await loadSupertonicTTS({
+      threads: TTS_TEST_THREADS,
       supertonicModelPath: st.path,
       voice: 'F1',
       language: 'en',
@@ -316,7 +327,12 @@ test(
       } catch (_e) {}
     }
 
-    const c2 = await loadChatterboxTTS({ modelDir: cb.targetDir, refWavPath, language: 'en' })
+    const c2 = await loadChatterboxTTS({
+      threads: TTS_TEST_THREADS,
+      modelDir: cb.targetDir,
+      refWavPath,
+      language: 'en'
+    })
     try {
       const r = await runChatterboxTTS(
         c2,

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

@@ -12,6 +12,7 @@ const test = require('brittle')
 const TTSGgml = require('@qvac/tts-ggml')
 
 const { ensureSupertonicModel, ensureParlerModel } = require('../utils/downloadModel')
+const { TTS_TEST_THREADS } = require('../utils/testThreads')
 
 const platform = os.platform()
 const isMobile = platform === 'ios' || platform === 'android'
@@ -40,6 +41,7 @@ async function collect(model, text) {
 // JS half, which must forward the combination rather than reject it up front.
 test('CosyVoice3: enhancer + streaming forwards a non-native outputSampleRate', (t) => {
   const model = new TTSGgml({
+    threads: TTS_TEST_THREADS,
     engine: TTSGgml.ENGINE_COSYVOICE3,
     files: {
       cosyvoiceModelDir: './models/cosyvoice3',
@@ -72,6 +74,7 @@ test(
     const text = 'Output rate selection resamples the synthesized audio.'
 
     const native = new TTSGgml({
+      threads: TTS_TEST_THREADS,
       engine: TTSGgml.ENGINE_SUPERTONIC,
       files: { supertonicModel: dl.path },
       voice: 'F1',
@@ -91,6 +94,7 @@ test(
     }
 
     const resampled = new TTSGgml({
+      threads: TTS_TEST_THREADS,
       engine: TTSGgml.ENGINE_SUPERTONIC,
       files: { supertonicModel: dl.path },
       voice: 'F1',
@@ -131,6 +135,7 @@ test(
     const text = 'Output rate selection resamples the synthesized audio.'
 
     const native = new TTSGgml({
+      threads: TTS_TEST_THREADS,
       engine: TTSGgml.ENGINE_PARLER,
       files: { parlerModel: dl.path },
       voice: 'Laura',
@@ -150,6 +155,7 @@ test(
     }
 
     const resampled = new TTSGgml({
+      threads: TTS_TEST_THREADS,
       engine: TTSGgml.ENGINE_PARLER,
       files: { parlerModel: dl.path },
       voice: 'Laura',

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

@@ -19,6 +19,7 @@ const test = require('brittle')
 const { loadParlerTTS, runParlerTTS } = require('../utils/runParlerTTS')
 const { ensureParlerModel, ensureWhisperModel } = require('../utils/downloadModel')
 const { loadWhisper, runWhisper } = require('../utils/runWhisper')
+const { TTS_TEST_THREADS } = require('../utils/testThreads')
 
 const platform = os.platform()
 const isDarwin = platform === 'darwin'
@@ -77,7 +78,12 @@ for (const { variant } of PARLER_WER_TIERS) {
       }
 
       const useGPU = isApple && !NO_GPU
-      const model = await loadParlerTTS({ parlerModelPath: download.path, seed: 42, useGPU })
+      const model = await loadParlerTTS({
+        threads: TTS_TEST_THREADS,
+        parlerModelPath: download.path,
+        seed: 42,
+        useGPU
+      })
       const entries = []
       try {
         for (const text of WER_SENTENCES) {

package/test/integration/parler.test.js

@@ -13,6 +13,7 @@ const test = require('brittle')
 const { loadParlerTTS, runParlerTTS } = require('../utils/runParlerTTS')
 const { ensureParlerModel } = 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'
@@ -39,7 +40,11 @@ test(
 
     // Deliberately NO description/voice/emotion: the engine renders the
     // models' recommended fallback caption — everything works on defaults.
-    const model = await loadParlerTTS({ parlerModelPath: download.path, seed: 42 })
+    const model = await loadParlerTTS({
+      threads: TTS_TEST_THREADS,
+      parlerModelPath: download.path,
+      seed: 42
+    })
     try {
       const wavPath = isMobile ? undefined : path.join(baseDir, 'test', 'output', 'parler-en.wav')
       const text = 'The parler engine speaks with a voice controlled by a text description.'
@@ -100,7 +105,11 @@ test(
       return
     }
 
-    const model = await loadParlerTTS({ parlerModelPath: download.path, voice: 'Laura' })
+    const model = await loadParlerTTS({
+      threads: TTS_TEST_THREADS,
+      parlerModelPath: download.path,
+      voice: 'Laura'
+    })
     try {
       const response = await model.run({
         type: 'text',
@@ -143,6 +152,7 @@ test(
     t.exception(
       () =>
         new TTSGgml({
+          threads: TTS_TEST_THREADS,
           engine: TTSGgml.ENGINE_PARLER,
           files: { parlerModel: download.path },
           description: 'A calm female voice.',
@@ -157,6 +167,7 @@ test(
     t.exception(
       () =>
         new TTSGgml({
+          threads: TTS_TEST_THREADS,
           engine: TTSGgml.ENGINE_SUPERTONIC,
           files: { supertonicModel: download.path },
           emotion: 'happy'
@@ -167,6 +178,7 @@ test(
     t.exception(
       () =>
         new TTSGgml({
+          threads: TTS_TEST_THREADS,
           engine: TTSGgml.ENGINE_SUPERTONIC,
           files: { supertonicModel: download.path },
           pitch: 'high'
@@ -176,6 +188,7 @@ test(
     )
 
     const model = await loadParlerTTS({
+      threads: TTS_TEST_THREADS,
       parlerModelPath: download.path,
       voice: 'Laura',
       seed: 42
@@ -218,6 +231,7 @@ test(
 
     // Constructor-level free-text description + per-call template rejects.
     const descModel = await loadParlerTTS({
+      threads: TTS_TEST_THREADS,
       parlerModelPath: download.path,
       description: 'A calm female voice, very clear audio.',
       seed: 42
@@ -248,6 +262,7 @@ test(
     }
 
     const model = await loadParlerTTS({
+      threads: TTS_TEST_THREADS,
       parlerModelPath: download.path,
       voice: 'Laura',
       seed: 42
@@ -295,6 +310,7 @@ test(
     }
 
     const model = await loadParlerTTS({
+      threads: TTS_TEST_THREADS,
       parlerModelPath: download.path,
       voice: 'Laura',
       emotion: 'neutral',
@@ -340,6 +356,7 @@ test(
 
     const TTSGgml = require('@qvac/tts-ggml')
     const model = new TTSGgml({
+      threads: TTS_TEST_THREADS,
       engine: TTSGgml.ENGINE_PARLER,
       files: { parlerModel: download.path },
       seed: 42,
@@ -392,6 +409,7 @@ test(
 
     async function synth(extra) {
       const model = new TTSGgml({
+        threads: TTS_TEST_THREADS,
         engine: TTSGgml.ENGINE_PARLER,
         files: { parlerModel: download.path },
         seed: 42,
@@ -481,6 +499,7 @@ test(
     }
 
     const model = await loadParlerTTS({
+      threads: TTS_TEST_THREADS,
       parlerModelPath: download.path,
       voice: 'Rohit',
       emotion: 'happy',
@@ -542,7 +561,12 @@ for (const { variant, quant } of PARLER_QUANT_MATRIX) {
       }
 
       const useGPU = isApple && !NO_GPU
-      const model = await loadParlerTTS({ parlerModelPath: download.path, seed: 42, useGPU })
+      const model = await loadParlerTTS({
+        threads: TTS_TEST_THREADS,
+        parlerModelPath: download.path,
+        seed: 42,
+        useGPU
+      })
       try {
         const text =
           variant === 'indic'

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()
+    }
+  }
+)