@qvac/tts-ggml 0.10.1 → 0.11.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@qvac/tts-ggml",
-  "version": "0.10.1",
-  "description": "Text to Speech (TTS) addon for qvac (ggml backend, wrapping the chatterbox + supertonic + parler + cosyvoice3 + audio8 + moss + Pocket engines from tts-cpp)",
+  "version": "0.11.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)",
   "addon": true,
   "engines": {
     "bare": ">=1.19.0"
@@ -53,8 +53,8 @@
   },
   "scripts": {
     "build": "npm run build:ts && npm run build:native",
-    "build:native": "bare-make generate && bare-make build && bare-make install",
-    "build:native:cuda": "bare-make generate -D ENABLE_CUDA=ON && bare-make build && bare-make install",
+    "build:native": "bare-make generate -D BUILD_FUZZING=OFF && bare-make build && bare-make install",
+    "build:native:cuda": "bare-make generate -D ENABLE_CUDA=ON -D BUILD_FUZZING=OFF && bare-make build && bare-make install",
     "build:cuda": "npm run build:ts && npm run build:native:cuda",
     "build:ts": "tsc -p tsconfig.build.json",
     "build:pack": "npm run build:ts && mkdir -p dist && npm pack --pack-destination dist",
@@ -80,8 +80,10 @@
     "example:parler-enhanced": "bare examples/parler-enhanced.js \"Hello from enhanced Parler.\"",
     "example:audio8": "bare examples/audio8-tts.js \"Audio eight speaks on-device.\"",
     "example:moss": "bare examples/moss-tts.js \"MOSS speaks on-device.\"",
+    "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/__tests__/package-contract.test.js\" \"scripts/__tests__/binding-loader.test.js\" \"binding.js\" \"addon-unavailable.js\" && lunte \"test/**/*.js\" \"scripts/__tests__/package-contract.test.js\" \"scripts/__tests__/binding-loader.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__/binding-loader.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__/binding-loader.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\" \"scripts/__tests__/binding-loader.test.js\" \"binding.js\" \"addon-unavailable.js\"",
@@ -95,10 +97,22 @@
     "test:benchmark:streaming": "npm run build:ts && brittle-bare test/benchmark/streaming-benchmark.test.js",
     "test:mobile:generate": "node scripts/generate-mobile-integration-tests.js",
     "test:mobile:validate": "node scripts/validate-mobile-tests.js",
-    "test:cpp:build": "bare-make generate -D BUILD_TESTING=ON && bare-make build --target tts_ggml_tests && bare-make install",
+    "test:cpp:build": "bare-make generate -D BUILD_TESTING=ON -D BUILD_FUZZING=OFF && bare-make build --target tts_ggml_tests && bare-make install",
     "test:cpp:run": "cd build && LLVM_PROFILE_FILE=default.profraw ./tts_ggml_tests --gtest_output=xml:cpp-test-results.xml",
     "test:cpp": "npm run test:cpp:build && npm run test:cpp:run",
-    "coverage:cpp:build": "bare-make generate -D BUILD_TESTING=ON -D ENABLE_COVERAGE=ON && bare-make build --target tts_ggml_tests",
+    "fuzz:build": "bare-make generate -D BUILD_FUZZING=ON -D BUILD_TESTING=OFF -D FUZZTEST_FUZZING_MODE=OFF && bare-make build --target tts-config-parse-fuzz",
+    "fuzz:build:continuous": "bare-make generate -D BUILD_FUZZING=ON -D BUILD_TESTING=OFF -D FUZZTEST_FUZZING_MODE=ON && bare-make build --target tts-config-parse-fuzz",
+    "fuzz:run": "node scripts/run-cpp-fuzz.js",
+    "fuzz": "npm run fuzz:build && npm run fuzz:run",
+    "fuzz:continuous": "npm run fuzz:build:continuous && node scripts/run-cpp-fuzz.js --continuous",
+    "test:cpp:fuzz:configure": "bare-make generate -D BUILD_TESTING=ON -D BUILD_FUZZING=ON -D FUZZTEST_FUZZING_MODE=OFF",
+    "test:cpp:fuzz:build:tests": "bare-make build --target tts_ggml_tests",
+    "test:cpp:fuzz:build:fuzz": "bare-make build --target tts-config-parse-fuzz",
+    "test:cpp:fuzz:build": "npm run test:cpp:fuzz:configure && npm run test:cpp:fuzz:build:tests && npm run test:cpp:fuzz:build:fuzz",
+    "test:cpp:fuzz:run": "npm run test:scripts && npm run test:cpp:run && node scripts/run-cpp-fuzz.js",
+    "test:cpp:fuzz": "npm run test:cpp:fuzz:build && npm run test:cpp:fuzz:run",
+    "test:scripts": "node --test scripts/__tests__/run-cpp-fuzz.test.js",
+    "coverage:cpp:build": "bare-make generate -D BUILD_TESTING=ON -D ENABLE_COVERAGE=ON -D BUILD_FUZZING=OFF && bare-make build --target tts_ggml_tests",
     "coverage:cpp:summary": "cd build && llvm-cov report ./tts_ggml_tests --instr-profile=coverage.profdata -ignore-filename-regex='(tests|build|node_modules|gtest|gmock|\\.vcpkg|/usr)/' > coverage-summary.txt",
     "coverage:cpp:report": "cd build && ls -lha && llvm-profdata merge -sparse default.profraw -o coverage.profdata && llvm-cov show ./tts_ggml_tests -instr-profile=coverage.profdata -format=html -output-dir=coverage-html -ignore-filename-regex='(tests|build|node_modules|gtest|gmock|\\.vcpkg|/usr)/' && llvm-cov export ./tts_ggml_tests -instr-profile=coverage.profdata -format=lcov -ignore-filename-regex='(tests|build|node_modules|gtest|gmock|\\.vcpkg|/usr)/' > lcov.info && npm run coverage:cpp:summary",
     "coverage:cpp": "npm run coverage:cpp:build && npm run test:cpp:run && npm run coverage:cpp:report",
@@ -127,6 +141,7 @@
     "scripts/download-tts-ggml-models.js",
     "test/integration",
     "test/mobile",
+    "test/pocket-worklet",
     "test/reference-audio",
     "test/utils/runTTS.js",
     "test/utils/runChatterboxTTS.js",
@@ -197,7 +212,9 @@
     "cmake-npm": "^1.1.0",
     "bare-url": "^2.1.6",
     "bare-https": "^3.0.0",
-    "bare-stream": "^2.7.0"
+    "bare-stream": "^2.7.0",
+    "bare-subprocess": "^6.2.1",
+    "brittle": "^3.17.0"
   },
   "dependencies": {
     "@qvac/error": "^0.1.0",
@@ -210,16 +227,14 @@
     "bare-path": "^3.0.0",
     "bare-process": "^4.2.2",
     "bare-stream": "^2.7.0",
-    "bare-subprocess": "^5.2.1",
-    "bare-url": "^2.4.3",
-    "brittle": "^3.17.0"
+    "bare-url": "^2.4.3"
   },
   "types": "index.d.ts",
   "optionalDependencies": {
-    "@qvac/tts-ggml-linux-x64": "0.10.1",
-    "@qvac/tts-ggml-linux-arm64": "0.10.1",
-    "@qvac/tts-ggml-darwin-arm64": "0.10.1",
-    "@qvac/tts-ggml-darwin-x64": "0.10.1",
-    "@qvac/tts-ggml-win32-x64": "0.10.1"
+    "@qvac/tts-ggml-linux-x64": "0.11.0",
+    "@qvac/tts-ggml-linux-arm64": "0.11.0",
+    "@qvac/tts-ggml-darwin-arm64": "0.11.0",
+    "@qvac/tts-ggml-darwin-x64": "0.11.0",
+    "@qvac/tts-ggml-win32-x64": "0.11.0"
   }
 }

