test.js

import test, { almost, ok, is } from 'tst'
import { wsola, pvoc, pvocLock, pvsola, pghi, transient, hybrid, paulstretch, psola, sms } from './index.js'
import { lsd, chordBalance, chordRetention, modulationDepth } from '@audio/quality'

// Plain OLA via wsola with delta:0 (correlation search disabled)
const ola = (d, o) => d instanceof Float32Array
  ? wsola(d, { ...o, frameSize: o?.frameSize || 2048, delta: 0 })
  : wsola({ ...d, frameSize: d?.frameSize || 2048, delta: 0 })

let fs = 44100

function sine(freq, n, sampleRate) {
  let d = new Float32Array(n)
  for (let i = 0; i < n; i++) d[i] = Math.sin(2 * Math.PI * freq * i / sampleRate)
  return d
}

function rms(data) {
  let sum = 0
  for (let i = 0; i < data.length; i++) sum += data[i] * data[i]
  return Math.sqrt(sum / data.length)
}

function peakFreq(data, sampleRate) {
  // simple zero-crossing frequency estimation
  let crossings = 0
  for (let i = 1; i < data.length; i++) {
    if (data[i - 1] <= 0 && data[i] > 0) crossings++
  }
  return crossings * sampleRate / data.length
}

// helper: test a stretch algorithm
function testStretch(name, fn, tolerances = {}) {
  let lenTol = tolerances.lenTol ?? 0.05
  let rmsTol = tolerances.rmsTol ?? 0.05
  let freqTol = tolerances.freqTol ?? 0.1

  test(`${name} — factor 1 returns copy`, () => {
    let data = sine(440, 8192, fs)
    let out = fn(data, { factor: 1 })
    is(out.length, data.length)
    almost(rms(out), rms(data), 0.01)
  })

  test(`${name} — factor 2 doubles length`, () => {
    let data = sine(440, 8192, fs)
    let out = fn(data, { factor: 2 })
    almost(out.length, data.length * 2, data.length * lenTol)
    ok(rms(out) > 0.1, 'has signal')
  })

  test(`${name} — factor 0.5 halves length`, () => {
    let data = sine(440, 16384, fs)
    let out = fn(data, { factor: 0.5 })
    almost(out.length, data.length * 0.5, data.length * lenTol)
    ok(rms(out) > 0.1, 'has signal')
  })

  test(`${name} — preserves pitch (440Hz sine)`, () => {
    let data = sine(440, 16384, fs)
    let out = fn(data, { factor: 2 })
    let freq = peakFreq(out, fs)
    almost(freq, 440, 440 * freqTol, 'pitch preserved')
  })

  test(`${name} — energy conservation`, () => {
    let data = sine(440, 8192, fs)
    let out = fn(data, { factor: 2 })
    almost(rms(out), rms(data), rms(data) * rmsTol + 0.05, 'energy preserved')
  })
}

// --- WSOLA ---
testStretch('wsola', wsola)
testStretch('pvsola', pvsola)

// --- Phase vocoder (plain) ---
testStretch('pvoc', pvoc, { rmsTol: 0.15 })

// --- Phase-locked vocoder ---
testStretch('pvocLock', pvocLock, { rmsTol: 0.15 })

// --- Transient-aware vocoder ---
testStretch('transient', transient, { rmsTol: 0.15 })

// --- PGHI vocoder ---
testStretch('pghi', pghi, { rmsTol: 0.15 })

// --- HPSS hybrid ---
testStretch('hybrid', hybrid, { rmsTol: 0.2 })

// --- PaulStretch ---
test('paulstretch — extreme stretch (8x)', () => {
  let data = sine(440, 4096, fs)
  let out = paulstretch(data, { factor: 8 })
  almost(out.length, data.length * 8, data.length * 0.1)
  ok(rms(out) > 0.05, 'has signal')
})

test('paulstretch — factor 1 returns copy', () => {
  let data = sine(440, 4096, fs)
  let out = paulstretch(data, { factor: 1 })
  is(out.length, data.length)
})

test('paulstretch — very extreme (32x)', () => {
  let data = sine(440, 4096, fs)
  let out = paulstretch(data, { factor: 32 })
  almost(out.length, data.length * 32, data.length * 0.2)
  ok(rms(out) > 0.01, 'has signal')
})

// --- PSOLA ---
test('psola — factor 1 returns copy', () => {
  let data = sine(440, 8192, fs)
  let out = psola(data, { factor: 1 })
  is(out.length, data.length)
})

test('psola — factor 2 doubles length', () => {
  let data = sine(440, 8192, fs)
  let out = psola(data, { factor: 2 })
  almost(out.length, data.length * 2, data.length * 0.15)
  ok(rms(out) > 0.05, 'has signal')
})

test('psola — factor 0.5 halves length', () => {
  let data = sine(440, 8192, fs)
  let out = psola(data, { factor: 0.5 })
  almost(out.length, data.length * 0.5, data.length * 0.15)
  ok(rms(out) > 0.05, 'has signal')
})

test('psola — preserves pitch (440Hz sine)', () => {
  let data = sine(440, 16384, fs)
  let out = psola(data, { factor: 2 })
  let freq = peakFreq(out, fs)
  almost(freq, 440, 440 * 0.1, 'pitch preserved')
})

test('psola — energy conservation', () => {
  let data = sine(440, 8192, fs)
  let out = psola(data, { factor: 2 })
  almost(rms(out), rms(data), rms(data) * 0.3, 'energy preserved')
})

