@qvac/tts-ggml 0.14.0 → 0.15.0

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@qvac/tts-ggml",
-  "version": "0.14.0",
+  "version": "0.15.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-23"
+    "ggml-speech": "2026-10-27#1"
   },
   "engines": {
     "bare": ">=1.19.0"
@@ -65,7 +65,7 @@
     "example:moss-sfx": "bare examples/moss-sound-effect.js \"Heavy rain falling on a tin roof with distant thunder.\" 5",
     "example:moss-speech": "bare examples/moss-speech.js test/reference-audio/jfk.wav",
     "lint": "npm run lint:js && npm run lint:ts && npm run test:types",
-    "lint:js": "prettier --check \"test/**/*.js\" \"scripts/run-cpp-fuzz.js\" \"scripts/__tests__/package-contract.test.js\" \"scripts/__tests__/run-cpp-fuzz.test.js\" \"binding.js\" \"addon-unavailable.js\" && lunte \"test/**/*.js\" \"scripts/run-cpp-fuzz.js\" \"scripts/__tests__/package-contract.test.js\" \"scripts/__tests__/run-cpp-fuzz.test.js\" \"binding.js\" \"addon-unavailable.js\"",
+    "lint:js": "prettier --check \"test/**/*.js\" \"scripts/run-cpp-fuzz.js\" \"scripts/__tests__/package-contract.test.js\" \"scripts/__tests__/backend-distribution.test.js\" \"scripts/__tests__/run-cpp-fuzz.test.js\" \"binding.js\" \"addon-unavailable.js\" && lunte \"test/**/*.js\" \"scripts/run-cpp-fuzz.js\" \"scripts/__tests__/package-contract.test.js\" \"scripts/__tests__/backend-distribution.test.js\" \"scripts/__tests__/run-cpp-fuzz.test.js\" \"binding.js\" \"addon-unavailable.js\"",
     "lint:ts": "eslint \"src/**/*.ts\" --max-warnings=0",
     "lint:ts:fix": "eslint \"src/**/*.ts\" --fix",
     "format": "prettier --write \"test/**/*.js\" \"scripts/__tests__/package-contract.test.js\" \"binding.js\" \"addon-unavailable.js\"",
@@ -106,7 +106,8 @@
     "download-models:registry": "node scripts/download-tts-ggml-models.js",
     "download-models:smoke": "node scripts/download-tts-ggml-models.js --group supertonic",
     "example:pocket": "bare examples/pocket-tts.js",
-    "test:pocket": "npm run build:ts && brittle-bare test/integration/pocket.integration.test.js"
+    "test:pocket": "npm run build:ts && brittle-bare test/integration/pocket.integration.test.js",
+    "example:fabric-controls": "bare examples/fabric-controls.js"
   },
   "files": [
     "addonLogging.js",
@@ -218,16 +219,16 @@
     "bare-url": "^2.4.3"
   },
   "optionalDependencies": {
-    "@qvac/tts-ggml-linux-x64": "0.14.0",
-    "@qvac/tts-ggml-linux-arm64": "0.14.0",
-    "@qvac/tts-ggml-darwin-arm64": "0.14.0",
-    "@qvac/tts-ggml-darwin-x64": "0.14.0",
-    "@qvac/tts-ggml-win32-x64": "0.14.0"
+    "@qvac/tts-ggml-linux-x64": "0.15.0",
+    "@qvac/tts-ggml-linux-arm64": "0.15.0",
+    "@qvac/tts-ggml-darwin-arm64": "0.15.0",
+    "@qvac/tts-ggml-darwin-x64": "0.15.0",
+    "@qvac/tts-ggml-win32-x64": "0.15.0"
   },
   "types": "index.d.ts",
   "peerDependencies": {
-    "@qvac/tts-ggml-android-arm64": "0.14.0",
-    "@qvac/tts-ggml-ios": "0.14.0"
+    "@qvac/tts-ggml-android-arm64": "0.15.0",
+    "@qvac/tts-ggml-ios": "0.15.0"
   },
   "peerDependenciesMeta": {
     "@qvac/tts-ggml-android-arm64": {

package/test/integration/audio8-streaming.test.js

@@ -0,0 +1,66 @@
+'use strict'
+
+const test = require('brittle')
+const process = require('bare-process')
+const TTSGgml = require('../..')
+
+const LM = process.env.QVAC_TEST_AUDIO8_LM_GGUF
+const DECODER = process.env.QVAC_TEST_AUDIO8_DECODER_GGUF
+const FRAME_LIMIT = 48
+const TEXT = 'The listener should hear the first words before the complete response is generated.'
+const TIMEOUT_MS = 180000
+
+async function modelFiles() {
+  if (LM && DECODER) return { audio8Lm: LM, audio8CodecDecoder: DECODER }
+  const { ensureAudio8Models } = require('../utils/downloadModel')
+  const models = await ensureAudio8Models({ includeEncoder: false })
+  if (!models.success) throw new Error('Audio8 streaming tests require LM and decoder GGUFs')
+  return { audio8Lm: models.lmPath, audio8CodecDecoder: models.decoderPath }
+}
+
+async function* source() {
+  yield TEXT
+}
+
+function run(model, method) {
+  if (method === 'runStream') return model.runStream(TEXT)
+  if (method === 'runStreaming') {
+    return model.runStreaming(source(), { accumulateSentences: false })
+  }
+  return model.run({ input: TEXT, streamOutput: true })
+}
+
+for (const method of ['runStream', 'runStreaming', 'streamOutput']) {
+  test(
+    `Audio8 ${method} delivers native PCM without replay`,
+    { timeout: TIMEOUT_MS },
+    async (t) => {
+      const model = new TTSGgml({
+        engine: TTSGgml.ENGINE_AUDIO8,
+        files: await modelFiles(),
+        greedy: true,
+        threads: 4,
+        maxFrames: FRAME_LIMIT,
+        opts: { stats: true }
+      })
+      try {
+        await model.load()
+        let chunks = 0
+        let samples = 0
+        const response = await run(model, method)
+        response.onUpdate((chunk) => {
+          if (!chunk.outputArray?.length) return
+          t.is(chunk.sampleRate, 44100)
+          chunks++
+          samples += chunk.outputArray.length
+        })
+        await response.await()
+        t.ok(chunks > 1, 'multiple codec windows reached JavaScript')
+        t.is(samples, response.stats.totalSamples, 'PCM was delivered exactly once')
+        t.is(response.stats.generatedFrames, FRAME_LIMIT)
+      } finally {
+        await model.unload()
+      }
+    }
+  )
+}

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

@@ -0,0 +1,124 @@
+'use strict'
+
+const path = require('bare-path')
+const proc = require('bare-process')
+const test = require('brittle')
+const TTSGgml = require('../../index')
+const { ensureCosyvoiceModel, ensureSupertonicModel } = require('../utils/downloadModel')
+const { getBaseDir } = require('../utils/runTTS')
+const { NO_GPU, GPU_ONLY_USE_GPU } = require('../utils/gpuOnly')
+const { TTS_TEST_THREADS } = require('../utils/testThreads')
+
+async function collect(response) {
+  let samples = 0
+  let terminalCount = 0
+  let tokenIds
+  for await (const chunk of response.iterate()) {
+    samples += chunk.outputArray.length
+    if (chunk.isLast) terminalCount++
+    if (chunk.speechTokenIds) tokenIds = chunk.speechTokenIds
+  }
+  return { samples, terminalCount, tokenIds }
+}
+
+test(
+  'CosyVoice returns owned speech tokens and replays them through native streaming',
+  { skip: NO_GPU },
+  async (t) => {
+    const download = await ensureCosyvoiceModel({
+      targetDir: path.join(getBaseDir(), 'models', 'cosyvoice3')
+    })
+    t.ok(download.success, 'CosyVoice bundle is available')
+    if (!download.success) return
+    const model = new TTSGgml({
+      engine: 'cosyvoice3',
+      files: { cosyvoiceModelDir: download.modelDir },
+      config: { useGPU: GPU_ONLY_USE_GPU },
+      threads: TTS_TEST_THREADS,
+      seed: 42,
+      greedy: true,
+      opts: { stats: true }
+    })
+    try {
+      await model.load()
+      const first = await collect(await model.run({ input: 'Hello from the speech addon.' }))
+      t.ok(first.samples > 0, 'batch synthesis emits audio')
+      t.ok(first.tokenIds.length > 0, 'batch synthesis returns its speech token trajectory')
+      const retained = first.tokenIds.slice()
+      await model.reload({ forceSpeechTokens: first.tokenIds, streamChunkTokens: 25 })
+      const replay = await model.run({ input: 'Hello from the speech addon.' })
+      const streamed = await collect(replay)
+      t.ok(streamed.samples > 0, 'forced trajectory emits streamed audio')
+      t.is(streamed.terminalCount, 1, 'streaming emits exactly one terminal chunk')
+      t.alike(streamed.tokenIds, retained, 'returned IDs match the forced trajectory')
+      t.alike(first.tokenIds, retained, 'a subsequent synthesis preserves the first result')
+      t.is(replay.stats.speechTokens, retained.length, 'numeric speechTokens remains a count')
+      t.is(replay.stats.totalSamples, streamed.samples, 'stream and stats account for the same PCM')
+      await t.exception(
+        model.reload({ forceSpeechTokens: [2147483647] }),
+        /vocabulary/,
+        'an out-of-vocabulary forced ID rejects without aborting the process'
+      )
+    } finally {
+      await model.destroy()
+    }
+  }
+)
+
+test('Supertonic accepts precision controls and remains usable after warmUp', async (t) => {
+  const download = await ensureSupertonicModel({ targetDir: path.join(getBaseDir(), 'models') })
+  t.ok(download.success, 'Supertonic model is available')
+  if (!download.success) return
+  const model = new TTSGgml({
+    engine: 'supertonic',
+    files: { supertonicModel: download.path },
+    config: { backend: 'cpu' },
+    threads: TTS_TEST_THREADS,
+    voice: 'F1',
+    precision: 'f32',
+    f16Weights: 0,
+    f16Attn: 0,
+    kvAttnType: 0
+  })
+  try {
+    await model.load()
+    t.is(
+      await model.warmUp('Speech is ready.'),
+      undefined,
+      'warmUp completes without an audio response'
+    )
+    const result = await collect(await model.run({ input: 'Speech is ready.' }))
+    t.ok(result.samples > 0, 'normal synthesis works after warmUp')
+  } finally {
+    await model.destroy()
+  }
+})
+
+test(
+  'Pocket preflight applies an explicit memory budget without loading a model',
+  { skip: !proc.env.QVAC_POCKET_MODEL_DIR },
+  async (t) => {
+    const bundle = proc.env.QVAC_POCKET_MODEL_DIR
+    const request = {
+      engineType: 'pocket',
+      pocketFlowModelPath: path.join(bundle, 'flow-lm.gguf'),
+      pocketMimiModelPath: path.join(bundle, 'mimi.gguf'),
+      pocketFrontendPath: path.join(bundle, 'frontend.json'),
+      pocketVoicePath: path.join(bundle, 'voice.gguf'),
+      backend: 'cpu',
+      threads: TTS_TEST_THREADS,
+      text: 'Project this sentence.'
+    }
+    const result = await TTSGgml.assessFit(request)
+    t.is(result.status, 'fits', 'native metadata-only projection fits')
+    t.is(result.devices.length, 1, 'a CPU projection has one host pool')
+    t.ok(result.devices[0].usedBytes > 0, 'metadata accounts for the load')
+    const constrained = await TTSGgml.assessFit({ ...request, memoryBudgetBytes: 1 })
+    t.is(constrained.status, 'does-not-fit', 'application memory budget affects the projection')
+    t.is(
+      constrained.devices[0].usedBytes,
+      result.devices[0].usedBytes,
+      'the same metadata is used for both budgets'
+    )
+  }
+)

package/test/integration/fit.test.js

@@ -27,16 +27,20 @@ async function supertonicPath(t) {
 /**
  * The supertonic fitter covers the fused graph path: a validated GPU, or a CPU
  * without the Accelerate pointwise kernels. A runner outside that answers
- * `compute-path-not-supported`. That is a refusal, and it carries no figures.
+ * `unknown`, and it carries no rows.
  */
 function projected(t, fit) {
-  if (fit.reason === 'compute-path-not-supported') {
-    t.pass('this runner’s compute path is not modelled')
+  if (fit.status === 'unknown') {
+    t.is(fit.devices.length, 0, 'an unknown carries no rows')
     return false
   }
   return true
 }
 
+function hostRow(fit) {
+  return fit.devices[fit.devices.length - 1]
+}
+
 function tempDir(t) {
   const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'tts-fit-'))
   t.teardown(() => fs.rmSync(dir, { recursive: true, force: true }))
@@ -70,14 +74,19 @@ test('a projection is internally consistent', { timeout: TEST_TIMEOUT_MS }, asyn
     useGPU: true
   })
 
-  t.comment(`status=${fit.status} reason=${fit.reason} device=${fit.deviceName}`)
+  t.comment(JSON.stringify(fit))
   if (!projected(t, fit)) return
-  t.ok(fit.status === 'fits' || fit.status === 'does-not-fit', 'a verdict, not an error')
-  t.ok(fit.deviceTotalBytes > 0, 'the device reported its capacity')
-  t.ok(fit.deviceFreeBytes <= fit.deviceTotalBytes, 'free never exceeds total')
-  t.ok(fit.weightsBytes > 0, 'the weights were measured')
-  t.ok(fit.deviceBytes >= fit.weightsBytes, 'weights are part of the device demand')
-  t.is(fit.lavasrFileBytes, 0, 'no LavaSR stage was named')
+  t.ok(fit.status === 'fits' || fit.status === 'does-not-fit', 'a verdict')
+  t.ok(fit.devices.length >= 1, 'at least the device the load resolves to')
+  for (const row of fit.devices) {
+    t.ok(row.id.length > 0 && row.name.length > 0, `${row.name} is named`)
+    t.ok(row.totalBytes > 0, `${row.name} reported its capacity`)
+    t.ok(row.freeBytes <= row.totalBytes, `${row.name} free never exceeds total`)
+  }
+  t.ok(fit.devices[0].usedBytes > 0, 'the device demand was measured')
+  t.is(hostRow(fit).name, 'CPU', 'the host row is last')
+  t.ok(hostRow(fit).unified, 'the host row is unified')
+  t.alike(fit.stats, {})
 })
 
 test('a weightless copy projects the same', { timeout: TEST_TIMEOUT_MS }, async (t) => {
@@ -97,9 +106,11 @@ test('a weightless copy projects the same', { timeout: TEST_TIMEOUT_MS }, async
   })
 
   t.is(stub.status, full.status, 'the same verdict')
-  t.is(stub.weightsBytes, full.weightsBytes, 'the same weight footprint')
-  t.is(stub.deviceBytes, full.deviceBytes, 'the same device demand')
-  t.is(stub.hostBytes, full.hostBytes, 'the same host demand')
+  t.alike(
+    stub.devices.map((row) => [row.id, row.usedBytes]),
+    full.devices.map((row) => [row.id, row.usedBytes]),
+    'the same demand on the same devices'
+  )
 })
 
 test('the load’s offload keys reach the projection', { timeout: TEST_TIMEOUT_MS }, async (t) => {
@@ -117,28 +128,14 @@ test('the load’s offload keys reach the projection', { timeout: TEST_TIMEOUT_M
     nGpuLayers: 0
   })
 
-  t.ok(cpu.deviceIsCpu, 'useGPU false projects on the CPU device')
-  t.is(pinned.deviceIsCpu, cpu.deviceIsCpu, 'nGpuLayers 0 agrees with useGPU false')
-})
-
-test('a LavaSR stage is sized beside the projection', { 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 fit = await TTSGgml.assessFit({
-    engineType: 'supertonic',
-    supertonicModelPath: model,
-    useGPU: true,
-    lavasrEnhancerPath: enhancer
-  })
-
-  t.is(fit.lavasrFileBytes, 4096, 'the enhancer is reported at its size on disk')
-  if (!projected(t, fit)) return
-  t.ok(fit.lavasrFileBytes < fit.deviceBytes, 'reported beside the projection')
+  t.is(pinned.status, cpu.status, 'nGpuLayers 0 agrees with useGPU false')
+  if (!projected(t, cpu)) return
+  t.is(cpu.devices.length, 1, 'useGPU false projects on the CPU alone')
+  t.ok(cpu.devices[0].unified, 'the CPU row is the host')
+  // Free memory is read again by each call, so only the placement and the
+  // demand are compared.
+  const placement = (fit) => fit.devices.map(({ freeBytes, ...row }) => row)
+  t.alike(placement(pinned), placement(cpu), 'the same row')
 })
 
 test('fitting keeps the event loop responsive', { timeout: TEST_TIMEOUT_MS }, async (t) => {
@@ -166,9 +163,7 @@ test('fitting keeps the event loop responsive', { timeout: TEST_TIMEOUT_MS }, as
 
   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')
-  }
+  t.is(new Set(fits.map((fit) => fit.status)).size, 1, 'every queued projection agrees')
 })
 
 test(
@@ -178,28 +173,16 @@ test(
     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 request = { engineType: 'supertonic', supertonicModelPath: model, useGPU: true }
     const first = TTSGgml.assessFit(request)
-    request.lavasrEnhancerPath = ''
+    request.supertonicModelPath = '/nonexistent/model.gguf'
     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])
