private fun checkOrientation(): Boolean {
        print("Orientation: four corner-marked splats... ")
        return guard {
            val size = 192
            val marks = listOf(
                Triple(-1f, 1f, "top-left") to floatArrayOf(1f, 0f, 0f),      // red
                Triple(1f, 1f, "top-right") to floatArrayOf(0f, 1f, 0f),      // green
                Triple(-1f, -1f, "bottom-left") to floatArrayOf(0f, 0f, 1f),  // blue
                Triple(1f, -1f, "bottom-right") to floatArrayOf(1f, 1f, 0f)   // yellow
            )
            val splats = marks.map { (where, color) ->
                splat(where.first, where.second, 0f, color, scale = 0.22f)
            }
            val file = File(testDir, "orientation.compressed.ply")
            CompressedSplatPlyFixture.write(file, splats)

            val view = SplatRaster.View.lookAt(
                eye = Vector3f(0f, 0f, 4f),
                target = Vector3f(0f, 0f, 0f),
                up = Vector3f(0f, 1f, 0f),
                width = size, height = size
            )
            val result = SplatRaster.rasterize(
                listOf(GaussianSplatRenderer.SplatSource(CompressedSplatPly.readRaw(file.absolutePath))),
                view
            )
            check(result.stats.drawn == 4) { "expected all four marks drawn, got ${result.stats}" }
            dump("orientation", result.image)

            val argb = result.image.toArgb()
            // The dominant hue of each quadrant, sampled well inside it.
            fun quadrant(left: Boolean, top: Boolean): String {
                val x = if (left) size / 4 else 3 * size / 4
                val y = if (top) size / 4 else 3 * size / 4
                var best = 0; var bestLum = -1
                for (dy in -12..12) for (dx in -12..12) {
                    val p = argb[(x + dx) + (y + dy) * size]
                    val lum = ((p shr 16) and 255) + ((p shr 8) and 255) + (p and 255)
                    if (lum > bestLum) { bestLum = lum; best = p }
                }
                val r = (best shr 16) and 255
                val g = (best shr 8) and 255
                val b = best and 255
                check(bestLum > 60) {
                    "quadrant left=$left top=$top is empty (brightest sum $bestLum) — a mark is missing"
                }
                return when {
                    r > 96 && g > 96 && b < 64 -> "yellow"
                    r > 96 && g < 64 && b < 64 -> "red"
                    g > 96 && r < 64 && b < 64 -> "green"
                    b > 96 && r < 64 && g < 64 -> "blue"
                    else -> "muddled($r,$g,$b)"
                }
            }

            val topLeft = quadrant(left = true, top = true)
            val topRight = quadrant(left = false, top = true)
            val bottomLeft = quadrant(left = true, top = false)
            val bottomRight = quadrant(left = false, top = false)
            check(topLeft == "red") { "top-left should be red (world -x +y), got $topLeft" }
            check(topRight == "green") { "top-right should be green (world +x +y), got $topRight" }
            check(bottomLeft == "blue") { "bottom-left should be blue (world -x -y), got $bottomLeft" }
            check(bottomRight == "yellow") { "bottom-right should be yellow (world +x -y), got $bottomRight" }
            "TL=$topLeft TR=$topRight BL=$bottomLeft BR=$bottomRight"
        }
    }

    private fun checkKnownPixel(): Boolean {
        print("A known splat at a known pixel and colour... ")
        return guard {
            val size = 128
            val color = floatArrayOf(1f, 0.25f, 0.5f)
            val file = File(testDir, "known.compressed.ply")
            // A single splat means a chunk whose min equals its max, so the colour and position
            // quantize exactly and the expected values below are not approximations.
            CompressedSplatPlyFixture.write(file, listOf(splat(0.5f, 0.25f, 0f, color, scale = 0.4f)))

            val view = SplatRaster.View.lookAt(
                eye = Vector3f(0f, 0f, 4f), target = Vector3f(0f, 0f, 0f),
                width = size, height = size
            )
            val result = SplatRaster.rasterize(
                listOf(GaussianSplatRenderer.SplatSource(CompressedSplatPly.readRaw(file.absolutePath))),
                view
            )
            check(result.stats.drawn == 1) { "expected one splat drawn, got ${result.stats}" }
            dump("known_pixel", result.image)
            val argb = result.image.toArgb()

            // Centroid of the coverage, weighted by the un-quantized linear alpha.
            var weight = 0.0
            var colSum = 0.0
            var rowSum = 0.0
            for (row in 0 until size) for (col in 0 until size) {
                val alpha = result.image.linear[(col + row * size) * 4 + 3].toDouble()
                weight += alpha
                colSum += alpha * col
                rowSum += alpha * row
            }
            check(weight > 0.0) { "the splat left no coverage at all" }
            val col = colSum / weight
            val row = rowSum / weight
            check(abs(col - 80.656) < 0.25 && abs(row - 54.922) < 0.25) {
                "energy centred on column %.3f row %.3f; the projection says column 80.656 row 54.922"
                    .format(col, row)
            }
            // The argmax is still worth a look, because a peak far from the centroid would mean the
            // Gaussian is lopsided even though its centre of mass is right.
            var brightestAt = -1
            var brightest = -1
            for (pixel in argb.indices) {
                val p = argb[pixel]
                val lum = ((p shr 16) and 255) + ((p shr 8) and 255) + (p and 255)
                if (lum > brightest) { brightest = lum; brightestAt = pixel }
            }
            check(abs(brightestAt % size - col) < 2.0 && abs(brightestAt / size - row) < 2.0) {
                "the brightest pixel (${brightestAt % size}, ${brightestAt / size}) is more than two " +
                    "pixels from the centroid (%.2f, %.2f), so the Gaussian is lopsided".format(col, row)
            }

            // The colour pipeline end to end: the file's linear 0..1 colour, decoded by colorGamma
            // 2.2 into the linear space the GPU blends in, composited premultiplied over black, and
            // sRGB-encoded on the way out exactly as a _SRGB framebuffer would encode it.
            val expected = IntArray(3) { channel ->
                (SplatRaster.linearToSrgb(color[channel].pow(2.2f)) * 255f + 0.5f).toInt()
            }
            val peak = argb[brightestAt]
            val got = intArrayOf((peak shr 16) and 255, (peak shr 8) and 255, peak and 255)
            check(expected[0] == 255) { "a colour of 1.0 must saturate, expected 255 got ${expected[0]}" }
            for (channel in 0..2) {
                // 2 code values of slack for the sub-pixel offset between the Gaussian's peak and the
                // centre of the pixel that samples it; the channels are 255/61/128 apart, so this
                // cannot absorb a channel swap or a missing gamma.
                check(abs(got[channel] - expected[channel]) <= 2) {
                    "channel $channel: expected ${expected[channel]} +/-2, got ${got[channel]} " +
                        "(all channels expected ${expected.joinToString()}, got ${got.joinToString()})"
                }
            }
            // Pin the digits, not just the agreement with a formula that could itself be wrong.
            check(expected.toList() == listOf(255, 61, 128)) {
                "the gamma pipeline moved: (1.0, 0.25, 0.5) should encode to (255, 61, 128), " +
                    "got ${expected.joinToString()}"
            }
            "centroid column %.3f row %.3f (expected 80.656, 54.922), sRGB ".format(col, row) +
                got.joinToString()
        }
    }

    private fun checkSlotSensitivity(): Boolean {
        print("Slot sensitivity: 13 floats must matter, 3 must not... ")
        return guard {
            val size = 96
            val file = File(testDir, "sensitivity.compressed.ply")
            CompressedSplatPlyFixture.write(
                file,
                (0 until 40).map { index ->
                    val t = index / 40f
                    splat(
                        (t - 0.5f) * 1.4f, ((index % 7) / 7f - 0.5f) * 1.2f, (index % 5) * 0.12f,
                        floatArrayOf(0.9f - t * 0.5f, 0.3f + t * 0.5f, 0.6f), scale = 0.15f
                    )
                }
            )
            val raw = CompressedSplatPly.readRaw(file.absolutePath)
            val view = SplatRaster.View.lookAt(
                eye = Vector3f(0f, 0f, 3.2f), target = Vector3f(0f, 0f, 0f),
                width = size, height = size
            )

            val baselineBuffer = SplatRaster.allocatePacked(raw.count)
            GaussianSplatRenderer.packInto(raw, baselineBuffer)
            val baseline = SplatRaster.rasterize(baselineBuffer, raw.count, view).image.toArgb()
            check(baseline.any { (it and 0xffffff) != 0 }) { "the baseline image is blank" }

            // Which splat to poke. One in the middle of the cloud, so it is neither clipped nor
            // hidden: slot 3 (alpha) has to be able to make a visible difference.
            val target = raw.count / 2
            val inert = setOf(GaussianSplatRenderer.SPLAT_SOURCE_FLOAT, 14, 15)
            val moved = mutableListOf<Int>()
            val still = mutableListOf<Int>()

            for (slot in 0 until STRIDE) {
                val probe = SplatRaster.allocatePacked(raw.count)
                GaussianSplatRenderer.packInto(raw, probe)
                val at = target * STRIDE + slot
                val was = probe.get(at)
                // A perturbation big enough to be unmistakable but not so big it moves the splat out
                // of frame, where "the image changed" would be true for the wrong reason.
                probe.put(at, if (slot == 3) 0.05f else was + 0.35f * max(1f, abs(was)))
                val after = SplatRaster.rasterize(probe, raw.count, view).image.toArgb()
                var differing = 0
                for (pixel in baseline.indices) if (baseline[pixel] != after[pixel]) differing++
                if (differing > 0) moved += slot else still += slot
            }

            check(still.toSet() == inert) {
                "slots the rasterizer ignores should be exactly $inert " +
                    "(the source index and the two padding floats), but they are $still; " +
                    "moved = $moved"
            }
            check(moved.size == 13) { "expected 13 load-bearing slots, got ${moved.size}: $moved" }
            "13 load-bearing (${moved.joinToString()}), 3 inert (${still.joinToString()})"
        }
    }

    private fun checkPackPathAgreement(): Boolean {
        print("pack vs packInto, in pixels... ")
        return guard {
            val size = 160
            val file = File(testDir, "agreement.compressed.ply")
            CompressedSplatPlyFixture.write(file, syntheticCloud(1200))

            val table = readCompressedSplatPly(file.absolutePath)
            val reference = GaussianSplatRenderer.pack(table)
            val raw = CompressedSplatPly.readRaw(file.absolutePath)
            val fused = SplatRaster.allocatePacked(raw.count)
            GaussianSplatRenderer.packInto(raw, fused)

            val view = SplatRaster.View.lookAt(
                eye = Vector3f(0.6f, 0.4f, 3.4f), target = Vector3f(0f, 0f, 0f),
                width = size, height = size
            )
            val fromTable = SplatRaster.rasterize(
                FloatBuffer.wrap(reference.floats), reference.count, view
            )
            val fromFused = SplatRaster.rasterize(fused, raw.count, view)
            check(fromTable.stats.drawn == fromFused.stats.drawn) {
                "the two paths drew different numbers of splats: " +
                    "${fromTable.stats.drawn} from pack, ${fromFused.stats.drawn} from packInto"
            }
            dump("agreement_fused", fromFused.image)

            val a = fromTable.image.toArgb()
            val b = fromFused.image.toArgb()
            var identical = 0
            var worst = 0
            for (pixel in a.indices) {
                if (a[pixel] == b[pixel]) { identical++; continue }
                for (shift in intArrayOf(16, 8, 0)) {
                    val delta = abs(((a[pixel] shr shift) and 255) - ((b[pixel] shr shift) and 255))
                    if (delta > worst) worst = delta
                }
            }
            val agreement = identical * 100.0 / a.size
            // These two floors are the point of the test, and they sit next to the measured figure
            // rather than a comfortable distance below it: this comparison actually returns 100.000%
            // identical with a worst channel delta of 0, because the two paths' ~3e-5 relative
            // disagreement is an order of magnitude under an 8-bit code value.
            //
            // The first version of this floor was 99.9%, and the negative control below rejected it:
            // moving a single splat of 1200 by 0.01 leaves 99.938% of pixels identical with a worst
            // delta of 1, which 99.9% and "delta <= 1" both admit. A floor that a real perturbation
            // passes is not a floor. AGREEMENT_FLOOR is 99.99% — about two pixels of this image, so
            // still room for a differently-rounding FMA on another platform, and nowhere near room
            // for one splat in the wrong place.
            check(agreement >= AGREEMENT_FLOOR) {
                "only %.3f%% of pixels identical between the pack paths, expected >= %s%%"
                    .format(agreement, AGREEMENT_FLOOR)
            }
            check(worst <= WORST_DELTA_CEILING) {
                "a channel differs by $worst code values between the pack paths, " +
                    "expected <= $WORST_DELTA_CEILING"
            }
            check(fromFused.stats.drawn > 500) {
                "only ${fromFused.stats.drawn} splats drawn of ${raw.count}; the view is nearly empty, " +
                    "so this comparison would agree vacuously"
            }
            // The other half of the claim: the comparison can tell when the clouds DIFFER. Move one
            // splat of 1200 by a hundredth of a unit and require both floors to reject it.
            //
            // Without this, "100.000% identical" is unfalsifiable — a comparison that always returns
            // 100% would produce exactly the same reassuring line. This is the cheapest possible
            // version of breaking your own oracle and watching it go red, and it runs every time
            // rather than once, in a terminal, by an agent who then wrote down that it had.
            val sabotaged = SplatRaster.allocatePacked(raw.count)
            GaussianSplatRenderer.packInto(raw, sabotaged)
            val victim = raw.count / 3
            sabotaged.put(victim * STRIDE, sabotaged.get(victim * STRIDE) + 0.01f)
            val damaged = SplatRaster.rasterize(sabotaged, raw.count, view).image.toArgb()
            var stillIdentical = 0
            var damagedWorst = 0
            for (pixel in a.indices) {
                if (b[pixel] == damaged[pixel]) { stillIdentical++; continue }
                for (shift in intArrayOf(16, 8, 0)) {
                    val delta = abs(((b[pixel] shr shift) and 255) - ((damaged[pixel] shr shift) and 255))
                    if (delta > damagedWorst) damagedWorst = delta
                }
            }
            val damagedAgreement = stillIdentical * 100.0 / a.size
            // Deliberately re-uses the *same* two constants the positive assertion above uses, so the
            // floors cannot be loosened without this control noticing.
            check(damagedAgreement < AGREEMENT_FLOOR || damagedWorst > WORST_DELTA_CEILING) {
                "moving one splat of ${raw.count} by 0.01 left the comparison reporting " +
                    "%.3f%% identical with a worst delta of $damagedWorst — both inside the floors this "
                        .format(damagedAgreement) +
                    "test passes on ($AGREEMENT_FLOOR%%, $WORST_DELTA_CEILING), so those floors " +
                    "would not catch a real regression either"
            }

            "%.3f%% of ${a.size} pixels identical, worst channel delta $worst; ".format(agreement) +
                "one splat moved by 0.01 drops that to %.3f%% at delta $damagedWorst; "
                    .format(damagedAgreement) +
                "${fromFused.stats.drawn} splats drawn, ${fromFused.image.stats()}"
        }
    }

    private fun checkPoisonDetection(): Boolean {
        print("Poisoned clouds are counted, clean ones are not... ")
        return guard {
            val size = 96
            val file = File(testDir, "poison.compressed.ply")
            CompressedSplatPlyFixture.write(file, syntheticCloud(300))
            val raw = CompressedSplatPly.readRaw(file.absolutePath)
            val view = SplatRaster.View.lookAt(
                eye = Vector3f(0f, 0f, 3.4f), target = Vector3f(0f, 0f, 0f),
                width = size, height = size
            )

            val clean = SplatRaster.allocatePacked(raw.count)
            GaussianSplatRenderer.packInto(raw, clean)
            val cleanStats = SplatRaster.rasterize(clean, raw.count, view).stats
            check(cleanStats.nonFinite == 0) {
                "a clean cloud reported ${cleanStats.nonFinite} non-finite splats; the detector fires " +
                    "on good data, so it proves nothing about bad data"
            }
            check(cleanStats.drawn > 100) { "clean cloud drew only ${cleanStats.drawn}; too empty to test" }

            // Position, colour and covariance in turn: three NaNs each, in disjoint splats.
            val poisonedSlots = listOf(0 to "position x", 5 to "colour green", 12 to "covariance yz")
            val report = StringBuilder()
            for ((slot, label) in poisonedSlots) {
                val probe = SplatRaster.allocatePacked(raw.count)
                GaussianSplatRenderer.packInto(raw, probe)
                val victims = listOf(3, 17, 41, 88, 199)
                for (victim in victims) probe.put(victim * STRIDE + slot, Float.NaN)
                val stats = SplatRaster.rasterize(probe, raw.count, view).stats
                check(stats.nonFinite == victims.size) {
                    "poisoning $label in ${victims.size} splats was counted as ${stats.nonFinite}"
                }
                stats.check()
                report.append("$label ok; ")
            }

            // An infinity is the other way this goes wrong, and it is worse: an infinite covariance
            // produces an infinite screen radius, which after the maxScreenRadius clamp looks
            // entirely reasonable. It must be caught as bad data, not clamped into plausibility.
            val infinite = SplatRaster.allocatePacked(raw.count)
            GaussianSplatRenderer.packInto(raw, infinite)
            infinite.put(7 * STRIDE + 8, Float.POSITIVE_INFINITY)
            val infiniteStats = SplatRaster.rasterize(infinite, raw.count, view).stats
            check(infiniteStats.nonFinite == 1) {
                "an infinite covariance was counted as ${infiniteStats.nonFinite} non-finite, expected 1"
            }
            "clean 0 non-finite over ${cleanStats.drawn} drawn; ${report}infinity ok"
        }
    }

    private fun checkSortOrder(): Boolean {
        print("A sortAlong pack is drawable in buffer order... ")
        return guard {
            val size = 128
            val file = File(testDir, "sorted.compressed.ply")
            // Overlapping, semi-transparent and spread in depth, which is the only arrangement where
            // compositing order shows up at all.
            //
            // z oscillates with the index rather than ramping with it. The first version of this test
            // ramped z, and the fixture does not Morton-sort, so file order *was* depth order and the
            // "unsorted" control agreed with the sorted render to 0.000 — the test passed its first
            // assertion while its own control proved nothing. Hence the second assertion below.
            CompressedSplatPlyFixture.write(
                file,
                (0 until 700).map { index ->
                    val t = index / 700f
                    splat(
                        (kotlin.math.sin(index * 2.4) * 0.5).toFloat(),
                        (kotlin.math.cos(index * 1.7) * 0.5).toFloat(),
                        (kotlin.math.sin(index * 0.9) * 0.9).toFloat(),
                        floatArrayOf(t, 0.4f, 1f - t),
                        scale = 0.2f,
                        opacityLogit = -0.4f
                    )
                }
            )
            val raw = CompressedSplatPly.readRaw(file.absolutePath)
            val view = SplatRaster.View.lookAt(
                eye = Vector3f(0f, 0f, 3f), target = Vector3f(0f, 0f, 0f),
                width = size, height = size
            )
            val bufferOrder = SplatRaster.RasterConfig(depthOrder = SplatRaster.DepthOrder.BufferOrder)

            // The camera looks down -z from +z, so the far splats are at -z: sort along -z... the
            // renderer wants farthest first, and packInto writes descending along sortAlong, so the
            // direction that puts far splats first is the camera's view direction.
            val sorted = SplatRaster.allocatePacked(raw.count)
            GaussianSplatRenderer.packInto(
                raw, sorted, sortAlong = Vector3f(0f, 0f, -1f)
            )
            val unsorted = SplatRaster.allocatePacked(raw.count)
            GaussianSplatRenderer.packInto(raw, unsorted)

            val truth = SplatRaster.rasterize(unsorted, raw.count, view).image.toArgb()
            val packSorted = SplatRaster.rasterize(sorted, raw.count, view, bufferOrder).image.toArgb()
            val naive = SplatRaster.rasterize(unsorted, raw.count, view, bufferOrder).image.toArgb()

            fun meanAbsDelta(a: IntArray, b: IntArray): Double {
                var sum = 0L
                for (pixel in a.indices) for (shift in intArrayOf(16, 8, 0)) {
                    sum += abs(((a[pixel] shr shift) and 255) - ((b[pixel] shr shift) and 255))
                }
                return sum.toDouble() / (a.size * 3)
            }
            val sortedError = meanAbsDelta(truth, packSorted)
            val naiveError = meanAbsDelta(truth, naive)
            check(sortedError < 0.5) {
                "a sortAlong pack drawn in buffer order differs from a depth sort by " +
                    "%.3f code values per channel, expected < 0.5".format(sortedError)
            }
            check(naiveError > 4.0 * max(sortedError, 0.01)) {
                "the unsorted pack is only %.3f off against the sorted pack's %.3f, so this test is "
                    .format(naiveError, sortedError) +
                    "not distinguishing an order that works from one that does not"
            }
            "sortAlong %.4f vs unsorted %.4f code values per channel".format(sortedError, naiveError)
        }
    }

    private fun checkStatsAccounting(): Boolean {
        print("Every splat accounted for exactly once... ")
        return guard {
            val file = File(testDir, "accounting.compressed.ply")
            CompressedSplatPlyFixture.write(file, syntheticCloud(400))
            val raw = CompressedSplatPly.readRaw(file.absolutePath)
            val packed = SplatRaster.allocatePacked(raw.count)
            GaussianSplatRenderer.packInto(raw, packed)

            val notes = mutableListOf<String>()
            // In frame, entirely behind the camera, and 900 units away. The last one still draws
            // every splat, and that is correct rather than a cull: `minScreenRadius` floors a splat
            // at 0.75 px precisely so a distant cloud does not evaporate. Noted here because "very
            // far, so it must be culled" is the wrong intuition to leave lying around.
            for ((label, view) in listOf(
                "in frame" to SplatRaster.View.lookAt(
                    eye = Vector3f(0f, 0f, 3f), target = Vector3f(0f, 0f, 0f), width = 64, height = 64
                ),
                "behind" to SplatRaster.View.lookAt(
                    eye = Vector3f(0f, 0f, 3f), target = Vector3f(0f, 0f, 9f), width = 64, height = 64
                ),
                "900 units off, floored at minScreenRadius" to SplatRaster.View.lookAt(
                    eye = Vector3f(0f, 0f, 900f), target = Vector3f(0f, 0f, 0f), width = 64, height = 64
                )
            )) {
                val stats = SplatRaster.rasterize(packed, raw.count, view).stats
                stats.check()
                check(stats.considered == raw.count) { "$label considered ${stats.considered}" }
                notes += "$label ${stats.drawn} drawn"
            }
            val behind = SplatRaster.rasterize(
                packed, raw.count,
                SplatRaster.View.lookAt(
                    eye = Vector3f(0f, 0f, 3f), target = Vector3f(0f, 0f, 9f), width = 64, height = 64
                )
            ).stats
            check(behind.culledBehind == raw.count) {
                "looking away should put all ${raw.count} splats behind the camera, got ${behind.culledBehind}"
            }
            notes.joinToString(", ")
        }
    }