// --- Streaming ---
function testStream(name, fn, streamOpts = {}) {
  let factor = streamOpts.factor ?? 2
  let chunkSize = streamOpts.chunkSize ?? 4096
  let lenTol = streamOpts.lenTol ?? 0.15
  let energyTol = streamOpts.energyTol ?? 0.3

  test(`${name} writer — matches batch output`, () => {
    let data = sine(440, 16384, fs)
    let batch = fn(data, { factor })
    let batchRms = rms(batch)

    let write = fn({ factor })
    let chunks = []
    for (let i = 0; i < data.length; i += chunkSize) {
      let chunk = data.subarray(i, Math.min(i + chunkSize, data.length))
      let out = write(chunk)
      if (out.length) chunks.push(out)
    }
    let tail = write()
    if (tail.length) chunks.push(tail)

    let total = chunks.reduce((s, c) => s + c.length, 0)
    ok(total > 0, 'produces output')
    almost(total, batch.length, batch.length * lenTol, 'similar length')

    let assembled = new Float32Array(total)
    let off = 0
    for (let c of chunks) { assembled.set(c, off); off += c.length }
    let streamRms = rms(assembled)
    ok(streamRms > 0.05, 'has signal')
    almost(streamRms, batchRms, batchRms * energyTol, 'similar energy')
  })

  test(`${name} writer — handles small chunks`, () => {
    let data = sine(440, 8192, fs)
    let write = fn({ factor })
    let chunks = []
    for (let i = 0; i < data.length; i += 512) {
      let out = write(data.subarray(i, Math.min(i + 512, data.length)))
      if (out.length) chunks.push(out)
    }
    let tail = write()
    if (tail.length) chunks.push(tail)
    let total = chunks.reduce((s, c) => s + c.length, 0)
    ok(total > 0, 'produces output from small chunks')
  })

  test(`${name} writer — silence stays silent`, () => {
    let data = new Float32Array(8192)
    let write = fn({ factor })
    let chunks = []
    for (let i = 0; i < data.length; i += chunkSize) {
      let out = write(data.subarray(i, i + chunkSize))
      if (out.length) chunks.push(out)
    }
    let tail = write()
    if (tail.length) chunks.push(tail)
    let total = chunks.reduce((s, c) => s + c.length, 0)
    if (total > 0) {
      let assembled = new Float32Array(total)
      let off = 0
      for (let c of chunks) { assembled.set(c, off); off += c.length }
      almost(rms(assembled), 0, 0.001, 'silence preserved')
    }
  })
}

testStream('ola', ola)
testStream('wsola', wsola)
testStream('pvoc', pvoc)
testStream('pvocLock', pvocLock)
testStream('pvsola', pvsola)
testStream('transient', transient)
testStream('paulstretch', paulstretch, { factor: 8, lenTol: 0.25, energyTol: 2 })
testStream('psola', psola, { lenTol: 0.25, energyTol: 0.5 })
testStream('sms', sms)
testStream('pghi', pghi)
testStream('hybrid', hybrid, { lenTol: 0.25, energyTol: 0.5 })

// --- Extreme ratios ---
function testExtreme(name, fn, factor, minLen) {
  test(`${name} — extreme ratio ${factor}x`, () => {
    let data = sine(440, 16384, fs)
    let out = fn(data, { factor })
    ok(out.length >= minLen, `output length ${out.length} >= ${minLen}`)
    ok(isFinite(rms(out)), 'no NaN/Infinity')
  })
}

testExtreme('ola', ola, 0.1, 100)
testExtreme('ola', ola, 10, 100000)
testExtreme('wsola', wsola, 0.1, 100)
testExtreme('wsola', wsola, 10, 100000)
testExtreme('pvoc', pvoc, 0.1, 100)
testExtreme('pvoc', pvoc, 10, 100000)
testExtreme('pvocLock', pvocLock, 0.1, 100)
testExtreme('pvocLock', pvocLock, 10, 100000)
testExtreme('pvsola', pvsola, 0.1, 100)
testExtreme('pvsola', pvsola, 10, 100000)
testExtreme('transient', transient, 0.1, 100)
testExtreme('transient', transient, 10, 100000)
testExtreme('psola', psola, 0.1, 100)
testExtreme('psola', psola, 10, 100000)
testExtreme('paulstretch', paulstretch, 100, 1000000)

// --- Multi-channel (stereo) ---
// All algorithms process mono Float32Array. Stereo is handled by splitting channels.