+    const third = TTSGgml.assessFit({ ...request, supertonicModelPath: model })
+    const [a, b, c] = await Promise.allSettled([first, second, third])
 
-    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')
+    t.is(a.status, 'fulfilled', 'the first call owns its original request')
+    t.is(b.status, 'rejected', 'the second call owns its changed request')
+    t.is(c.status, 'fulfilled', 'a rejection does not strand queued callers')
   }
 )
 
@@ -218,11 +201,11 @@ test('a fit settles while a loaded model unloads', { timeout: TEST_TIMEOUT_MS },
     const fit = TTSGgml.assessFit({
       engineType: 'supertonic',
       supertonicModelPath: model,
-      useGPU: false
+      useGPU: true
     })
     await voice.unload()
     const result = await fit
-    t.ok(result.deviceTotalBytes > 0, 'the projection measured a device')
+    t.ok(['fits', 'does-not-fit', 'unknown'].includes(result.status), 'the fit settled')
   } finally {
     try {
       await voice.unload()
@@ -231,27 +214,34 @@ test('a fit settles while a loaded model unloads', { timeout: TEST_TIMEOUT_MS },
 })
 
 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',
-    promptRows: 128,
-    referenceSamples: 0,
-    streaming: false
-  })
-
-  t.is(fit.status, 'error')
-  t.is(fit.reason, 'model-unreadable')
-  t.is(fit.modelVariant, 'moss')
+  await t.exception(
+    TTSGgml.assessFit({
+      engineType: 'moss',
+      mossBackbonePath: '/models/moss-tts-delay.gguf',
+      mossCodecDecoderPath: '/models/moss-codec-decoder.gguf',
+      promptRows: 128,
+      referenceSamples: 0,
+      streaming: false
+    }),
+    /model-unreadable/
+  )
 })
 
