@JvmStatic
    fun main(args: Array<String>) {
        Options.enableVR = false
        val window = Window("GPU Pressure Projection Probe")
        val renderer = Renderer(window)
        var failures = 0

        try {
            failures = gpuProbe(
                renderer,
                name = "pressure-chain",
                pump = { window.pollEvents(); renderer.render() },
            ) { probe ->
                run(probe)
            }
        } finally {
            renderer.cleanup()
            window.cleanup()
        }

        if (failures > 0) {
            println("gpu pressure projection chain FAILED ($failures)")
            exitProcess(1)
        }
        println("gpu pressure projection chain PASSED")
        exitProcess(0)
    }

    private fun run(probe: GpuProbe): Int {
        // --- fixtures. Every one of these is host-readable because `fixture` insists on it.
        val velocity = probe.fixture("velocity", FIELD_FLOATS)
        val velocityOut = probe.fixture("velocityOut", FIELD_FLOATS)
        val divergence = probe.fixture("divergence", FIELD_FLOATS)
        val pressureA = probe.fixture("pressureA", FIELD_FLOATS)
        val pressureB = probe.fixture("pressureB", FIELD_FLOATS)

        val seeded = seedField()
        probe.upload(velocity, seeded)
        probe.fill(pressureA, 0f)
        probe.fill(pressureB, 0f)

        // --- the chain. Three stages, three shader compiles, 1 + JACOBI + 1 dispatches.
        //
        // Stage order is registration order and dispatch order is insertion order, so this reads
        // as the pipeline it is. The ping-pong is explicit and visible: iteration `k` reads the
        // buffer iteration `k - 1` wrote, and because JACOBI is even the answer ends up back in
        // pressureA, which is what `project` binds.
        probe.stage("divergence", DIVERGENCE_GLSL).dispatch(groups = GROUPS) {
            bind("velocity") { velocity }
            bind("divergence") { divergence }
            bind("side") { N }
        }

        val jacobi = probe.stage("jacobi", JACOBI_GLSL)
        require(JACOBI % 2 == 0) { "JACOBI must be even so the result lands back in pressureA" }
        for (k in 0 until JACOBI) {
            val from = if (k % 2 == 0) pressureA else pressureB
            val to = if (k % 2 == 0) pressureB else pressureA
            jacobi.dispatch(groups = GROUPS, label = "sweep$k") {
                bind("pressureIn") { from }
                bind("pressureOut") { to }
                bind("divergence") { divergence }
                bind("side") { N }
            }
        }

        probe.stage("project", PROJECT_GLSL).dispatch(groups = GROUPS) {
            bind("velocity") { velocity }
            bind("pressure") { pressureA }
            bind("velocityOut") { velocityOut }
            bind("side") { N }
        }

        println(
            "--- chain: ${probe.stageList.size} stages, " +
                "${probe.stageList.sumOf { it.dispatchCount }} dispatches over $CELLS cells " +
                "(${N}x$N), $JACOBI Jacobi sweeps per frame"
        )

        // --- wait for the chain to exist at all. This is the wait that matters: a ComputeModule
        // whose shader has not finished compiling dispatches as a silent no-op, so the question is
        // "has the output been written", not "have four frames gone by".
        // The two graded outputs, and deliberately NOT the pressure pair.
        //
        // Arming `pressureA`/`pressureB` looks strictly better and is wrong, measured: it hung
        // for 1434 frames and then reported `9 of 16384 slots still hold the sentinel, from index
        // 908`. The Jacobi stencil is an average, and a constant is a fixed point of an average:
        // `(4 x -98765 - 0) / 4` is exactly `-98765`, so any interior cell whose four neighbours
        // are all still sentinel and whose divergence is exactly zero reproduces the sentinel
        // forever. A sentinel must not be a fixed point of the shader that is supposed to
        // overwrite it — witness the END of a chain, not an intermediate that is fed back into
        // itself.
        //
        // The Jacobi stage's execution is not left unwitnessed by this. A stage that never ran
        // leaves the pressure at zero, the projection returns its input, and three of the claims
        // below — the reduction, `extra sweeps helped` and `projection changed the field` — fail
        // together rather than quietly.
        probe.settle(velocityOut, divergence)
        val warmFrames = probe.framesToLand
        println("  cold start: landed after $warmFrames pumped frames (three shader compiles)")
        for (s in probe.stageList) {
            if (!s.valid) probe.fail("stage '${s.stageName}' never became valid")
        }

        // --- claim 1: the divergence pass, against the closed-form oracle, at every cell.
        val gpuDiv = probe.read(divergence)
        val cpuDiv = divergenceOf(seeded)
        var worstDivError = 0f
        var worstDivIndex = -1
        for (id in 0 until CELLS) {
            val e = abs(gpuDiv[id * 4] - cpuDiv[id])
            if (e > worstDivError) { worstDivError = e; worstDivIndex = id }
        }
        val maxDivBefore = maxAbs(cpuDiv)
        println(
            ("  divergence pass vs closed form: worst |error| %.3e at cell %d of %d; " +
                "field carries max |div| %.4f")
                .format(worstDivError, worstDivIndex, CELLS, maxDivBefore)
        )
        // Measured 1.192e-07 at cell 96, which is one ULP of a number of order 1 — the GLSL and
        // the Kotlin sum the same four terms in the same order, so the only difference available
        // is the compiler's contraction choice. 1e-6 is eight times the measurement, which leaves
        // room for a fused multiply-add on one side and not the other, and nothing else.
        probe.atMost(
            "divergence pass vs closed form", worstDivError, 1e-6f,
            buffer = "divergence", index = worstDivIndex
        )
        probe.allFinite("divergence pass", gpuDiv, buffer = "divergence")
        // The trivial-pass guard: a field of zeros would satisfy everything below. The fixture is
        // a fixed superposition computed on the CPU, so this is exactly reproducible — measured
        // 1.7649, and a floor of 1.5 fails the moment somebody edits `seedField` into something
        // flat rather than passing quietly on it.
        probe.atLeast("input field max |div|", maxDivBefore, 1.5f, buffer = "velocity")

        // --- claim 2: the sweep. Pressure re-zeroed each sample, so `frames x JACOBI` is the
        // whole iteration count and the curve is comparable point to point.
        println("  projected divergence against Jacobi sweeps (population: $CELLS cells each):")
        data class Sample(val frames: Int, val sweeps: Int, val after: Float, val ratio: Float)

        val samples = mutableListOf<Sample>()
        var lastProjected = FloatArray(0)
        for (frames in FRAME_SWEEP) {
            probe.idle()
            probe.fill(pressureA, 0f)
            probe.fill(pressureB, 0f)
            probe.arm(velocityOut, divergence)
            while (probe.stillWaiting()) probe.pumpFrames(1)
            val landed = probe.framesToLand
            if (frames > landed) probe.pumpFrames(frames - landed)
            val pumped = maxOf(frames, landed)
            probe.idle()

            val projected = probe.read(velocityOut)
            lastProjected = projected
            val after = maxAbs(divergenceOf(projected))
            val sweeps = pumped * JACOBI
            samples += Sample(pumped, sweeps, after, maxDivBefore / after)
            println(
                "    %2d frames = %4d sweeps : max |div| after %.5f   reduction %6.1fx".format(
                    pumped, sweeps, after, maxDivBefore / after
                )
            )
        }

        // Monotone, as a count rather than as a boolean, so a single non-monotone point is
        // distinguishable from a flat curve.
        var regressions = 0
        for (k in 1 until samples.size) {
            // 1.001 of slack: two adjacent points can agree to fp32 once converged.
            if (samples[k].after > samples[k - 1].after * 1.001f) regressions++
        }
        probe.exactly("sweep is monotone (non-monotone steps)", regressions, 0)
        val best = samples.last()
        val worst = samples.first()
        // Measured 2250.8x at 256 sweeps. Jacobi has no atomics and no race, the fixture is
        // fixed, and the frame count at this end of the sweep is exactly 16, so this number is
        // reproducible on a given GPU rather than approximately so. 1500 is a third below it; a
        // chain that lost a stage or a barrier reports single digits, not 1400.
        probe.atLeast(
            "reduction at ${best.sweeps} sweeps", best.ratio, 1500.0f, buffer = "velocityOut"
        )
        // And that the *extra* sweeps did something. A chain missing a barrier between Jacobi
        // iterations reads a stale pressure every time, so every sample comes back identical --
        // which passes a reduction floor and a monotonicity check but not this.
        //
        // Measured 533x. The floor is 100 rather than 400 because the *first* sample's population
        // is `max(1, framesToLand)`: on a contended GPU that can be 2 frames, which makes the
        // first point 32 sweeps instead of 16 and legitimately shrinks this ratio to about 286.
        // The sweep table prints the frame count for each point, so the population is visible.
        probe.atLeast(
            "extra sweeps helped (${worst.sweeps} -> ${best.sweeps})",
            worst.after / best.after, 100.0f
        )

        // --- claim 3: the projection moved the field, and left it finite.
        var worstMove = 0f
        for (i in 0 until FIELD_FLOATS) worstMove = maxOf(worstMove, abs(lastProjected[i] - seeded[i]))
        // Measured 1.434 against a field whose own max |div| is 1.765, i.e. the correction is the
        // same order as the thing being corrected. A floor of 1.0 is a real constraint; 0.1 would
        // have passed on a projection that barely touched the field.
        probe.atLeast("projection changed the field", worstMove, 1.0f, buffer = "velocityOut")
        probe.allFinite("projected field", lastProjected, buffer = "velocityOut")
        probe.varies("projected field", lastProjected, 1.2f, buffer = "velocityOut")

        // --- claim 4: the Jacobi stage directly, as a Poisson residual.
        val pressure = probe.read(pressureA)
        val residual = poissonResidual(pressure, cpuDiv)
        println(
            "  Poisson residual max |Lap p - div| = %.5f against max |div| %.4f (%.1f%%)".format(
                residual, maxDivBefore, 100f * residual / maxDivBefore
            )
        )
        // Measured 4.45e-04 of max |div| after 256 sweeps. 5e-3 is an order of magnitude above it
        // and still an order of magnitude below the 4.5e-2 that 64 sweeps would give, so this
        // claim can tell the sweep lengths apart rather than accepting any of them.
        probe.atMost("Poisson residual / max |div|", residual / maxDivBefore, 5e-3f, buffer = "pressureA")
        probe.allFinite("pressure", pressure, buffer = "pressureA")
        // Measured 11.91. The pressure field is the solution of a Poisson problem with an O(1)
        // right-hand side over 64 cells, so it is an order of magnitude larger than the velocity;
        // a floor of 8 catches a solve that collapsed to near-constant, which 0.05 would not.
        probe.varies("pressure", pressure, 8.0f, buffer = "pressureA")

        // --- and that the whole chain re-lands promptly once warm, which is the claim that the
        // sentinel mechanism is measuring something rather than being always true.
        //
        // Measured 1. It is structurally 1: `landed()` waits *every* compute fence for this
        // window, so one pumped frame is one completed chain no matter how many frames the
        // renderer keeps in flight. The bound is 2 rather than 1 only so a scheduling hiccup is
        // not a red test; a 3 here would mean the sentinel is surviving a completed frame, which
        // is a real finding and should fail.
        probe.atMost("frames to land once warm", probe.framesToLand, 2)

        return probe.verdict("gpu pressure projection chain")
    }
}