function stereoTest(name, fn, opts) {
  test(`${name} — stereo split/process/recombine`, () => {
    let n = 8192
    let L = sine(440, n, fs)
    let R = sine(660, n, fs)

    let outL = fn(L, opts)
    let outR = fn(R, opts)

    ok(outL.length > 0, 'left channel has output')
    ok(outR.length > 0, 'right channel has output')
    is(outL.length, outR.length, 'channels same length')
    ok(rms(outL) > 0.05, 'left has signal')
    ok(rms(outR) > 0.05, 'right has signal')

    let diff = 0
    let len = Math.min(outL.length, outR.length)
    for (let i = 0; i < len; i++) diff += Math.abs(outL[i] - outR[i])
    ok(diff / len > 0.01, 'channels are different')
  })

  test(`${name} writer — stereo split/process/recombine`, () => {
    let n = 16384
    let L = sine(440, n, fs)
    let R = sine(660, n, fs)

    let wL = fn(opts)
    let wR = fn(opts)
    let chunksL = [], chunksR = []

    for (let i = 0; i < n; i += 4096) {
      let cL = wL(L.subarray(i, Math.min(i + 4096, n)))
      let cR = wR(R.subarray(i, Math.min(i + 4096, n)))
      if (cL.length) chunksL.push(cL)
      if (cR.length) chunksR.push(cR)
    }
    let tL = wL(), tR = wR()
    if (tL.length) chunksL.push(tL)
    if (tR.length) chunksR.push(tR)

    let totalL = chunksL.reduce((s, c) => s + c.length, 0)
    let totalR = chunksR.reduce((s, c) => s + c.length, 0)

    ok(totalL > 0, 'left stream has output')
    ok(totalR > 0, 'right stream has output')
    almost(totalL, totalR, totalL * 0.05, 'stream channels similar length')
  })
}

stereoTest('ola', ola, { factor: 1.5 })
stereoTest('wsola', wsola, { factor: 1.5 })
stereoTest('pvoc', pvoc, { factor: 1.5 })
stereoTest('pvocLock', pvocLock, { factor: 1.5 })
stereoTest('pvsola', pvsola, { factor: 1.5 })
stereoTest('transient', transient, { factor: 1.5 })
stereoTest('paulstretch', paulstretch, { factor: 4 })
stereoTest('psola', psola, { factor: 1.5 })

// --- SMS (Sinusoidal Modeling Synthesis) ---
testStretch('sms', sms, { rmsTol: 0.2, freqTol: 0.1 })
testStream('sms', sms, { energyTol: 0.5 })
testExtreme('sms', sms, 0.1, 100)
testExtreme('sms', sms, 10, 100000)
stereoTest('sms', sms, { factor: 1.5 })

// --- Quality metrics ---
test('transient — preserves attack sharpness', () => {
  let n = 16384
  let data = new Float32Array(n)
  for (let i = 0; i < n; i += 2048) {
    for (let j = 0; j < 64 && i + j < n; j++) data[i + j] = Math.sin(2 * Math.PI * 440 * j / fs) * (1 - j / 64)
  }
  let out = transient(data, { factor: 2 })
  let peak = 0
  for (let i = 0; i < out.length; i++) peak = Math.max(peak, Math.abs(out[i]))
  ok(peak > 0.3, `transient peaks preserved (peak=${peak.toFixed(3)})`)
})

test('sms — noise residual energy preservation', () => {
  let n = 8192, seed = 0x12345
  let data = new Float32Array(n)
  for (let i = 0; i < n; i++) {
    seed = (seed * 1664525 + 1013904223) >>> 0
    data[i] = (seed / 0x100000000 - 0.5) * 0.6
  }
  let out = sms(data, { factor: 2, residualMix: 1 })
  ok(rms(out) > rms(data) * 0.3, 'noise energy preserved via residual')
})

test('pvocLock — spectral purity on sine', () => {
  let data = sine(440, 16384, fs)
  let out = pvocLock(data, { factor: 1.5 })
  let trim = Math.floor(out.length * 0.1)
  let freq = peakFreq(out.slice(trim, out.length - trim), fs)
  almost(freq, 440, 22, 'frequency drift < 5%')
})

// --- Spectral-quality regression (LSD vs. regenerated ground truth) ---
// LSD < 1.5 dB = transparent, < 3 good, > 5 poor.

function chordSig(dur) {
  let freqs = [261.6, 329.6, 392.0]
  let n = Math.round(dur * fs), d = new Float32Array(n)
  let a = 0.72 / freqs.length
  for (let i = 0; i < n; i++) for (let f of freqs) d[i] += Math.sin(2 * Math.PI * f * i / fs) * a
  return d
}

function sweepSig(f0, f1, dur) {
  let n = Math.round(dur * fs), d = new Float32Array(n)
  for (let i = 0; i < n; i++) {
    let t = i / fs, f = f0 + (f1 - f0) * t / dur
    d[i] = Math.sin(2 * Math.PI * f * t) * 0.72
  }
  return d
}

function vowelSig(freq, dur) {
  let n = Math.round(dur * fs), d = new Float32Array(n)
  let formants = [700, 1200, 2500], bw = [80, 120, 160]
  for (let h = 1; h <= 30; h++) {
    let hf = freq * h
    if (hf > fs / 2) break
    let amp = 0
    for (let fi = 0; fi < 3; fi++) {
      let df = hf - formants[fi]
      amp += Math.exp(-0.5 * (df / bw[fi]) ** 2)
    }
    amp = amp * 0.3 / h
    for (let i = 0; i < n; i++) d[i] += Math.sin(2 * Math.PI * hf * i / fs) * amp
  }
  return d
}

function sineSig(freq, dur) {
  let n = Math.round(dur * fs), d = new Float32Array(n)
  for (let i = 0; i < n; i++) d[i] = Math.sin(2 * Math.PI * freq * i / fs) * 0.8
  return d
}