-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'
-  })
+test('a model that cannot be read rejects', async (t) => {
+  await t.exception(
+    TTSGgml.assessFit({
+      engineType: 'supertonic',
+      supertonicModelPath: '/nonexistent/model.gguf'
+    }),
+    /model-unreadable/
+  )
+})
 
-  t.is(fit.status, 'error')
+test('a voice with no fitter rejects', async (t) => {
+  await t.exception(
+    TTSGgml.assessFit({ engineType: 'moss-speech', mossSpeechModelPath: '/models/speech.gguf' }),
+    /has no fitter/
+  )
 })
 
 test('a count that is not a count is refused', async (t) => {

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

@@ -40,18 +40,18 @@ test('MOSS metadata-only fit covers batch, streaming and cloning', async (t) =>
     referenceSamples: 0,
     streaming: false
   }
+  const used = (fit) => fit.devices.reduce((total, row) => total + row.usedBytes, 0)
+
   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)
+  t.ok(batch.status === 'fits' || batch.status === 'does-not-fit', JSON.stringify(batch))
+  t.ok(batch.devices[0].usedBytes > 0)
   const stream = await TTSGgml.assessFit({ ...request, streaming: true })
-  t.not(stream.status, 'error', stream.report)
+  t.ok(stream.status === 'fits' || stream.status === 'does-not-fit', JSON.stringify(stream))
   const cloning = await TTSGgml.assessFit({
     ...request,
     mossCodecEncoderPath: path.join(modelDir, 'moss-codec-encoder-f16.gguf'),
     referenceSamples: 24000
   })
-  t.not(cloning.status, 'error', cloning.report)
-  t.ok(cloning.weightsBytes > batch.weightsBytes)
+  t.ok(cloning.status === 'fits' || cloning.status === 'does-not-fit', JSON.stringify(cloning))
+  t.ok(used(cloning) > used(batch), 'the encoder adds to the demand')
 })

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

