@memef1f1y/dsh-plugin-tts 0.6.0

package/tests/e2e-real-rvc.mjs

@@ -0,0 +1,122 @@
+// One-off real end-to-end: plugin Host -> real rvc-server (azusa-test) chain.
+//
+// [DEPRECATED in favor of tests/rvc-server-live.mjs] This one-off test hardcodes
+// Windows paths (E:/AI/.../azusa-test.pth) and is not portable. The standard,
+// environment-aware live scenario + boundary suite is `tests/rvc-server-live.mjs`
+// (npm run test:live). This file is kept for Windows reference only.
+
+// Verifies Edge base synth + real RVC conversion + audio route serving.
+import * as plugin from '../lib/index.mjs';
+
+const routes = [];
+const ctx = {
+  get(name) {
+    if (name === 'webServer') {
+      return {
+        register(route) {
+          routes.push(route);
+          return () => {
+            const i = routes.indexOf(route);
+            if (i >= 0) routes.splice(i, 1);
+          };
+        }
+      };
+    }
+    return undefined;
+  },
+  effect() {}
+};
+plugin.apply(ctx);
+
+const speakRoute = routes.find((r) => r.kind === 'exact' && r.path === '/dsh-tts-api/speak');
+const audioRoute = routes.find((r) => r.kind === 'prefix' && r.path === '/dsh-tts-audio');
+
+function mockReq(url, body) {
+  const chunks = body === undefined ? [] : [body];
+  return {
+    url,
+    [Symbol.asyncIterator]() {
+      let i = 0;
+      return {
+        next: () => (i < chunks.length ? Promise.resolve({ value: chunks[i++], done: false }) : Promise.resolve({ done: true }))
+      };
+    }
+  };
+}
+function mockRes() {
+  return { headersSent: false, head: null, body: null, writeHead(c, h) { this.head = { c, h }; }, end(b) { this.body = b; } };
+}
+
+const RVC_DIR = 'E:/AI/RVC20240604Nvidia/RVC20240604Nvidia';
+const custom = {
+  baseUrl: 'http://127.0.0.1:4892',
+  model: `${RVC_DIR}/assets/weights/azusa-test.pth`,
+  index: `${RVC_DIR}/assets/indices/azusa-test_IVF3317_Flat_nprobe_1_azusa-test_v2.index`,
+  baseVoice: 'zh-CN-YunyangNeural',
+  f0Method: 'rmvpe',
+  indexRate: 0.75
+};
+
+const t0 = Date.now();
+const res = mockRes();
+try {
+  await speakRoute.handler(
+    mockReq('/dsh-tts-api/speak', JSON.stringify({ text: '这是通过插件链路转换出的 azusa 音色，用来验证端到端流程。', provider: 'rvc', custom })),
+    res
+  );
+} catch (e) {
+  console.error('speak handler threw:', e);
+  process.exit(1);
+}
+console.log('res.head:', JSON.stringify(res.head));
+console.log('res.body type:', typeof res.body, res.body === null ? 'null' : String(res.body).slice(0, 200));
+if (!res.body) process.exit(1);
+const parsed = JSON.parse(res.body);
+console.log(`speak -> ${res.head.c} ${parsed.url ?? parsed.error}  (${((Date.now() - t0) / 1000).toFixed(1)}s)`);
+if (!parsed.url) process.exit(1);
+
+const ares = mockRes();
+await audioRoute.handler(mockReq(parsed.url), ares);
+const bytes = Buffer.isBuffer(ares.body) ? ares.body : Buffer.from(ares.body ?? '');
+console.log(`audio -> ${ares.head.c} ${bytes.length} bytes, head=${bytes.slice(0, 4).toString()}`);
+if (!(bytes.length > 1000 && bytes.slice(0, 4).toString() === 'RIFF')) process.exit(1);
+
+// ---- adaptive chunked progressive playback (long text) ----
+const nextRoute = routes.find((r) => r.kind === 'exact' && r.path === '/dsh-tts-api/rvc-next');
+if (!nextRoute) {
+  console.error('rvc-next route missing');
+  process.exit(1);
+}
+const longText = '这是一段用来验证自适应分块渐进播放的长文本，每一块都会先由 Edge 合成，再交给本地 RVC 服务转换，播放的同时后台继续合成后面的段落，从而做到长文朗读不卡顿。'.repeat(3);
+const t1 = Date.now();
+const longRes = mockRes();
+await speakRoute.handler(
+  mockReq('/dsh-tts-api/speak', JSON.stringify({ text: longText, provider: 'rvc', custom })),
+  longRes
+);
+const longParsed = JSON.parse(longRes.body);
+console.log(`long speak -> ${longRes.head.c} jobId=${longParsed.jobId ?? ''} chunks=${longParsed.chunks?.length ?? 0} total=${longParsed.total ?? 0} ratio=${longParsed.ratio ?? 'n/a'} chunkSec=${longParsed.chunkSec ?? 'n/a'} (${((Date.now() - t1) / 1000).toFixed(1)}s)`);
+if (!longParsed.jobId || !Array.isArray(longParsed.chunks) || longParsed.chunks.length < 2) process.exit(1);
+let fetched = longParsed.chunks.length;
+let more = true;
+const chunkStarts = [];
+while (more) {
+  const nr = mockRes();
+  await nextRoute.handler(mockReq(`/dsh-tts-api/rvc-next?job=${longParsed.jobId}`), nr);
+  const np = JSON.parse(nr.body);
+  if (np && np.url) {
+    fetched++;
+    chunkStarts.push(np.url);
+  }
+  more = !!(np && np.more);
+}
+console.log(`rvc-next drained: fetched=${fetched} total=${longParsed.total} (${((Date.now() - t1) / 1000).toFixed(1)}s)`);
+if (fetched !== longParsed.total) process.exit(1);
+// verify one late chunk serves wav
+const lastRes = mockRes();
+await audioRoute.handler(mockReq(chunkStarts[chunkStarts.length - 1]), lastRes);
+const lastBytes = Buffer.isBuffer(lastRes.body) ? lastRes.body : Buffer.from(lastRes.body ?? '');
+console.log(`late chunk audio -> ${lastRes.head.c} ${lastBytes.length} bytes, head=${lastBytes.slice(0, 4).toString()}`);
+if (!(lastBytes.length > 1000 && lastBytes.slice(0, 4).toString() === 'RIFF')) process.exit(1);
+
+process.exit(0);