// Limits set ~0.2-0.4 dB above measured to catch regressions, not noise.
let qualityCases = [
  // [name, fn, sigName, gen, factor, maxLSD]
  ['pvocLock',  pvocLock,  'sine',   f => sineSig(440, 0.5 * f),                 0.5, 0.7],
  ['pvocLock',  pvocLock,  'sine',   f => sineSig(440, 0.5 * f),                 2.0, 0.7],
  ['pvocLock',  pvocLock,  'chord',  f => chordSig(0.5 * f),                     0.5, 0.7],
  ['pvocLock',  pvocLock,  'chord',  f => chordSig(0.5 * f),                     1.5, 0.7],
  ['pvocLock',  pvocLock,  'chord',  f => chordSig(0.5 * f),                     2.0, 0.8],

  ['pvoc',      pvoc,      'chord',  f => chordSig(0.5 * f),                     0.5, 1.3],
  // 2.0× re-measured at 0.83 after the stft center-alignment fix (identical for
  // the old onset-zeroing) — re-ratcheted from 0.7 per the +0.2 convention.
  ['pvoc',      pvoc,      'chord',  f => chordSig(0.5 * f),                     2.0, 1.05],
  ['pvoc',      pvoc,      'sweep',  f => sweepSig(200, 2000, 0.5 * f),          2.0, 3.2],

  ['transient', transient, 'chord',  f => chordSig(0.5 * f),                     1.5, 0.8],

  ['wsola',     wsola,     'sine',   f => sineSig(440, 0.5 * f),                 2.0, 0.2],
  ['wsola',     wsola,     'chord',  f => chordSig(0.5 * f),                     2.0, 0.9],
  ['wsola',     wsola,     'vowel',  f => vowelSig(150, 0.5 * f),                2.0, 0.2],

  // pghi: measured 0.17 sine / 0.85 sweep / 0.94 chord @2x (gradient integration
  // beats locking on modulated content, approximates it on steady polyphony)
  ['pghi',      pghi,      'sine',   f => sineSig(440, 0.5 * f),                 2.0, 0.4],
  ['pghi',      pghi,      'sweep',  f => sweepSig(200, 2000, 0.5 * f),          2.0, 1.1],
  ['pghi',      pghi,      'chord',  f => chordSig(0.5 * f),                     2.0, 1.2],

  ['hybrid',    hybrid,    'chord',  f => chordSig(0.5 * f),                     2.0, 1.0],

  ['psola',     psola,     'sine',   f => sineSig(440, 0.5 * f),                 1.5, 0.4],
  ['psola',     psola,     'vowel',  f => vowelSig(150, 0.5 * f),                1.5, 1.0],
]

for (let [name, fn, sigName, gen, factor, maxLSD] of qualityCases) {
  test(`${name} — LSD on ${sigName} @ ${factor}× < ${maxLSD} dB`, () => {
    let src = gen(1)
    let truth = gen(factor)
    let out = fn(src, { factor })
    let score = lsd(out, truth, { trim: 0.1 })
    ok(score < maxLSD, `LSD=${score.toFixed(2)} dB (limit ${maxLSD})`)
  })
}

// PSOLA falls through to WSOLA on polyphonic content (voiced threshold 0.72
// rejects chords whose autocorrelation peaks ~0.58). Verify reasonable quality.
test('psola — chord falls through to wsola (LSD < 0.9 dB)', () => {
  let src = chordSig(0.5)
  let truth = chordSig(1.0)
  let out = psola(src, { factor: 2 })
  let score = lsd(out, truth, { trim: 0.1 })
  ok(score < 0.9, `LSD=${score.toFixed(2)} dB (limit 0.9)`)
})

test('lsd — identity returns 0', () => {
  let a = chordSig(0.5)
  almost(lsd(a, a, { trim: 0.1 }), 0, 0.001)
})

test('lsd — non-matching signals return large value', () => {
  let a = sineSig(440, 0.5)
  let b = sineSig(880, 0.5)
  ok(lsd(a, b, { trim: 0.1 }) > 5, 'different pitches = high LSD')
})

// --- Chord partial balance & retention (Goertzel-based) ---
let chordFreqs = [261.6, 329.6, 392.0]
let chordBalanceCases = [
  // [name, fn, opts, minBalance, minRetention]
  ['pvocLock 0.5×', pvocLock, { factor: 0.5 }, 0.9, 0.9],
  ['pvocLock 2.0×', pvocLock, { factor: 2.0 }, 0.9, 0.9],
  ['wsola 0.5×',    wsola,    { factor: 0.5 }, 0.4, 0.5],
  ['wsola 2.0×',    wsola,    { factor: 2.0 }, 0.15, 0.4],
  ['psola 0.5×',    psola,    { factor: 0.5 }, 0.4, 0.5],
  ['psola 2.0×',    psola,    { factor: 2.0 }, 0.15, 0.4],
]

for (let [name, fn, opts, minBal, minRet] of chordBalanceCases) {
  test(`chord balance — ${name}`, () => {
    let src = chordSig(1.0)
    let ref = chordSig(1.0 * opts.factor)
    let out = fn(src, opts)
    let bal = chordBalance(out, chordFreqs, fs)
    let ret = chordRetention(out, ref, chordFreqs, fs)
    ok(bal >= minBal, `balance=${bal.toFixed(3)} (min ${minBal})`)
    ok(ret >= minRet, `retention=${ret.toFixed(3)} (min ${minRet})`)
  })
}