@@ -24,11 +24,8 @@ test('MOSS sound-effect fit rejects missing workload and invalid load controls',
   await t.exception(TTSGgml.assessFit(request({ marginBytes: -1 })))
 })
 
-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')
+test('MOSS sound-effect fit rejects unreadable models', async (t) => {
+  await t.exception(TTSGgml.assessFit(request()), /model-unreadable/)
 })
 
 test(
@@ -41,23 +38,13 @@ test(
     const cfg = { mossSoundEffectPath: model }
     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)
-    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
-    )
+    t.is(fit.devices.length, 1, 'a CPU load is one row')
+    t.ok(fit.devices[0].unified, 'the CPU row is the host')
+    t.ok(fit.devices[0].usedBytes > 0)
     const shorter = await TTSGgml.assessFit(request({ ...cfg, seconds: 1 }))
-    t.is(shorter.weightsBytes, fit.weightsBytes)
-    t.is(shorter.lmComputeBytes, fit.lmComputeBytes)
+    t.ok(shorter.devices[0].usedBytes <= fit.devices[0].usedBytes, 'a shorter clip needs no more')
     const noHeadroom = await TTSGgml.assessFit(request({ ...cfg, marginBytes: Number.MAX_VALUE }))
     t.is(noHeadroom.status, 'does-not-fit')