package/test/integration/fit.test.js

@@ -141,14 +141,18 @@ test('a LavaSR stage is sized beside the projection', { timeout: TEST_TIMEOUT_MS
   t.ok(fit.lavasrFileBytes < fit.deviceBytes, 'reported beside the projection')
 })
 
-test('a voice with no fitter is an outcome, not a throw', (t) => {
+test('MOSS routes to its fitter when a model cannot be read', (t) => {
   const fit = TTSGgml.assessFit({
     engineType: 'moss',
-    mossBackbonePath: '/models/moss-tts-delay.gguf'
+    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, 'unsupported-engine')
+  t.is(fit.reason, 'model-unreadable')
   t.is(fit.modelVariant, 'moss')
 })
 

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

@@ -0,0 +1,57 @@
+'use strict'
+
+const path = require('bare-path')
+const process = require('bare-process')
+const test = require('brittle')
+const TTSGgml = require('@qvac/tts-ggml')
+
+test('MOSS fit requires explicit, representable workload counts', (t) => {
+  const request = {
+    engineType: 'moss',
+    mossBackbonePath: '/models/moss-tts-delay.gguf',
+    mossCodecDecoderPath: '/models/moss-codec-decoder.gguf',
+    promptRows: 128,
+    referenceSamples: 0,
+    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 }))
+  }
+  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 }))
+})
+
+test('MOSS metadata-only fit covers batch, streaming and cloning', (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')
+    return
+  }
+  const request = {
+    engineType: 'moss',
+    mossBackbonePath: path.join(modelDir, 'moss-tts-delay-f16.gguf'),
+    mossCodecDecoderPath: path.join(modelDir, 'moss-codec-decoder-f16.gguf'),
+    promptRows: 128,
+    referenceSamples: 0,
+    streaming: false
+  }
+  const batch = 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 })
+  t.not(stream.status, 'error', stream.report)
+  const cloning = 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)
+})

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

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

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

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

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

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