// --- Chord modulation depth ("crumble") regression ---
// Hop-rate amplitude modulation on polyphonic content — the defect canonical WSOLA
// was created to avoid.
let modulationCases = [
  // [name, fn, opts, freqs, maxDepth]
  ['pvocLock chord 2.0×', pvocLock, { factor: 2.0 }, chordFreqs, 0.05],
  ['wsola chord 2.0×',    wsola,    { factor: 2.0 }, chordFreqs, 0.05],
  ['wsola chord 1.5×',    wsola,    { factor: 1.5 }, chordFreqs, 0.05],
  ['wsola chord 0.5×',    wsola,    { factor: 0.5 }, chordFreqs, 0.05],
  ['wsola sine 2.0×',     wsola,    { factor: 2.0 }, [440],      0.02],
]

for (let [name, fn, opts, freqs, maxDepth] of modulationCases) {
  test(`modulation depth — ${name}`, () => {
    let src = freqs.length === 1 ? sineSig(freqs[0], 1.0) : chordSig(1.0)
    let out = fn(src, opts)
    let depth = modulationDepth(out, freqs, fs)
    ok(depth < maxDepth, `depth=${depth.toFixed(3)} (max ${maxDepth})`)
  })
}

// --- Alignment & onset regression (stft center-mapping) ---
// Input time t must land at t×factor: the pre-fix engine lagged by (N/2)(factor−1)
// and pvoc zeroed pre-pad frames, swallowing the first ~N×factor samples.

function firstAbove(data, thresh) {
  for (let i = 0; i < data.length; i++) if (Math.abs(data[i]) > thresh) return i
  return -1
}

// RMS half-max crossing — a threshold on raw samples would bias early by the
// window ramp; the envelope midpoint tracks the perceptual event position.
function onsetPos(data) {
  let win = 256, nWin = Math.floor(data.length / win), maxRms = 0
  let env = new Float64Array(nWin)
  for (let k = 0; k < nWin; k++) {
    let s = 0
    for (let i = 0; i < win; i++) { let v = data[k * win + i]; s += v * v }
    env[k] = Math.sqrt(s / win)
    if (env[k] > maxRms) maxRms = env[k]
  }
  for (let k = 0; k < nWin; k++) if (env[k] > maxRms * 0.5) return k * win
  return -1
}

for (let [name, fn] of [['pvocLock', pvocLock], ['transient', transient]]) {
  test(`${name} — stretched event lands at t×factor (±512)`, () => {
    let n = fs * 2, from = Math.floor(0.5 * fs)
    let data = new Float32Array(n)
    for (let i = from; i < Math.floor(1.2 * fs); i++) data[i] = Math.sin(2 * Math.PI * 440 * i / fs) * 0.8
    for (let factor of [0.5, 2]) {
      let onset = onsetPos(fn(data, { factor }))
      ok(Math.abs(onset - from * factor) <= 512, `${factor}×: onset ${onset} vs ideal ${from * factor}`)
    }
  })
}

test('pvoc — onset from t=0 is not swallowed', () => {
  let onset = firstAbove(pvoc(sine(440, fs, fs), { factor: 2 }), 0.05)
  ok(onset >= 0 && onset < 512, `first audible sample at ${onset}`)
})

// --- Streaming with fractional analysis hop (regression: NaN output at 1.5×) ---
for (let [name, fn] of [['pvoc', pvoc], ['pvocLock', pvocLock], ['pghi', pghi], ['transient', transient], ['hybrid', hybrid], ['paulstretch', paulstretch], ['sms', sms]]) {
  test(`${name} stream — finite output at fractional hop (1.5×)`, () => {
    let data = sine(440, 32768, fs)
    let write = fn({ factor: 1.5 })
    let total = 0, energy = 0, bad = 0
    let consume = (out) => {
      for (let j = 0; j < out.length; j++) { if (!Number.isFinite(out[j])) bad++; energy += out[j] * out[j] }
      total += out.length
    }
    for (let i = 0; i < data.length; i += 1024) consume(write(data.subarray(i, Math.min(i + 1024, data.length))))
    consume(write())
    is(bad, 0, 'no NaN/Inf samples')
    ok(Math.abs(total - data.length * 1.5) < data.length * 0.15, `length ${total} ≈ ${data.length * 1.5}`)
    ok(Math.sqrt(energy / Math.max(1, total)) > 0.3, 'carries signal energy')
  })
}

test('pvocLock streaming: non-integer anaHop ratios stay finite', () => {
  // regression: hopSize/factor was passed unrounded — the STFT ring indexed at a
  // fractional hop and emitted NaN for any non-integer ratio (all semitone ratios)
  let x = sine(440, fs, fs)
  for (let factor of [1.5, 1.25, 1.7, 2.5, 0.75, 2 ** (7 / 12)]) {
    let write = pvocLock({ factor, frameSize: 1024 })
    let out = write(x.slice())
    ok(out.length > 0, `factor ${factor.toFixed(3)} emits`)
    ok([...out].every(v => isFinite(v)), `factor ${factor.toFixed(3)} finite`)
  }
})

// =============================================================================
// audio.js manifests — whole-render atoms with a structural `frames` hook