-    const invalid = await TTSGgml.assessFit(request({ ...cfg, seconds: 0 }))
-    t.is(invalid.status, 'error')
-    t.is(invalid.reason, 'invalid-arguments')
+    await t.exception(TTSGgml.assessFit(request({ ...cfg, seconds: 0 })), /invalid-arguments/)
   }
 )

package/test/integration/native-options.test.js

@@ -0,0 +1,41 @@
+'use strict'
+
+const test = require('brittle')
+const binding = require('../../binding')
+const TTSGgml = require('../../index')
+
+const POCKET_FIT = {
+  engineType: 'pocket',
+  pocketFlowModelPath: '/missing/flow-lm.gguf',
+  pocketMimiModelPath: '/missing/mimi.gguf',
+  pocketFrontendPath: '/missing/frontend.json',
+  pocketVoicePath: '/missing/voice.gguf',
+  text: 'Project this sentence.'
+}
+
+test('Pocket preflight reaches its native fitter and validates explicit byte budgets', async (t) => {
+  const result = await TTSGgml.assessFit(POCKET_FIT)
+  t.is(result.status, 'unknown', 'an unmeasurable native projection stays unknown')
+  t.alike(result.devices, [])
+  t.alike(result.stats, {})
+  for (const memoryBudgetBytes of [-1, 1.5, Infinity]) {
+    await t.exception(
+      TTSGgml.assessFit({ ...POCKET_FIT, memoryBudgetBytes }),
+      /count|integer|finite/
+    )
+  }
+})
+
+test('native option parsing rejects malformed vectors and environment maps before loading weights', (t) => {
+  const cases = [
+    ['cosyvoice3', { forceSpeechTokens: [1.5] }, /integer/],
+    ['cosyvoice3', { forceSpeechTokens: [NaN] }, /integer/],
+    ['supertonic', { voiceStyleTtl: new Float32Array([Infinity]) }, /finite/],
+    ['supertonic', { voiceStyleDp: ['invalid'] }, /numbers/],
+    ['supertonic', { vulkanEnvOverrides: { GGML_VK_TEST: false } }, /string/],
+    ['moss', { textTemperature: Infinity }, /finite/]
+  ]
+  for (const [engineType, fields, error] of cases) {
+    t.exception(() => binding.createInstance({}, { engineType, ...fields }, () => {}), error)
+  }
+})

package/tts.d.ts

@@ -1,7 +1,8 @@
 export interface TTSConfigurationParams {
-    [key: string]: string | number | boolean | string[] | undefined;
+    [key: string]: string | number | boolean | string[] | number[] | Float32Array | Record<string, string> | undefined;
 }
 export interface TTSJobData {
+    streamOutput?: boolean;
     type: string;
     input: string;
     description?: string;