package/test/mobile/integration.auto.cjs

@@ -50,6 +50,14 @@ async function runLavasrEnhancerTest (options = {}) { // eslint-disable-line no-
   return runIntegrationModule('../integration/lavasr-enhancer.test.js', options)
 }
 
+async function runMossSfxTest (options = {}) { // eslint-disable-line no-unused-vars
+  return runIntegrationModule('../integration/moss-sfx.test.js', options)
+}
+
+async function runMossSpeechTest (options = {}) { // eslint-disable-line no-unused-vars
+  return runIntegrationModule('../integration/moss-speech.test.js', options)
+}
+
 async function runMossTest (options = {}) { // eslint-disable-line no-unused-vars
   return runIntegrationModule('../integration/moss.test.js', options)
 }
@@ -70,6 +78,10 @@ async function runParlerTest (options = {}) { // eslint-disable-line no-unused-v
   return runIntegrationModule('../integration/parler.test.js', options)
 }
 
+async function runPocketIntegrationTest (options = {}) { // eslint-disable-line no-unused-vars
+  return runIntegrationModule('../integration/pocket.integration.test.js', options)
+}
+
 async function runRtfBenchmarkTest (options = {}) { // eslint-disable-line no-unused-vars
   return runIntegrationModule('../integration/rtf-benchmark.test.js', options)
 }
@@ -106,11 +118,14 @@ module.exports = {
   runFitTest,
   runGpuSmokeTest,
   runLavasrEnhancerTest,
+  runMossSfxTest,
+  runMossSpeechTest,
   runMossTest,
   runMultipleRunsTest,
   runOutputSampleRateTest,
   runParlerWerTest,
   runParlerTest,
+  runPocketIntegrationTest,
   runRtfBenchmarkTest,
   runStreamingBenchmarkTest,
   runSupertonicMtlTest,

package/tts.d.ts

@@ -17,6 +17,26 @@ export interface TTSJobData {
     instruct?: string;
     referenceAudio?: string;
     referenceText?: string;
+    seconds?: number;
+    negativePrompt?: string;
+    steps?: number;
+    guidance?: number;
+    shift?: number;
+    messages?: Array<{
+        role: string;
+        text?: string;
+        audio?: Int16Array | Float32Array;
+        sampleRate?: number;
+    }>;
+    replyVoice?: Int16Array | Float32Array;
+    replyVoiceSampleRate?: number;
+    textReply?: boolean;
+    maxReplySeconds?: number;
+    maxNewTokens?: number;
+    greedy?: boolean;
+    temperature?: number;
+    topP?: number;
+    topK?: number;
 }
 export interface TTSWeightData {
     filename: string;