package/tests/i18n-keys.mjs

@@ -0,0 +1,82 @@
+// i18n regression: every t("key") used in lib/client.js must exist in both zh
+// and en dictionaries; both dictionaries must be identical in key sets; and
+// no CJK UI literal may remain outside the dictionary.
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import path from 'node:path';
+
+const client = readFileSync(path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', 'lib', 'client.js'), 'utf8');
+const results = [];
+function check(name, ok, detail) { results.push({ name, ok, detail }); console.log(`${ok ? 'PASS' : 'FAIL'}  ${name}${detail ? ' — ' + detail : ''}`); }
+
+function extractDict(lang) {
+  const lineMarker = `          ${lang}: {`;
+  const start = client.indexOf(lineMarker);
+  if (start < 0) throw new Error('no dict.' + lang);
+  const bodyStart = client.indexOf('{', start);
+  let i = bodyStart, depth = 0;
+  for (; i < client.length; i++) {
+    if (client[i] === '{') depth++;
+    else if (client[i] === '}') { depth--; if (depth === 0) break; }
+  }
+  const block = client.slice(bodyStart, i + 1);
+  const re = /"([^"]+)":\s*"((?:[^"\\]|\\.)*)"/g;
+  const out = {};
+  let m;
+  while ((m = re.exec(block))) out[m[1]] = m[2];
+  return out;
+}
+let zh, en, zhKeys, enKeys;
+try {
+  zh = extractDict('zh'); en = extractDict('en');
+  zhKeys = new Set(Object.keys(zh)); enKeys = new Set(Object.keys(en));
+  check('i18n dictionaries exist & non-empty', zhKeys.size > 0 && enKeys.size > 0, `zh=${zhKeys.size} en=${enKeys.size}`);
+  const missingEn = [...zhKeys].filter(k => !enKeys.has(k));
+  const missingZh = [...enKeys].filter(k => !zhKeys.has(k));
+  check('zh and en have identical key sets', missingEn.length === 0 && missingZh.length === 0,
+    missingEn.length ? 'en missing: ' + missingEn.join(',') : (missingZh.length ? 'zh missing: ' + missingZh.join(',') : undefined));
+} catch (e) {
+  check('i18n dictionaries parse', false, String(e.message));
+  zhKeys = new Set(); enKeys = new Set();
+}
+
+// every real t("key") usage (word-boundary t call) must be defined in both
+const used = new Set();
+const tRe = /(^|[^A-Za-z0-9_$.])t\(\s*"([^"]+)"\s*(?:\)|,)/g;
+let mm;
+while ((mm = tRe.exec(client))) used.add(mm[2]);
+const missingDef = [...used].filter(k => !zhKeys.has(k) || !enKeys.has(k));
+check('all t("key") usages have zh+en definitions', missingDef.length === 0, missingDef.length ? 'missing: ' + missingDef.join(',') : `${used.size} keys used`);
+
+// no CJK literal remains outside the dictionary (UI fully localized)
+const i18nEnd = client.lastIndexOf('// ------------------------------------------------------------ /i18n');
+const render = client.slice(i18nEnd + 1);
+const cjkRe = /"[^"\n]*[\u4e00-\u9fff][^"\n]*"/g;
+const cjk = [];
+let c;
+while ((c = cjkRe.exec(render))) {
+  const lineStart = render.lastIndexOf('\n', c.index) + 1;
+  const line = render.slice(lineStart, c.index);
+  if (!line.trim().startsWith('//')) cjk.push(c[0]);
+}
+check('no CJK UI literal left outside dictionary', cjk.length === 0, cjk.length ? cjk.slice(0, 10).join(' | ') : undefined);
+
+// dictionary has no dead keys (excluding voice.*/baseVoice.* data labels and lang labels used only in the switcher)
+// host.* keys are resolved DYNAMICALLY (hostErrText(t(i18n.code)) and
+// t("host.phase." + phaseKey)) so they won't appear as literal t("host.x")
+// calls; they are part of the host<->client i18n contract. Exclude them here.
+// cloud.usage.* tier keys are likewise dynamic (t("cloud.usage." + tier)).
+const dead = [...zhKeys].filter(k =>
+  used.has(k) ? false
+  : /^voice\.|^baseVoice\.|^host\.|^cloud\.usage\.(standard|wavenet|neural2|chirp3)$/.test(k) ? false
+  : true);
+check('dictionary has no dead keys (excluding voice/baseVoice/host data)', dead.length === 0, dead.length ? 'dead: ' + dead.join(',') : undefined);
+// host.* keys form a complete bi-dictionary set (already covered by the
+// identical-key-sets check); also ensure the handful the client references
+// statically are present.
+const hostStatic = ["host.phase.model", "host.phase.index", "host.phase.prepare"];
+check('host.* phase keys present in both langs', hostStatic.every(k => zhKeys.has(k) && enKeys.has(k)));
+
+const failed = results.filter(r => !r.ok);
+console.log(`\n${results.length - failed.length}/${results.length} i18n checks passed`);
+process.exit(failed.length === 0 ? 0 : 1);

package/tests/mock-registry.mjs

@@ -0,0 +1,50 @@
+// Mock voice-pack registry — a tiny static file server for local dev/testing.
+// Serves whatever is in <dir> (manifest.json + pack files), so you can build a
+// local voice-pack repo and point the plugin's 音色包 registry URL at it.
+//   node tests/mock-registry.mjs <dir> [port]
+// Also exports startMockRegistry(dir, port=0, delayMs=0) for use from tests.
+import { createServer } from 'node:http';
+import { readFileSync, existsSync } from 'node:fs';
+import path from 'node:path';
+
+export function startMockRegistry(dir, port = 0, delayMs = 0) {
+  const root = path.resolve(dir);
+  const server = createServer((req, res) => {
+    const url = new URL(req.url, 'http://x');
+    let rel = decodeURIComponent(url.pathname).replace(/^\/+/, '');
+    if (!rel) rel = 'manifest.json';
+    const file = path.join(root, rel);
+    if (!file.startsWith(root) || !existsSync(file)) {
+      res.writeHead(404, { 'Content-Type': 'text/plain' });
+      res.end('not found');
+      return;
+    }
+    const bytes = readFileSync(file);
+    const type = file.endsWith('.json')
+      ? 'application/json; charset=utf-8'
+      : 'application/octet-stream';
+    const send = () => {
+      res.writeHead(200, {
+        'Content-Type': type,
+        'Content-Length': bytes.length,
+        'Access-Control-Allow-Origin': '*'
+      });
+      res.end(bytes);
+    };
+    if (delayMs > 0) setTimeout(send, delayMs);
+    else send();
+  });
+  return new Promise(resolve => {
+    server.listen(port, '127.0.0.1', () =>
+      resolve({ server, port: server.address().port, base: `http://127.0.0.1:${server.address().port}` }),
+    );
+  });
+}
+
+// CLI: serve a directory so you can test the plugin UI against a local repo.
+if (process.argv[1] && process.argv[1].endsWith('mock-registry.mjs')) {
+  const dir = process.argv[2] || process.cwd();
+  const port = Number(process.argv[3] || 8899);
+  const { base } = await startMockRegistry(dir, port);
+  console.log(`mock registry serving ${dir}\n  manifest: ${base}/manifest.json`);
+}

package/tests/package-runtime-patch.mjs

@@ -0,0 +1,88 @@
+// Boundary test for tools/package-runtime.py's macOS-only PyAV patch helper
+// (patch_infer_for_pyav): it must rewrite av.open("rb"/"wb") -> "r"/"w" in the
+// packaged infer/lib/audio.py on darwin, but leave a normal Python `open(
+// file, "rb")` (a real file open) untouched. Verified end-to-end too by
+//   node tests/rvc-server-live.mjs  (live /convert)
+// Run: node tests/package-runtime-patch.mjs
+import { execFileSync } from 'node:child_process';
+import { mkdtempSync, writeFileSync, readFileSync, rmSync, mkdirSync } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const results = [];
+function check(name, ok, detail) {
+  results.push({ name, ok, detail });
+  console.log(`${ok ? 'PASS' : 'FAIL'}  ${name}${detail ? ' — ' + detail : ''}`);
+}
+
+const repo = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const pkg = path.join(repo, 'tools', 'package-runtime.py');
+// Run the driver with python3 when available, else fall back to `python` and
+// then to the Windows `py -3` launcher. Windows installs often only ship
+// `python`, and a bare `python`/`python3` may be a dead Microsoft Store stub
+// that exits 9009, so the `py` launcher is the reliable last resort.
+function runPython(driverPath) {
+  const tries = [
+    ['python3', []],
+    ['python', []],
+    ['py', ['-3']]
+  ];
+  for (const [cmd, pre] of tries) {
+    try {
+      return execFileSync(cmd, [...pre, driverPath], { encoding: 'utf8' });
+    } catch (e) {
+      if (cmd === 'py') throw e; // give up after the last fallback
+    }
+  }
+}
+// sample = the unpatched (as-released) audio.py
+const sample = [
+  'import av',
+  'import numpy as np',
+  'def wav2(i, o, format):',
+  '    inp = av.open(i, "rb")',
+  '    out = av.open(o, "wb", format=format)',
+  '    return inp, out',
+  'def audio2(i, o, format, sr):',
+  '    inp = av.open(i, "rb")',
+  '    out = av.open(o, "wb", format=format)',
+  '    return inp, out',
+  'def load_audio(file, sr):',
+  '    with open(file, "rb") as f:',
+  '        pass',
+  ''
+].join('\n');
+
+const dir = mkdtempSync(path.join(os.tmpdir(), 'dsh-tts-pyav-'));
+try {
+  const libDir = path.join(dir, 'infer', 'lib');
+  mkdirSync(libDir, { recursive: true });
+  const audioPath = path.join(libDir, 'audio.py');
+  writeFileSync(audioPath, sample);
+
+  const driver = path.join(dir, 'driver.py');
+  writeFileSync(driver, `
+import importlib.util
+spec = importlib.util.spec_from_file_location("prt", ${JSON.stringify(pkg)})
+m = importlib.util.module_from_spec(spec)
+spec.loader.exec_module(m)
+m.patch_infer_for_pyav(${JSON.stringify(path.join(dir, 'infer'))})
+`);
+  runPython(driver);
+
+  const out = readFileSync(audioPath, 'utf8');
+  check('darwin patch replaces av.open rb/wb', !/av\.open\([^)]*"(rb|wb)"/.test(out), out.split('\n').filter(l => l.includes('av.open')).join(' | '));
+  check('darwin patch keeps Python open(file,"rb")', out.includes('with open(file, "rb") as f:'));
+  check('darwin patch converts to r/w', out.includes('av.open(i, "r")') && out.includes('av.open(o, "w", format=format)'));
+
+  // idempotency: running twice changes nothing
+  runPython(driver);
+  check('patch idempotent (second run unchanged)', readFileSync(audioPath, 'utf8') === out);
+} finally {
+  rmSync(dir, { recursive: true, force: true });
+}
+
+const failed = results.filter(r => !r.ok);
+console.log(`\n${results.length - failed.length}/${results.length} patch checks passed`);
+process.exit(failed.length === 0 ? 0 : 1);

package/tests/rvc-server-live.mjs

@@ -0,0 +1,230 @@
+// Standard live scenario + boundary suite for the local RVC inference server
+// (rvc-server.py). Unlike the Windows-hardcoded one-off e2e tests, this is
+// environment-aware:
+//   * uses RVC_URL (default http://127.0.0.1:4892) if a server is already up;
+//   * otherwise tries to spawn one from $RVC_WORK (default ~/rvc-work, the
+//     layout the macOS test builds), using venv/bin/python;
+//   * if neither is available it prints SKIP and exits 0 (safe in CI).
+//
+//   node tests/rvc-server-live.mjs
+//   RVC_URL=... node tests/rvc-server-live.mjs
+//
+// Covers: real end-to-end scenario (health/files/load/convert/compact-index)
+// plus protocol boundary cases (malformed payloads, missing model/index,
+// convert-before-load, empty/tiny/invalid base64, bad f0_method, bad
+// compact-index, unknown route, concurrency lock).
+import { spawn } from 'node:child_process';
+import os from 'node:os';
+import path from 'node:path';
+import { existsSync } from 'node:fs';
+
+const BASE = process.env.RVC_URL || 'http://127.0.0.1:4892';
+const WORK = process.env.RVC_WORK || path.join(os.homedir(), 'rvc-work');
+const MODEL = path.join(WORK, 'assets', 'weights', 'model.pth');
+const INDEX = path.join(WORK, 'assets', 'weights', 'guanguanV1.index');
+const PY = path.join(WORK, 'venv', 'bin', 'python');
+const SERVER = path.join(WORK, 'rvc-server.py');
+
+const results = [];
+const skipped = [];
+function check(name, ok, detail) {
+  results.push({ name, ok, detail });
+  console.log(`${ok ? 'PASS' : 'FAIL'}  ${name}${detail ? ' — ' + detail : ''}`);
+}
+function skip(name, reason) {
+  skipped.push(name);
+  console.log(`SKIP  ${name} — ${reason}`);
+}
+
+async function ping(url, timeoutMs = 3000) {
+  const ctrl = new AbortController();
+  const t = setTimeout(() => ctrl.abort(), timeoutMs);
+  try {
+    const r = await fetch(url + '/health', { signal: ctrl.signal });
+    clearTimeout(t);
+    return r.ok;
+  } catch { clearTimeout(t); return false; }
+}
+
+async function http(method, route, body, timeoutMs = 300000) {
+  const ctrl = new AbortController();
+  const t = setTimeout(() => ctrl.abort(), timeoutMs);
+  const opt = { method, signal: ctrl.signal, headers: {} };
+  if (body !== undefined) {
+    opt.headers['Content-Type'] = 'application/json';
+    opt.body = typeof body === 'string' ? body : JSON.stringify(body);
+  }
+  try {
+    const r = await fetch(BASE + route, opt);
+    clearTimeout(t);
+    const text = await r.text();
+    let data = null;
+    try { data = JSON.parse(text); } catch {}
+    return { status: r.status, data, text };
+  } catch (e) {
+    clearTimeout(t);
+    return { status: 0, data: null, text: String(e) };
+  }
+}
+
+// --- availability detection + optional spawn ---
+let serverProc = null;
+let live = await ping(BASE, 2000);
+if (!live && existsSync(PY) && existsSync(SERVER)) {
+  console.log(`[live] no server on ${BASE}; spawning from ${WORK}`);
+  serverProc = spawn(PY, [SERVER, '--port', new URL(BASE).port], { stdio: 'ignore' });
+  // wait up to ~20s for /health
+  for (let i = 0; i < 40; i++) {
+    await new Promise(r => setTimeout(r, 500));
+    if (await ping(BASE, 1000)) { live = true; break; }
+  }
+}
+if (!live) {
+  console.log('SKIP  live+rvc-server unavailable — start rvc-server.py or set RVC_URL/RVC_WORK');
+  process.exit(0);
+}
+console.log(`[live] using ${BASE}  (work=${existsSync(WORK) ? WORK : 'n/a'})`);
+
+try {
+  // ---------- SCENARIO: happy path ----------
+  {
+    const h = await http('GET', '/health');
+    // Accept either a CPU or a CUDA device: the health payload must be
+    // self-consistent (cuda_available matches the reported device), so this
+    // works both on CI (cpu) and on a Windows/macOS GPU regression host (cuda).
+    const dev = h.data && h.data.device;
+    const cuda = h.data && h.data.cuda_available;
+    const consistent = (dev === 'cpu' && cuda === false) || (typeof dev === 'string' && dev.startsWith('cuda') && cuda === true);
+    check('scenario /health ok + consistent device', h.status === 200 && h.data.ok === true && consistent,
+      `device=${dev} cuda=${cuda}`);
+
+    const f = await http('GET', '/files?kind=pth');
+    check('scenario /files lists pth', f.status === 200 && Array.isArray(f.data && f.data.files), f.text.slice(0, 120));
+
+    const modelExists = existsSync(MODEL);
+    const indexExists = existsSync(INDEX);
+    if (!(modelExists && indexExists)) {
+      skip('scenario /load + /convert + /compact-index', 'model/index not in ' + WORK);
+    } else {
+      const ld = await http('POST', '/load', { model: MODEL, index: INDEX });
+      check('scenario /load ok', ld.status === 200 && ld.data.ok === true, ld.text.slice(0, 100));
+
+      const wav = makeWav(1.0, 44100); // ~1s sawtooth speech-like
+      const cv = await http('POST', '/convert', {
+        audio_base64: wav.toString('base64'),
+        params: { f0_method: 'rmvpe', index_rate: 0.75 }
+      }, 600000);
+      const cvOk = cv.status === 200 && cv.data && typeof cv.data.audio_base64 === 'string'
+        && Number.isFinite(cv.data.sample_rate) && cv.data.sample_rate > 0;
+      check('scenario /convert returns wav', cvOk, `status=${cv.status} sr=${cv.data && cv.data.sample_rate}`);
+      if (cvOk) {
+        const out = Buffer.from(cv.data.audio_base64, 'base64');
+        check('scenario /convert output is RIFF wav', out.slice(0, 4).toString() === 'RIFF' && out.length > 44,
+          `${out.length} bytes`);
+      }
+
+      const ci = await http('POST', '/compact-index', { index: INDEX, target_vectors: 500 }, 600000);
+      check('scenario /compact-index ok', ci.status === 200 && ci.data.ok === true
+        && typeof ci.data.reduction_pct === 'number', ci.text.slice(0, 120));
+    }
+  }
+
+  // ---------- BOUNDARY: protocol edges ----------
+  {
+    // load with missing model path
+    const r1 = await http('POST', '/load', { model: path.join(WORK, 'nope.pth') }, 30000);
+    check('boundary /load missing model -> 4xx', r1.status >= 400 && r1.status < 500, `status=${r1.status} ${r1.text.slice(0, 80)}`);
+
+    // load with missing index path (model valid)
+    if (existsSync(MODEL)) {
+      const r2 = await http('POST', '/load', { model: MODEL, index: path.join(WORK, 'nope.index') }, 60000);
+      check('boundary /load missing index -> 4xx', r2.status >= 400 && r2.status < 500, `status=${r2.status} ${r2.text.slice(0, 80)}`);
+    }
+
+    // malformed JSON body
+    const r3 = await http('POST', '/load', '{not json', 30000);
+    check('boundary /load malformed json -> 4xx', r3.status >= 400, `status=${r3.status} ${r3.text.slice(0, 80)}`);
+
+    // convert before load (if we could not load, this still applies when nothing loaded)
+    const r4 = await http('POST', '/convert', { audio_base64: makeWav(0.2, 44100).toString('base64'), params: {} }, 30000);
+    // 200 if a model happens to be loaded from the happy path, else 4xx — either is acceptable,
+    // but a 500 crash is not.
+    check('boundary /convert never 5xx-crashes pre/post load', r4.status !== 500, `status=${r4.status} ${r4.text.slice(0, 80)}`);
+
+    // convert with empty audio_base64
+    const r5 = await http('POST', '/convert', { audio_base64: '', params: {} }, 30000);
+    check('boundary /convert empty base64 -> 4xx (not 500)', r5.status !== 500 && r5.status !== 0, `status=${r5.status}`);
+
+    // convert with invalid base64
+    const r6 = await http('POST', '/convert', { audio_base64: '!!!not-base64!!!', params: {} }, 30000);
+    check('boundary /convert bad base64 -> 4xx (not 500)', r6.status !== 500 && r6.status !== 0, `status=${r6.status}`);
+
+    // convert with a zero-length (empty) wav
+    const empty = Buffer.alloc(44); // 44-byte header, no data
+    empty.write('RIFF', 0); empty.write('WAVE', 8); empty.write('fmt ', 12);
+    const r7 = await http('POST', '/convert', { audio_base64: empty.toString('base64'), params: {} }, 30000);
+    check('boundary /convert empty wav -> 4xx (not 500)', r7.status !== 500 && r7.status !== 0, `status=${r7.status} ${r7.text.slice(0, 80)}`);
+
+    // convert with a valid wav but unknown f0_method (should not crash)
+    const r8 = await http('POST', '/convert', { audio_base64: makeWav(0.3, 44100).toString('base64'), params: { f0_method: 'does-not-exist' } }, 60000);
+    check('boundary /convert unknown f0_method -> 4xx (not 500)', r8.status !== 500, `status=${r8.status} ${r8.text.slice(0, 80)}`);
+
+    // compact-index with missing index
+    const r9 = await http('POST', '/compact-index', { index: path.join(WORK, 'nope.index') }, 30000);
+    check('boundary /compact-index missing index -> 4xx', r9.status >= 400 && r9.status < 500, `status=${r9.status} ${r9.text.slice(0, 80)}`);
+
+    // compact-index with empty index
+    const r10 = await http('POST', '/compact-index', { index: '' }, 30000);
+    check('boundary /compact-index empty index -> 4xx', r10.status >= 400, `status=${r10.status} ${r10.text.slice(0, 80)}`);
+
+    // unknown route -> 404
+    const r11 = await http('GET', '/does-not-exist');
+    check('boundary unknown route -> 404', r11.status === 404, `status=${r11.status}`);
+  }
+
+  // ---------- CONCURRENCY: parallel converts must not crash ----------
+  if (existsSync(MODEL)) {
+    await http('POST', '/load', { model: MODEL, index: existsSync(INDEX) ? INDEX : '' }, 60000);
+    const wav = makeWav(0.5, 44100).toString('base64');
+    const out = await Promise.allSettled([
+      http('POST', '/convert', { audio_base64: wav, params: { f0_method: 'rmvpe' } }, 600000),
+      http('POST', '/convert', { audio_base64: wav, params: { f0_method: 'rmvpe' } }, 600000),
+      http('POST', '/convert', { audio_base64: wav, params: { f0_method: 'pm' } }, 600000),
+    ]);
+    const statuses = out.map(x => x.status === 'fulfilled' ? x.value.status : -1);
+    const anyOk = statuses.some(s => s === 200);
+    const no5xx = statuses.every(s => s !== 500 && s !== -1);
+    check('boundary 3 concurrent converts no 5xx + at least one ok', anyOk && no5xx, `statuses=${statuses.join(',')}`);
+  }
+} finally {
+  if (serverProc) serverProc.kill();
+}
+
+const failed = results.filter(r => !r.ok);
+console.log(`\n${results.length - failed.length}/${results.length} live checks passed${skipped.length ? `, ${skipped.length} skipped` : ''}`);
+process.exit(failed.length === 0 ? 0 : 1);
+
+// --- helper: tiny valid WAV ---
+function makeWav(seconds, sr) {
+  const n = Math.floor(sr * seconds);
+  const dataSize = n * 2;
+  const buf = Buffer.alloc(44 + dataSize);
+  buf.write('RIFF', 0);
+  buf.writeUInt32LE(36 + dataSize, 4);
+  buf.write('WAVE', 8);
+  buf.write('fmt ', 12);
+  buf.writeUInt32LE(16, 16);
+  buf.writeUInt16LE(1, 20);
+  buf.writeUInt16LE(1, 22);
+  buf.writeUInt32LE(sr, 24);
+  buf.writeUInt32LE(sr * 2, 28);
+  buf.writeUInt16LE(2, 32);
+  buf.writeUInt16LE(16, 34);
+  buf.write('data', 36);
+  buf.writeUInt32LE(dataSize, 40);
+  for (let i = 0; i < n; i++) {
+    const v = Math.round(12000 * Math.sin(2 * Math.PI * 220 * i / sr));
+    buf.writeInt16LE(v, 44 + i * 2);
+  }
+  return buf;
+}