test('manifests — every package hosts as a variable-length whole atom', async () => {
  let sr = 44100, N = 16384, d = new Float32Array(N)
  for (let i = 0; i < N; i++) d[i] = 0.5 * Math.sin(2 * Math.PI * 440 * i / sr)
  for (let pkg of ['pvoc-lock', 'pvoc', 'pvsola', 'pghi', 'wsola', 'psola', 'sms', 'transient', 'hybrid', 'paulstretch']) {
    let mod = await import(`./packages/stretch-${pkg}/audio.js`)
    let m = Object.values(mod)[0]
    ok(typeof m === 'function' && m.streaming === false && typeof m.frames === 'function', `${pkg}: whole-render manifest shape`)
    let params = {}
    for (let [k, sp] of Object.entries(m.params)) params[k] = new Float32Array([sp.default])
    params.factor = new Float32Array([2])
    let outLen = m.frames(N, { sampleRate: sr, params })
    is(outLen, N * 2, `${pkg}: frames hook = input × factor`)
    let process = m({ sampleRate: sr })
    let out = [new Float32Array(outLen)]
    process([[d]], [out], params)
    ok(out[0].some(v => Math.abs(v) > 0.05), `${pkg}: produced signal`)
    ok([...out[0]].every(Number.isFinite), `${pkg}: finite output`)
    // pitch preserved over the steady middle
    let o = out[0], from = outLen >> 2, to = outLen - (outLen >> 2), zc = 0
    for (let i = from + 1; i < to; i++) if ((o[i - 1] < 0) !== (o[i] < 0)) zc++
    let hz = zc / 2 / ((to - from) / sr)
    ok(Math.abs(hz - 440) < 10, `${pkg}: pitch preserved (${hz.toFixed(0)}Hz)`)
  }
})

test('pvoc-lock, pghi — sliding factor fn: length integrates, pitch preserved throughout', () => {
	let sr = 44100, n = sr * 2, d = new Float32Array(n)
	for (let i = 0; i < n; i++) d[i] = 0.5 * Math.sin(2 * Math.PI * 440 * i / sr)
	let f = t => 1 + Math.min(1, Math.max(0, t / 2))  // 1 → 2 over the 2s source
	for (let [name, fn] of [['pvoc-lock', pvocLock], ['pghi', pghi]]) {
		let out = fn(d, { factor: f, fs: sr, sampleRate: sr })
		almost(out.length / n, 1.5, 0.02, `${name}: ∫factor over source (got ${(out.length / n).toFixed(3)})`)
		ok([...out].every(isFinite), `${name}: finite`)
		let zc = (a, lo, hi) => { let c = 0; for (let i = lo + 1; i < hi; i++) if ((a[i - 1] < 0) !== (a[i] < 0)) c++; return c / 2 / ((hi - lo) / sr) }
		almost(zc(out, sr >> 2, sr >> 1), 440, 6, `${name}: pitch early`)
		almost(zc(out, out.length - sr, out.length - (sr >> 2)), 440, 6, `${name}: pitch late (2× region)`)

		// streaming form matches
		let w = fn({ factor: f, fs: sr, sampleRate: sr })
		let total = 0
		for (let off = 0; off < n; off += 4096) total += w(d.subarray(off, Math.min(off + 4096, n))).length
		total += w().length
		almost(total / n, 1.5, 0.02, `${name}: stream length integrates`)
	}
})

// --- audit 2026-07-10: channel-array + Float64 input parity with @audio/shift ---

test('batch entries accept [L, R] channel arrays and Float64Array', () => {
	let L = new Float32Array(8000), R = new Float32Array(8000)
	for (let i = 0; i < 8000; i++) { L[i] = Math.sin(2 * Math.PI * 220 * i / 8000); R[i] = Math.sin(2 * Math.PI * 330 * i / 8000) }
	for (const fn of [wsola, pvoc]) {
		let out = fn([L, R], { factor: 2, sampleRate: 8000 })
		ok(Array.isArray(out) && out.length === 2, fn.name + ': channel array in → channel array out')
		ok(Math.abs(out[0].length - 2 * L.length) < 4096, fn.name + ': each channel stretched (' + out[0].length + ')')
		let d64 = fn(Float64Array.from(L), { factor: 2, sampleRate: 8000 })
		ok(d64 instanceof Float32Array && Math.abs(d64.length - 2 * L.length) < 4096, fn.name + ': Float64Array accepted')
	}
})

// --- stream ≡ batch: every chunking yields the batch output, sample for sample ---

function streamed(fn, x, opts, sizes) {
	let w = fn(opts), parts = []
	for (let i = 0, k = 0; i < x.length; k++) { let n = sizes[k % sizes.length]; parts.push(w(x.subarray(i, i + n))); i += n }
	parts.push(w())
	let out = new Float32Array(parts.reduce((a, p) => a + p.length, 0)), o = 0
	for (let p of parts) { out.set(p, o); o += p.length }
	return out
}

test('stream ≡ batch under any chunking (wsola, pvsola, sms, hybrid, paulstretch, pvoc, pvocLock, pghi, transient)', () => {
	// wsola/sms zeroed their unfinished overlap-add tails at each buffer compaction (clicks
	// every ~16k samples) and ran their own grain schedules (±2 % length); hybrid stitched
	// independent segment renders; paulstretch threw once the analysis hop passed the frame
	let sr = 44100, seed = 3, rnd = () => (seed = (seed * 16807) % 2147483647) / 2147483647 * 2 - 1
	let x = Float32Array.from({ length: sr + 123 }, (_, i) => 0.4 * Math.sin(2 * Math.PI * 220 * i / sr) + 0.2 * Math.sin(2 * Math.PI * 1370 * i / sr) + 0.05 * rnd())
	for (let [name, fn] of Object.entries({ wsola, pvsola, sms, hybrid, paulstretch, pvoc, pvocLock, pghi, transient })) {
		for (let factor of [0.13, 0.5, 1.37, 3]) {
			let batch = fn(Float32Array.from(x), { factor, sampleRate: sr })
			for (let sizes of [[997], [64], [4096, 3, 1000]]) {
				let s = streamed(fn, x, { factor, sampleRate: sr }, sizes), m = s.length === batch.length ? 0 : Infinity
				for (let i = 0; i < batch.length && m < Infinity; i++) m = Math.max(m, Math.abs(s[i] - batch[i]))
				is(m, 0, `${name} ×${factor}, chunks ${sizes}: stream ≡ batch`)
			}
		}
	}
})

