feat: demucs 6-stem separation

Radix-2 FFT and torch-compatible stft/istft (hann, center, reflect,
normalized). HTDemucs-6s ONNX separator mirroring demucs apply_model:
whole-mix normalisation, 343980-sample centred segments, 25% overlap
with triangular weights, _spec/_ispec around the graph, spectral +
time branch sum. Brief's guitar/bass > 3 dB criterion is unmet by the
model on t1b/1 and is kept as test.failing pending a ruling.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

tests/dsp/fft.test.ts

@@ -0,0 +1,52 @@
+import { test, expect } from "bun:test";
+import { fft, stft, istft } from "../../src/dsp/fft.ts";
+import { createRng } from "../../src/core/rng.ts";
+
+test("fft of an impulse has all-ones magnitude", () => {
+  const n = 1024;
+  const re = new Float32Array(n);
+  const im = new Float32Array(n);
+  re[0] = 1;
+  fft(re, im);
+  for (let k = 0; k < n; k++) expect(Math.hypot(re[k]!, im[k]!)).toBeCloseTo(1, 6);
+});
+
+test("fft matches a direct DFT on a random signal", () => {
+  const n = 64;
+  const rng = createRng(3);
+  const x = Array.from({ length: n }, () => rng.next() * 2 - 1);
+  const re = Float32Array.from(x);
+  const im = new Float32Array(n);
+  fft(re, im);
+  for (let k = 0; k < n; k++) {
+    let sr = 0, si = 0;
+    for (let t = 0; t < n; t++) {
+      sr += x[t]! * Math.cos((-2 * Math.PI * k * t) / n);
+      si += x[t]! * Math.sin((-2 * Math.PI * k * t) / n);
+    }
+    expect(re[k]!).toBeCloseTo(sr, 4);
+    expect(im[k]!).toBeCloseTo(si, 4);
+  }
+});
+
+test("stft follows torch semantics: frame count, bins, normalized=True scaling", () => {
+  const nFft = 4096, hop = 1024, len = 50_000;
+  const x = new Float32Array(len).fill(1); // DC: bin 0 of an interior frame = sum(hann)/sqrt(nFft) = nFft/2/sqrt(nFft)
+  const s = stft(x, nFft, hop);
+  expect(s.re.length).toBe(1 + Math.floor(len / hop));
+  expect(s.re[0]!.length).toBe(nFft / 2 + 1);
+  expect(s.re[10]![0]!).toBeCloseTo(nFft / 2 / Math.sqrt(nFft), 3);
+  expect(Math.abs(s.re[10]![1]!)).toBeCloseTo(nFft / 4 / Math.sqrt(nFft), 3);
+});
+
+test("istft(stft(x)) reconstructs x (max err < 1e-4)", () => {
+  const nFft = 4096, hop = 1024, len = 50_000;
+  const rng = createRng(7);
+  const x = new Float32Array(len);
+  for (let i = 0; i < len; i++) x[i] = rng.next() * 2 - 1;
+  const y = istft(stft(x, nFft, hop), nFft, hop, len);
+  expect(y.length).toBe(len);
+  let maxErr = 0;
+  for (let i = 0; i < len; i++) maxErr = Math.max(maxErr, Math.abs(y[i]! - x[i]!));
+  expect(maxErr).toBeLessThan(1e-4);
+});

tests/pipeline/separate.test.ts

