private fun checkMath(report: Reporter) {
        var maxLog2Err = 0.0
        var x = 0.01
        while (x < 20_000.0) {
            val approx = DoughMath.log2(x.toFloat()).toDouble()
            val exact = log2(x)
            maxLog2Err = max(maxLog2Err, abs(approx - exact))
            x *= 1.05
        }
        report.check("log2 within 1e-3 absolute over 0.01…20k", maxLog2Err < 1e-3, "max err %.2e".format(maxLog2Err))

        var maxExp2RelErr = 0.0
        var e = -30.0
        while (e < 30.0) {
            val approx = DoughMath.exp2(e.toFloat()).toDouble()
            val exact = Math.pow(2.0, e)
            maxExp2RelErr = max(maxExp2RelErr, abs(approx - exact) / exact)
            e += 0.031
        }
        report.check("exp2 within 1e-3 relative over -30…30", maxExp2RelErr < 1e-3, "max rel err %.2e".format(maxExp2RelErr))

        report.check("exp2 saturates instead of returning NaN", DoughMath.exp2(1e9f).isFinite() && DoughMath.exp2(-1e9f) == 0f)

        val pow = DoughMath.pow(2f, 10f)
        report.check("pow(2,10) ≈ 1024", abs(pow - 1024f) / 1024f < 2e-3, "got $pow")
        report.check("pow(x<0) is NaN", DoughMath.pow(-1f, 2f).isNaN())
        report.check("pow10(3) ≈ 1000", abs(DoughMath.pow10(3f) - 1000f) / 1000f < 2e-3, "got ${DoughMath.pow10(3f)}")
        report.check("powHalf(1) ≈ 0.5", abs(DoughMath.powHalf(1f) - 0.5f) < 1e-3, "got ${DoughMath.powHalf(1f)}")

        var maxParSinErr = 0.0
        var maxSinFastErr = 0.0
        var t = -12.0
        while (t < 12.0) {
            maxParSinErr = max(maxParSinErr, abs(DoughMath.parSin(t.toFloat()) - sin(t)))
            maxSinFastErr = max(maxSinFastErr, abs(DoughMath.sinFast(t.toFloat()) - sin(t)))
            t += 0.001
        }
        // The parabola is a crude fit — ~5.6e-2 peak error is inherent to it, not a port defect.
        report.check("parSin within 6e-2 absolute", maxParSinErr < 6e-2, "max err %.2e".format(maxParSinErr))
        report.check("sinFast within 1e-4 absolute", maxSinFastErr < 1e-4, "max err %.2e".format(maxSinFastErr))
        report.check(
            "parCos is parSin shifted a quarter turn",
            abs(DoughMath.parCos(0f) - 1f) < 6e-2,
            "parCos(0) = ${DoughMath.parCos(0f)}"
        )

        report.check("ftz flushes denormals", DoughMath.ftz(1e-20f) == 0f && DoughMath.ftz(0.5f) == 0.5f)

        report.check("lerpCurve clamps endpoints", DoughMath.lerpCurve(-1f, 2f, 7f, 2f) == 2f && DoughMath.lerpCurve(2f, 2f, 7f, 2f) == 7f)
        val linear = DoughMath.lerpCurve(0.5f, 0f, 1f, 0f)
        val easeIn = DoughMath.lerpCurve(0.5f, 0f, 1f, 2f)
        val easeOut = DoughMath.lerpCurve(0.5f, 0f, 1f, -2f)
        report.check(
            "lerpCurve ease-in < linear < ease-out at midpoint",
            easeIn < linear && linear < easeOut,
            "easeIn=%.3f linear=%.3f easeOut=%.3f".format(easeIn, linear, easeOut)
        )
    }

    private fun checkPlateReverb(report: Reporter) {
        fun tail(decay: Float, mix: Float = 1f): Pair<FloatArray, FloatArray> =
            renderStereo(
                PlateReverb(
                    source = OneShotImpulse(),
                    decay = Param(decay),
                    mix = Param(mix)
                ),
                2f
            )

        val (l, r) = tail(0.85f)
        report.check("tail is finite", l.all { it.isFinite() } && r.all { it.isFinite() })
        report.check("tail is bounded", l.maxOf { abs(it) } < 10f, "peak=%.4f".format(l.maxOf { abs(it) }))

        val late = window(l, 0.5f, 1.0f)
        report.check("impulse produces a non-trivial late tail at 0.5–1.0 s", rms(late) > 1e-5f,
            "rms=%.3e".format(rms(late)))

        // Stereo must be decorrelated, not a copy: the tap sets differ per side.
        val correlation = correlation(window(l, 0.1f, 1.0f), window(r, 0.1f, 1.0f))
        report.check("left and right are decorrelated", abs(correlation) < 0.5f, "corr=%.3f".format(correlation))

        // Energy must decay over time and grow with the decay parameter.
        val early = rms(window(l, 0.05f, 0.25f))
        val later = rms(window(l, 1.0f, 1.5f))
        report.check("tail decays", later < early, "early=%.3e later=%.3e".format(early, later))

        val shortTail = rms(window(tail(0.3f).first, 0.5f, 1.0f))
        val longTail = rms(window(tail(0.9f).first, 0.5f, 1.0f))
        report.check("higher decay = longer tail", longTail > shortTail * 2f,
            "decay0.3=%.3e decay0.9=%.3e".format(shortTail, longTail))

        // mix = 0 must be exactly the dry impulse.
        val (dryL, dryR) = tail(0.85f, mix = 0f)
        report.check("mix=0 passes dry only", dryL[0] == 1f && dryL.drop(1).all { it == 0f } && dryR[0] == 1f)

        // Unscaled mode must also run clean (dough-identical tap lengths).
        val (unscaledL, _) = renderStereo(
            PlateReverb(source = OneShotImpulse(), mix = Param(1f), scaleToSampleRate = false),
            1f
        )
        report.check("scaleToSampleRate=false also produces a finite tail",
            unscaledL.all { it.isFinite() } && rms(window(unscaledL, 0.3f, 0.9f)) > 1e-6f)
    }

    private fun checkCurvedAdsr(report: Reporter) {
        val attack = 0.02f
        val decay = 0.05f
        val sustain = 0.6f
        val release = 0.1f

        val gate = Gate()
        val env = CurvedADSR(
            gate = gate,
            attack = Param(attack), decay = Param(decay),
            sustain = Param(sustain), release = Param(release)
        )

        // Gate on for 0.15 s, off for 0.03 s (mid-release), on again, then off.
        val ctx = SynthContext(SR, BLOCK)
        val buf = FloatArray(BLOCK)
        val trace = ArrayList<Float>()
        val blocksPerSecond = SR / BLOCK
        fun blocks(seconds: Float) = (seconds * blocksPerSecond).toInt()

        val schedule = listOf(
            true to blocks(0.15f),
            false to blocks(0.03f),
            true to blocks(0.15f),
            false to blocks(0.3f)
        )
        val gateDropBlock = schedule[0].second
        val retriggerBlock = schedule[0].second + schedule[1].second
        for ((open, count) in schedule) {
            if (open) gate.open() else gate.close()
            repeat(count) {
                env.render(buf, BLOCK, ctx)
                ctx.advanceCycle()
                for (i in 0 until BLOCK) trace += buf[i]
            }
        }

        val samples = trace.toFloatArray()
        report.check("envelope finite and in [0,1]", samples.all { it.isFinite() && it >= -1e-6f && it <= 1f + 1e-6f },
            "peak=%.4f".format(samples.maxOf { it }))

        val peak = samples.max()
        report.check("reaches full level after attack", peak > 0.99f, "peak=%.4f".format(peak))

        // Sustain plateau: sample just before the gate drops.
        val sustainLevel = samples[gateDropBlock * BLOCK - 1]
        report.check("holds at the sustain level", abs(sustainLevel - sustain) < 0.01f, "got %.4f".format(sustainLevel))

        report.check("returns to zero after release", samples.last() == 0f, "last=%.4f".format(samples.last()))

        // The distinguishing feature: no discontinuity anywhere, including the
        // retrigger part-way through the release segment.
        var maxJump = 0f
        var maxJumpAt = 0
        for (i in 1 until samples.size) {
            val jump = abs(samples[i] - samples[i - 1])
            if (jump > maxJump) { maxJump = jump; maxJumpAt = i }
        }
        report.check(
            "retriggers without a discontinuity",
            maxJump < 0.01f,
            "max jump %.5f at sample %d".format(maxJump, maxJumpAt)
        )

        // For contrast: the same gating through plain ADSR restarts from zero.
        val plainGate = Gate()
        val plain = ADSR(
            gate = plainGate,
            attack = Param(attack), decay = Param(decay),
            sustain = Param(sustain), release = Param(release)
        )
        val plainCtx = SynthContext(SR, BLOCK)
        val plainTrace = ArrayList<Float>()
        for ((open, count) in schedule) {
            if (open) plainGate.open() else plainGate.close()
            repeat(count) {
                plain.render(buf, BLOCK, plainCtx)
                plainCtx.advanceCycle()
                for (i in 0 until BLOCK) plainTrace += buf[i]
            }
        }
        val plainSamples = plainTrace.toFloatArray()
        var plainMaxJump = 0f
        for (i in 1 until plainSamples.size) {
            plainMaxJump = max(plainMaxJump, abs(plainSamples[i] - plainSamples[i - 1]))
        }
        println("       (for contrast, ADSR's max jump under the same gating: %.4f)".format(plainMaxJump))
    }

    private class Ramp : Signal() {
        private var v = -2.0
        override fun generate(output: FloatArray, numFrames: Int, ctx: SynthContext) {
            for (i in 0 until numFrames) {
                output[i] = v.toFloat()
                v += 4.0 / (SR * 0.05)
            }
        }
    }

    private fun renderMono(signal: Signal, seconds: Float): FloatArray {
        val ctx = SynthContext(SR, BLOCK)
        val total = (seconds * SR).toInt()
        val out = FloatArray(total)
        val buf = FloatArray(BLOCK)
        var written = 0
        while (written < total) {
            signal.render(buf, BLOCK, ctx)
            ctx.advanceCycle()
            val n = minOf(BLOCK, total - written)
            System.arraycopy(buf, 0, out, written, n)
            written += n
        }
        return out
    }

    private fun renderStereo(node: StereoRenderable, seconds: Float): Pair<FloatArray, FloatArray> {
        val ctx = SynthContext(SR, BLOCK)
        val total = (seconds * SR).toInt()
        val outL = FloatArray(total)
        val outR = FloatArray(total)
        val bufL = FloatArray(BLOCK)
        val bufR = FloatArray(BLOCK)
        var written = 0
        while (written < total) {
            node.render(bufL, bufR, BLOCK, ctx)
            ctx.advanceCycle()
            val n = minOf(BLOCK, total - written)
            System.arraycopy(bufL, 0, outL, written, n)
            System.arraycopy(bufR, 0, outR, written, n)
            written += n
        }
        return outL to outR
    }

    private fun window(samples: FloatArray, fromSeconds: Float, toSeconds: Float): FloatArray {
        val from = (fromSeconds * SR).toInt().coerceIn(0, samples.size)
        val to = (toSeconds * SR).toInt().coerceIn(from, samples.size)
        return samples.copyOfRange(from, to)
    }

    private fun rms(samples: FloatArray): Float {
        if (samples.isEmpty()) return 0f
        var sum = 0.0
        for (s in samples) sum += s.toDouble() * s
        return sqrt(sum / samples.size).toFloat()
    }

    private fun correlation(a: FloatArray, b: FloatArray): Float {
        val n = minOf(a.size, b.size)
        if (n == 0) return 0f
        var sumAB = 0.0; var sumAA = 0.0; var sumBB = 0.0
        for (i in 0 until n) {
            sumAB += a[i].toDouble() * b[i]
            sumAA += a[i].toDouble() * a[i]
            sumBB += b[i].toDouble() * b[i]
        }
        if (sumAA == 0.0 || sumBB == 0.0) return 0f
        return (sumAB / sqrt(sumAA * sumBB)).toFloat()
    }
}