test('psola stream — spliced segments stay click-free, level-true and batch-length', () => {
	// Segments render on their own pitch-synchronous grids: the plain crossfade cancelled
	// (−3 dB) and kinked (72× a clean sine's curvature); renders also began after a silent
	// gap and ended cut off
	let sr = 44100, n = 2 * sr, f0 = 220, amp = 0.5
	let x = Float32Array.from({ length: n }, (_, i) => amp * Math.sin(2 * Math.PI * f0 * i / sr) * Math.min(1, i / 2205, (n - i) / 2205))
	let curve = amp * (2 * Math.PI * f0 / sr) ** 2
	for (let factor of [0.2, 0.5, 1.5, 3]) {
		for (let y of [psola(Float32Array.from(x), { factor, sampleRate: sr }), streamed(psola, x, { factor, sampleRate: sr }, [997])]) {
			is(y.length, Math.round(n * factor), `×${factor}: length`)
			let g = 0, e = 0, a = Math.floor(y.length * 0.1), b = Math.floor(y.length * 0.9)
			for (let i = 1; i < y.length - 1; i++) g = Math.max(g, Math.abs(y[i + 1] - 2 * y[i] + y[i - 1]) / curve)
			for (let i = a; i < b; i++) e += y[i] * y[i]
			ok(g < 3, `×${factor}: curvature ≤ ${g.toFixed(1)}× a clean sine's`)
			almost(20 * Math.log10(Math.sqrt(e / (b - a)) / (amp / Math.SQRT2)), 0, 0.5, `×${factor}: level`)
		}
	}
})

test('sms — input shorter than one frame stays finite (was NaN)', () => {
	for (let len of [1, 100, 2047]) {
		let x = Float32Array.from({ length: len }, (_, i) => 0.5 * Math.sin(i * 0.05))
		ok(sms(x, { factor: 2 }).every(Number.isFinite), `${len} samples: batch finite`)
		ok(streamed(sms, x, { factor: 2 }, [300]).every(Number.isFinite), `${len} samples: stream finite`)
	}
})

test('paulstretch — level stays flat across the grain hop (random-phase grains add power)', () => {
	// Normalizing uncorrelated grains by Σw², as for coherent frames, left a 2.7 dB tremolo
	// at the hop rate and a 2.7 dB loss
	let seed = 7, rnd = () => (seed = (seed * 16807) % 2147483647) / 2147483647 * 2 - 1
	let x = Float32Array.from({ length: 44100 * 2 }, () => 0.3 * rnd()), y = paulstretch(x, { factor: 8 })
	let hop = 2048, e = new Float64Array(8), n = new Float64Array(8), all = 0
	for (let i = 44100 * 2; i < y.length - 44100 * 2; i++) { let b = Math.floor(i % hop / (hop / 8)); e[b] += y[i] * y[i]; n[b]++; all += y[i] * y[i] }
	let ref = 0.09 / 3, db = [...e].map((v, b) => 10 * Math.log10(v / n[b] / ref))
	ok(Math.max(...db) - Math.min(...db) < 0.3, `ripple across the hop ${(Math.max(...db) - Math.min(...db)).toFixed(2)} dB`)
	almost(10 * Math.log10(all / (y.length - 44100 * 4) / ref), 0, 0.3, 'level matches the input')
})

test('wsola stretcher — a host map at rate 1 gives the input back; one alignment for all channels; no read past a declared end', async () => {
	let { stretcher } = await import('./packages/stretch-wsola/wsola.js')
	let sr = 44100, seed = 5, rnd = () => (seed = (seed * 16807) % 2147483647) / 2147483647 * 2 - 1
	let x = Float32Array.from({ length: sr }, (_, i) => 0.4 * Math.sin(2 * Math.PI * 180 * i / sr) + 0.1 * rnd())
	let run = (o, chs) => { let s = stretcher(chs.length, o), a = s.write(chs), b = s.end(); return a.map((p, c) => { let r = new Float32Array(p.length + b[c].length); r.set(p); r.set(b[c], p.length); return r }) }
	let [y] = run({ at: s => s, sampleRate: sr }, [x])
	ok(y.length >= x.length && x.every((v, i) => v === y[i]), 'at(s) = s: the input, sample for sample')
	let [l, r] = run({ factor: 1.7, sampleRate: sr }, [x, x.map(v => -v)])
	ok(l.every((v, i) => v === -r[i]), 'channels share one search')
	// a stretch to a declared end: the last samples are still the input's, not silence past it
	let [z] = run({ at: s => s / 2, end: x.length, sampleRate: sr }, [x])
	let tail = z.subarray(2 * x.length - 2000, 2 * x.length)
	ok(tail.every(v => v !== 0), 'the end of a 2× stretch reads within the input')
	// a host's end between samples (a sliding map's), fed silence past it as a host's reader pads, never ended: reads stay
	// on whole samples (were NaN once the end capped them)
	// (43941 samples put segment 56's centre 50 samples before the end, where the cap binds)
	let h = stretcher(1, { at: s => s / 1.37, end: 43941 - 0.4, sampleRate: sr })
	let q = [...h.write([x.subarray(0, 43941)])[0], ...h.write([new Float32Array(sr)])[0]]
	ok(q.length > 1.3 * x.length && q.every(Number.isFinite), 'a fractional end: finite')
	// the smallest inputs, and a stream split just before its end, as the batch
	for (let n of [0, 1, 100, 1500]) {
		let y = wsola(x.slice(0, n), { factor: 1.5 })
		ok(y.length === Math.round(n * 1.5) && y.every(Number.isFinite), `${n} samples → ${y.length}, finite`)
	}
	let whole = wsola(x, { factor: 1.37 })
	for (let sizes of [[x.length - 1, 1], [x.length]]) {
		let s = streamed(wsola, x, { factor: 1.37 }, sizes)
		ok(s.length === whole.length && s.every((v, i) => v === whole[i]), `stream split ${sizes} ≡ batch`)
	}
	ok(wsola({ factor: 2 })().length === 0, 'a stream ended unfed: nothing')
})