@@ -0,0 +1,117 @@
+import { test, expect, beforeAll } from "bun:test";
+import { join } from "node:path";
+import { buildSong, loadSongDir } from "../../src/bench/dataset.ts";
+import { createSeparator, STEMS, type Stem } from "../../src/pipeline/separate.ts";
+import type { Audio } from "../../src/core/types.ts";
+
+const MODEL = join(import.meta.dir, "../../models/demucs/htdemucs_6s.onnx");
+const SLOW = 300_000;
+
+let separate: (mix: Audio) => Promise<Record<Stem, Audio>>;
+let data: Awaited<ReturnType<typeof loadSongDir>>;
+
+beforeAll(async () => {
+  const dir = await buildSong("t1b", 1);
+  data = await loadSongDir(dir);
+  separate = await createSeparator(new Uint8Array(await Bun.file(MODEL).arrayBuffer()), { intraOpNumThreads: 8 });
+}, SLOW);
+
+/** Sum of oracle stems for every track of the given role. */
+function oracle(role: string): Audio {
+  const len = data.mix.channels[0]!.length;
+  const ch = [new Float32Array(len), new Float32Array(len)];
+  for (const t of data.song.tracks) {
+    if (t.role !== role) continue;
+    const s = data.stems.get(t.name)!;
+    for (let c = 0; c < 2; c++) for (let i = 0; i < len; i++) ch[c]![i]! += s.channels[c]![i]!;
+  }
+  return { sampleRate: data.mix.sampleRate, channels: ch };
+}
+
+/** SDR in dB over all channels: 10 log10(|ref|^2 / |ref - est|^2). */
+function sdr(ref: Audio, est: Audio): number {
+  let num = 0, den = 0;
+  for (let c = 0; c < ref.channels.length; c++) {
+    const r = ref.channels[c]!, e = est.channels[c]!;
+    for (let i = 0; i < r.length; i++) {
+      num += r[i]! * r[i]!;
+      den += (r[i]! - e[i]!) ** 2;
+    }
+  }
+  return 10 * Math.log10(num / Math.max(den, 1e-20));
+}
+
+let out: Record<Stem, Audio>;
+let secsPerMin = 0;
+const sdrs: Record<string, number> = {};
+
+function sum(...as: Audio[]): Audio {
+  const len = as[0]!.channels[0]!.length;
+  return { sampleRate: 44100, channels: [0, 1].map((c) => {
+    const o = new Float32Array(len);
+    for (const a of as) for (let i = 0; i < len; i++) o[i]! += a.channels[c]![i]!;
+    return o;
+  }) };
+}
+
+beforeAll(async () => {
+  const t0 = performance.now();
+  out = await separate(data.mix);
+  const minutes = data.mix.channels[0]!.length / data.mix.sampleRate / 60;
+  secsPerMin = (performance.now() - t0) / 1000 / minutes;
+  for (const [stem, role] of [["guitar", "guitar"], ["bass", "bass"], ["drums", "drums"]] as const) {
+    sdrs[stem] = sdr(oracle(role), out[stem]);
+    sdrs[`${stem}_mixBaseline`] = sdr(oracle(role), data.mix);
+  }
+  sdrs.guitarPlusPiano = sdr(oracle("guitar"), sum(out.guitar, out.piano));
+  console.log(`separation t1b/1: ${secsPerMin.toFixed(1)} s per minute of audio`, sdrs);
+}, SLOW);
+
+test("separates t1b/1: every stem stereo 44.1 kHz with exactly the input length", () => {
+  const len = data.mix.channels[0]!.length;
+  for (const s of STEMS) {
+    expect(out[s].sampleRate).toBe(44100);
+    expect(out[s].channels.length).toBe(2);
+    for (const ch of out[s].channels) expect(ch.length).toBe(len);
+  }
+});
+
+test("separates t1b/1: drums > 3 dB, bass beats the mix, guitar(+piano) > 3 dB and beats the mix", () => {
+  // Measured (2026-10-30): drums 5.4 dB (mix -13.7), bass 1.67 dB (mix -2.8), guitar 1.85 dB (mix 1.87),
+  // guitar+piano 4.7 dB. HTDemucs-6s routes ~30% of the GM steel guitar into its piano stem.
+  expect(sdrs.drums!).toBeGreaterThan(3);
+  expect(sdrs.drums!).toBeGreaterThan(sdrs.drums_mixBaseline!);
+  expect(sdrs.bass!).toBeGreaterThan(sdrs.bass_mixBaseline!);
+  expect(sdrs.guitarPlusPiano!).toBeGreaterThan(3);
+  expect(sdrs.guitarPlusPiano!).toBeGreaterThan(sdrs.guitar_mixBaseline!);
+});
+
+// Brief's literal criterion. Unmet by the model on this song (guitar 1.85 dB, bass 1.67 dB); kept as an
+// expected failure so it flips loudly if separation improves. Needs a controller ruling.
+test.failing("brief criterion: guitar and bass stems each > 3 dB and > mix baseline", () => {
+  expect(sdrs.guitar!).toBeGreaterThan(3);
+  expect(sdrs.guitar!).toBeGreaterThan(sdrs.guitar_mixBaseline!);
+  expect(sdrs.bass!).toBeGreaterThan(3);
+  expect(sdrs.bass!).toBeGreaterThan(sdrs.bass_mixBaseline!);
+});
+
+test("a 3-second slice (shorter than one segment) returns 3 s stems", async () => {
+  const n = 3 * 44100;
+  const slice: Audio = { sampleRate: 44100, channels: data.mix.channels.map((c) => c.slice(44100, 44100 + n)) };
+  const out = await separate(slice);
+  for (const s of STEMS) for (const ch of out[s].channels) expect(ch.length).toBe(n);
+}, SLOW);
+
+test("mono input is accepted and returns stereo stems of the same length", async () => {
+  const n = 44100;
+  const mono: Audio = { sampleRate: 44100, channels: [data.mix.channels[0]!.slice(0, n)] };
+  const out = await separate(mono);
+  for (const s of STEMS) {
+    expect(out[s].channels.length).toBe(2);
+    expect(out[s].channels[0]!.length).toBe(n);
+  }
+}, SLOW);
+
+test("rejects sample rates other than 44100", async () => {
+  await expect(separate({ sampleRate: 22050, channels: [new Float32Array(100)] })).rejects.toThrow(/44100/);
+});