test('pvsola — slowed noise stays noise (no comb); a voice keeps its pulses; a host map at rate 1 gives the input back', async () => {
	let { stretcher } = await import('./packages/stretch-pvsola/pvsola.js')
	let sr = 44100, seed = 9, rnd = () => (seed = (seed * 16807) % 2147483647) / 2147483647 * 2 - 1
	// the strongest normalized autocorrelation over 2 to 20 ms lags, 20 ms frames: WSOLA's repeats make noise periodic
	let comb = y => {
		let W = 882, s = 0, c = 0
		for (let p = sr / 2; p + 2 * W < y.length - sr / 2; p += 2205, c++) {
			let best = 0
			for (let l = 88; l <= W; l++) { let xy = 0, xx = 0, yy = 0; for (let i = 0; i < W; i++) { let a = y[p + i], b = y[p + i + l]; xy += a * b; xx += a * a; yy += b * b } best = Math.max(best, xy / Math.sqrt(xx * yy)) }
			s += best
		}
		return s / c
	}
	let noise = Float32Array.from({ length: sr * 2 }, () => .3 * rnd()), k = comb(noise)
	for (let f of [1.5, 2]) {
		let p = comb(pvsola(noise, { factor: f })), w = comb(wsola(noise, { factor: f }))
		ok(p < k + .06 && w > p + .2, `×${f}: pvsola ${p.toFixed(3)}, wsola ${w.toFixed(3)}, the input ${k.toFixed(3)}`)
	}
	// glottal pulses at 120 Hz through two formants: their kurtosis kept, which the plain vocoder halves
	let x = new Float32Array(sr * 2), ph = 0, z = [0, 0, 0, 0], res = (f, bw) => { let r = Math.exp(-Math.PI * bw / sr); return [2 * r * Math.cos(2 * Math.PI * f / sr), -r * r] }
	let [a1, a2] = res(700, 80), [b1, b2] = res(1200, 100)
	for (let i = 0; i < x.length; i++) { ph += 120 * (1 + .05 * Math.sin(2 * Math.PI * 3 * i / sr)) / sr; let e = ph >= 1 ? (ph -= 1, 1) : 0, s1 = e + a1 * z[0] + a2 * z[1]; z[1] = z[0]; z[0] = s1; x[i] = s1 + b1 * z[2] + b2 * z[3]; z[3] = z[2]; z[2] = x[i] }
	let kurt = y => { let a = y.length >> 2, b = y.length - a, mu = 0, m2 = 0, m4 = 0; for (let i = a; i < b; i++) mu += y[i] / (b - a); for (let i = a; i < b; i++) { let d = y[i] - mu; m2 += d * d; m4 += d ** 4 } return m4 * (b - a) / (m2 * m2) }
	for (let f of [1.5, 2]) {
		let kp = kurt(pvsola(x, { factor: f })) / kurt(x), kl = kurt(pvocLock(x, { factor: f })) / kurt(x)
		ok(kp > .95 && kl < .75, `×${f}: pulse kurtosis kept ${kp.toFixed(2)} (phase-locked vocoder ${kl.toFixed(2)})`)
	}
	let s = stretcher(1, { at: t => t, sampleRate: sr }), y = [...s.write([noise])[0], ...s.end()[0]], e = 0
	for (let i = 0; i < noise.length; i++) e = Math.max(e, Math.abs(y[i] - noise[i]))
	ok(e < 1e-6, `at(s) = s: the input (${e.toExponential(1)})`)
	// the smallest inputs, a stream split just before its end, a stream ended unfed
	for (let n of [0, 1, 100, 1500]) {
		let q = pvsola(noise.slice(0, n), { factor: 1.5 })
		ok(q.length === Math.round(n * 1.5) && q.every(Number.isFinite), `${n} samples → ${q.length}, finite`)
	}
	let whole = pvsola(x, { factor: 1.37 })
	for (let sizes of [[x.length - 1, 1], [x.length]]) {
		let q = streamed(pvsola, x, { factor: 1.37 }, sizes)
		ok(q.length === whole.length && q.every((v, i) => v === whole[i]), `stream split ${sizes} ≡ batch`)
	}
	ok(pvsola({ factor: 2 })().length === 0, 'a stream ended unfed: nothing')
})