@JvmStatic
    fun main(args: Array<String>) {
        val keepOpen = args.contains("--keep")
        Options.enableVR = false
        Options.doVulkanSDK()

        outputDir.mkdirs()
        val window = Window("Field · Fabricate summarised quadtrees")
        val renderer = Renderer(window)

        // Same reason as the other two chain demos: StandardRenderer.build allocates targets through
        // a bare `RenderToTexture { … }`, whose renderer defaults to `fromContext()`, so it needs a
        // box context or the failure is an NPE from inside the RTT constructor.
        val hostBox = Box("fabricate-quadtree-chain-demo").apply { name = "fabricate-quadtree-chain-demo" }
        hostBox.setPropertyRaw("renderer", renderer, doResync = false)
        hostBox.setPropertyRaw("window", window, doResync = false)

        try {
            Box.withBoxContextNow(hostBox) { run(renderer, window) }
            if (keepOpen) {
                println("-- --keep: leaving the window open, close it to exit --")
                while (!window.shouldClose()) pump(renderer, window, 1)
            }
        } catch (t: Throwable) {
            println("FAIL: ${t.message}")
            t.printStackTrace()
            failures++
        } finally {
            runCatching { renderer.cleanup() }
            runCatching { window.cleanup() }
        }

        if (failures == 0) {
            println("quadtree chain tests PASSED — figures in ${outputDir.absolutePath}")
        } else {
            println("quadtree chain tests FAILED ($failures)")
        }
        exitProcess(if (failures == 0) 0 else 1)
    }

    private fun run(renderer: Renderer, window: Window) {
        val bundle = StandardRenderer.build(
            renderer,
            StandardRenderer.Config(
                renderWidth = DIM,
                renderHeight = DIM,
                backgroundColor = Vector3f(0.04f, 0.05f, 0.07f)
            )
        )
        bundle.applyScenePlan()
        bundle.present(renderer = renderer)
        bundle.attachTo(renderer)
        pump(renderer, window, WARMUP_FRAMES)

        val ramp = bundle.addPassChain(rampChain(), renderer = renderer, printReport = true)
        // The A/B: the same field, the same gain, the same readout pass, differing only in how the
        // value statistics merge on the way up.
        val pooled = bundle.addPassChain(flatChain("flat", SummaryStatistics.POOLED), renderer = renderer)
        val raw = bundle.addPassChain(flatChain("rawflat", SummaryStatistics.RAW_MOMENTS), renderer = renderer)
        val grid = bundle.addPassChain(gridPointChain(), renderer = renderer, printReport = true)
        val cloud = bundle.addPassChain(cloudChain(), renderer = renderer)

        // Every capture below names a pass by its prefix and depth rather than carrying a chain
        // around: the whole point of the naming scheme is that `ramp-value-2` says which producer,
        // which plane and which level, and a reader of an assertion should not have to also know
        // which `addPassChain` call it came out of.
        chainsByPrefix["ramp"] = ramp
        chainsByPrefix["flat"] = pooled
        chainsByPrefix["rawflat"] = raw
        chainsByPrefix["grid"] = grid
        chainsByPrefix["cloud"] = cloud
        chainsByPrefix["cloudfield"] = cloud

        bundle.present(renderer = renderer)
        bundle.attachTo(renderer)
        pump(renderer, window, WARMUP_FRAMES)

        guard("the pyramid planned one complete quadtree per plane, and the levels share targets") {
            val leaf = GRID_DEPTH
            FabricatePassLibrary.SUMMARY_PLANES.forEach { plane ->
                (leaf downTo 0).forEach { depth ->
                    val name = FabricatePassLibrary.summaryPlane("ramp", plane, depth)
                    val target = ramp.targetOf(name) ?: error("$name was not built")
                    require(target.width == 1 shl depth && target.height == 1 shl depth) {
                        "$name is ${target.width}x${target.height}, not ${1 shl depth}²"
                    }
                }
            }
            require(ramp.plan.targetCount < ramp.plan.passCount) {
                "the pyramid planned ${ramp.plan.targetCount} targets for ${ramp.plan.passCount} passes — " +
                        "nothing shared, which for a chain of dead intermediates means the lifetimes are wrong"
            }
            "${ramp.plan.passCount} passes on ${ramp.plan.targetCount} targets, " +
                    "${"%.2f".format(ramp.plan.naiveBytes.toDouble() / ramp.plan.plannedBytes)}x against " +
                    "one full-resolution target per pass"
        }

        // --- the two pyramids against the closed form ---

        val rampRoot = planes(renderer, "ramp", 0, "01-ramp-root")
        val rampMid = planes(renderer, "ramp", 2, "02-ramp-depth2")
        val gridRoot = planes(renderer, "grid", 0, "10-grid-root")
        val gridMid = planes(renderer, "grid", 2, "11-grid-depth2")

        guard("the root cell's weight, mean and moments are the closed form of the whole image") {
            checkCell(rampRoot, 0, 0, cell = 0, side = GRID, label = "raster root")
            checkCell(gridRoot, 0, 0, cell = 0, side = GRID, label = "point root")
            "raster root " + describe(rampRoot, 0, 0) + "; point root " + describe(gridRoot, 0, 0)
        }

        guard("every cell at depth 2 is the closed form of its own quarter, not of the image") {
            // The level that catches a reduction reading the wrong child, which the root cannot: at
            // the root every wrong tree of reductions still averages the same 256 texels.
            val side = GRID shr 2
            (0 until 4).forEach { cy ->
                (0 until 4).forEach { cx ->
                    checkCell(rampMid, cx, cy, cell = cx, side = side, label = "cell ($cx, $cy)", cellY = cy)
                }
            }
            "16 cells of $side² texels each agree with the closed form; " + describe(rampMid, 1, 2)
        }

        guard("the value variance is the variance of a ramp, at two depths") {
            val rootVariance = plane(renderer, ramp, "ramp-variance-0", "03-ramp-variance-root")
            val exactRoot = (RAMP_AMP * RAMP_AMP).toDouble() * spatialVariance(GRID, GRID)
            codeEquals("root variance", rootVariance.linear(0, 0, 0), exactRoot * RAMP_ROOT_VARIANCE_GAIN, 0)

            val midVariance = plane(renderer, ramp, "ramp-variance-2", "04-ramp-variance-depth2")
            val exactMid = (RAMP_AMP * RAMP_AMP).toDouble() * spatialVariance(GRID shr 2, GRID)
            (0 until 4).forEach { cx ->
                codeEquals("depth-2 variance at ($cx, 1)", midVariance.linear(cx, 1, 0), exactMid * RAMP_MID_VARIANCE_GAIN, 0)
            }
            "root ${"%.6f".format(exactRoot)} and depth-2 ${"%.6f".format(exactMid)}, both within " +
                    "$CHANNEL_CODE_TOLERANCE codes of the closed form"
        }

        guard("the pooled merge keeps a spread the raw moments cannot, on the same field in one run") {
            val exact = (FLAT_AMP * FLAT_AMP).toDouble() * spatialVariance(GRID, GRID)
            val expected = exact * FLAT_VARIANCE_GAIN
            val pooledRoot = plane(renderer, pooled, "flat-variance-0", "05-flat-variance-pooled")
            val rawRoot = plane(renderer, raw, "rawflat-variance-0", "06-flat-variance-raw")
            val measuredPooled = pooledRoot.linear(0, 0, 0)
            val measuredRaw = rawRoot.linear(0, 0, 0)
            codeEquals("pooled root variance", measuredPooled, expected, 0)
            // Not "the raw form is bad" as an opinion: at this amplitude the subtraction has no
            // digits left, so its answer has to be *outside* the readback's own resolution of the
            // right one. If this ever starts passing, fp32 got wider or the field got louder.
            val rawError = abs(measuredRaw - expected)
            require(rawError > 8.0 * codeStep(expected)) {
                "the raw-moment form returned ${"%.4f".format(measuredRaw)} against an exact " +
                        "${"%.4f".format(expected)}, which is inside the instrument's own noise — the A/B " +
                        "is not separating the two representations any more, so either the amplitude is " +
                        "too loud to cancel or the raw path is no longer raw"
            }
            "exact ${"%.4f".format(expected)} (gain ${FLAT_VARIANCE_GAIN.toLong()}): pooled " +
                    "${"%.4f".format(measuredPooled)}, raw moments ${"%.4f".format(measuredRaw)}"
        }

        // --- the point pipeline ---

        val codes = plane(renderer, grid, "grid-code", "07-grid-codes")
        val sorted = plane(renderer, grid, "grid-sorted", "08-grid-sorted")

        guard("the gather filled every slot exactly once — the sort is a permutation") {
            // The gather writes alpha 1 only where it found an element for its slot. Alpha comes back
            // *linearly* through the readback (an sRGB format encodes rgb and leaves a alone), so
            // this is an exact count and not a thresholded one.
            val holes = (0 until sorted.height).sumOf { y ->
                (0 until sorted.width).count { x -> sorted.code(x, y, ALPHA) < 255 }
            }
            require(holes == 0) {
                "$holes of ${GRID_POINTS} slots were never written — the rank is not a bijection, which " +
                        "is what a rank computed without the index tie-break does the moment two points " +
                        "share a leaf cell"
            }
            "all $GRID_POINTS slots written once"
        }

        guard("the keys come out of the sort in order, and went in out of order") {
            // Order is one of the few things an 8-bit sRGB encoding preserves exactly, because the
            // curve is monotonic. So this is an exact check on a quantised measurement.
            val after = keysInRasterOrder(sorted)
            val before = keysInRasterOrder(codes)
            val descents = (1 until after.size).count { after[it] < after[it - 1] }
            require(descents == 0) { "$descents of ${after.size - 1} adjacent sorted keys descend" }
            val scrambled = (1 until before.size).count { before[it] < before[it - 1] }
            require(scrambled > 0) {
                "the Morton codes were already in raster order before the sort, so this run proves " +
                        "nothing about the sort — the point set has become one the interleave does not reorder"
            }
            "sorted: 0 descents in ${after.size - 1} steps; unsorted: $scrambled"
        }

        val gridRange = plane(renderer, grid, FabricatePassLibrary.summaryPlane("grid", FabricatePassLibrary.SUMMARY_RANGE, 0), "09-grid-range-root")

        guard("the root node's range is the whole array, which is what makes every node's range contiguous") {
            // `(first, count)` reduced by (min, sum) up the tree. The root's count being exactly N is
            // the arithmetic statement that the leaf ranges tile the sorted array — four adjacent
            // Morton ranges concatenating into one is the property the whole scheme rests on, and the
            // root is where a gap or an overlap would show as a count that is not N.
            require(gridRange.code(0, 0, 0) == 0) {
                "the root range starts at code ${gridRange.code(0, 0, 0)}, not 0"
            }
            require(gridRange.code(0, 0, 1) == 255) {
                "the root range holds ${gridRange.code(0, 0, 1)}/255 of the array — the leaf ranges do " +
                        "not tile it, so some points are summarised twice and others not at all"
            }
            "root range = [0, $GRID_POINTS)"
        }

        // --- the two producers, on one distribution ---

        guard("the point quadtree agrees with the same closed form, to the same tolerance, unscaled") {
            // The *same* expectations as the raster, with no conversion factor anywhere: a node's
            // weight is its density against a uniform spread, and this set is one point per texel, so
            // a uniformly weighted cell has density exactly 1 — which is also the raster's mean
            // coverage. Two pipelines sharing nothing below the reduction ladder, landing on the same
            // numbers.
            val side = GRID shr 2
            (0 until 4).forEach { cy ->
                (0 until 4).forEach { cx ->
                    checkCell(gridMid, cx, cy, cell = cx, side = side, label = "node ($cx, $cy)", cellY = cy)
                }
            }
            "16 nodes of ${side * side} points each against the raster's own closed form, " +
                    describe(gridMid, 1, 2)
        }

        guard("the centroid and the covariance the two producers report are the same numbers") {
            // The statistic-level comparison rather than the channel-level one above, and the one the
            // unification claim is actually about: two pipelines with nothing in common below the
            // reduction ladder, asked for the same distribution's shape.
            var worstCentroid = 0.0
            var worstChannel = 0
            (0 until 4).forEach { cy ->
                (0 until 4).forEach { cx ->
                    val a = shapeOf(rampMid, cx, cy)
                    val b = shapeOf(gridMid, cx, cy)
                    worstCentroid = maxOf(worstCentroid, hypot(a.centroidU - b.centroidU, a.centroidV - b.centroidV))
                    (0..3).forEach { channel ->
                        listOf(rampMid.value to gridMid.value, rampMid.moment to gridMid.moment, rampMid.extent to gridMid.extent)
                            .forEach { (one, other) ->
                                worstChannel = maxOf(worstChannel, abs(one.code(cx, cy, channel) - other.code(cx, cy, channel)))
                            }
                    }
                }
            }
            require(worstCentroid < 0.01) {
                "the two producers' centroids differ by up to ${"%.5f".format(worstCentroid)} UV — more " +
                        "than the readback's quantisation, so they are not summarising the same points"
            }
            "worst centroid disagreement ${"%.5f".format(worstCentroid)} UV over 16 cells, and the " +
                    "twelve raw channels differ by at most $worstChannel code"
        }

        // --- the clustered set, where the spatial half of the summary says something ---

        val cloudLeaf = planes(renderer, "cloud", CLOUD_DEPTH, "12-cloud-leaf")
        val cloudRange = plane(renderer, cloud, FabricatePassLibrary.summaryPlane("cloud", FabricatePassLibrary.SUMMARY_RANGE, CLOUD_DEPTH), "13-cloud-leaf-ranges")

        guard("a clustered set fills its leaf cells unevenly, which the uniform case cannot show") {
            val counts = (0 until cloudRange.height).flatMap { y ->
                (0 until cloudRange.width).map { x -> cloudRange.code(x, y, 1) }
            }
            require(counts.max() > counts.min()) { "every leaf node holds the same number of points" }
            val empty = counts.count { it == 0 }
            require(empty > 0) {
                "every one of the ${counts.size} leaf cells is occupied — a clustered set of " +
                        "$CLOUD_POINTS points over ${counts.size} cells should leave some empty, and a " +
                        "summary that never sees an empty cell never exercises its zero-weight branch"
            }
            val occupancy = cloudLeaf.value.let { plane ->
                (0 until plane.height).sumOf { y -> (0 until plane.width).count { x -> plane.code(x, y, ALPHA) > 127 } }
            }
            require(occupancy == counts.size - empty) {
                "the occupancy channel says $occupancy cells are occupied and the ranges say " +
                        "${counts.size - empty}"
            }
            "$empty of ${counts.size} leaf cells empty, fullest holds ${counts.max()}/255 of the array"
        }

        guard("the centroids have walked away from their cells' centres") {
            // The assertion the ramp cannot make. With a uniform weight every centroid sits at its
            // cell's centre whatever the moments are doing, so a chain with `momentTex` bound to the
            // wrong plane still passes everything above. Here the mass is lumpy and the centroid has
            // to follow it.
            var worst = 0.0
            var moved = 0
            (0 until cloudLeaf.value.height).forEach { cy ->
                (0 until cloudLeaf.value.width).forEach { cx ->
                    val shape = shapeOf(cloudLeaf, cx, cy)
                    if (shape.weight <= 0.0) return@forEach
                    val cells = cloudLeaf.value.width
                    val offset = hypot(
                        shape.centroidU - (cx + 0.5) / cells,
                        shape.centroidV - (cy + 0.5) / cells
                    )
                    if (offset > 0.25 / cells) moved++
                    worst = maxOf(worst, offset * cells)
                }
            }
            require(moved >= 4) {
                "only $moved occupied cells hold a centroid off their own centre by more than a quarter " +
                        "of a cell — on a clustered set that is what a centroid computed from the cell " +
                        "index rather than from the moments looks like"
            }
            "$moved cells with a displaced centroid, worst ${"%.2f".format(worst)} of a cell width"
        }

        // --- the cut: the half of a quadtree that is not the pyramid ---

        guard("a variance cut stops at the depth the closed form says it must, and only there") {
            // A uniform field has a uniform answer, which is what makes this arithmetic rather than
            // a picture of some cells. Every wrong version of the descent shows up here: a parent's
            // flags read from the wrong level, a criterion off by a factor, or a finest level still
            // allowed to refine (which drops every cell that was open there and leaves holes).
            listOf(
                Triple("ramp-cut-coarse", CUT_COARSE_THRESHOLD, CUT_COARSE_DEPTH),
                Triple("ramp-cut-fine", CUT_FINE_THRESHOLD, CUT_FINE_DEPTH)
            ).forEach { (cut, threshold, expected) ->
                val drawn = (0..4).map { depth ->
                    depth to drawnCells(renderer, ramp, "$cut-select-$depth", "19-$cut-$depth")
                }
                drawn.forEach { (depth, count) ->
                    val wanted = if (depth == expected) (1 shl depth) * (1 shl depth) else 0
                    require(count == wanted) {
                        "$cut drew $count cells at depth $depth, wanted $wanted — the variance of a " +
                                "$threshold cut crosses between depths ${expected - 1} and $expected, so " +
                                "the whole cut has to sit at depth $expected and nowhere else"
                    }
                }
            }
            "0.003 cut lands entirely at depth $CUT_COARSE_DEPTH, 0.0005 at depth $CUT_FINE_DEPTH"
        }

        guard("a clustered set is cut to different depths in different places — the hierarchy, used") {
            // The assertion the flat one-level overlay could not make. A cut that spans one level
            // is a grid whatever produced it; what makes this a quadtree is that the *same* pass
            // chain resolved empty space at depth 1 and the clusters four levels down.
            val perDepth = (1..CLOUD_DEPTH).map { depth ->
                depth to drawnCells(renderer, cloud, "cloud-cut-select-$depth", "20-cloud-cut-$depth")
            }
            val used = perDepth.filter { it.second > 0 }
            require(used.size >= 3) {
                "the cut used ${used.size} of ${perDepth.size} levels (${perDepth.joinToString()}) — " +
                        "one level is a grid, and a cut that never stops early is a grid at the bottom"
            }
            // Exactly the property that makes it a *cut* and not a set of overlapping cells: drawn
            // and open partition reached at every level, so the drawn cells' areas must sum to the
            // whole domain. A cell drawn twice, or a subtree that was opened and never closed,
            // shows up here and in no picture.
            val area = perDepth.sumOf { (depth, count) -> count.toDouble() / (1 shl depth) / (1 shl depth) }
            require(abs(area - 1.0) < 1e-6) {
                "the chosen cells cover ${"%.6f".format(area)} of the domain, not 1.0 — the cut is " +
                        "not a tiling, so some region is summarised twice or not at all"
            }
            "depths ${used.joinToString { "${it.first}:${it.second}" }}, covering exactly the domain"
        }

        // --- the figures ---

        val splat = capture(renderer, cloud.targetOf("cloud-view")!!, "14-cloud-view")
        val cloudEllipses = capture(renderer, cloud.targetOf("cloud-ellipses")!!, "15-cloud-ellipses")
        val fieldEllipses = capture(renderer, cloud.targetOf("cloudfield-ellipses")!!, "16-cloudfield-ellipses")
        val cut = capture(renderer, cloud.targetOf("cloud-cut-$CLOUD_DEPTH")!!, "21-cloud-adaptive-cut")

        guard("the overlay draws something the image underneath does not have") {
            require(splat.distinctLumaBuckets >= 8) { "the splatted cloud has ${splat.distinctLumaBuckets} levels" }
            // Checked before the comparison below draws any conclusion from the raster producer: a
            // clipped density is a different distribution, and its moments are right about it.
            require(splat.maxLuma < SATURATION_CEILING) {
                "the splatted cloud peaks at ${"%.4f".format(splat.maxLuma)}, at or over the readback's " +
                        "clamp — the raster producer is then summarising a flat-topped version of the " +
                        "cloud, and its disagreement with the point producer would be the clipping. " +
                        "Lower SPLAT_GAIN."
            }
            val drewEllipses = cloudEllipses.changedFraction(splat, MARKED_TEXEL)
            val drewCut = cut.changedFraction(splat, MARKED_TEXEL)
            require(drewEllipses > DREW_SOMETHING) {
                "the ellipse overlay changed ${"%.4f".format(drewEllipses)} of the frame — either the " +
                        "planes are unbound or every cell fell through the zero-weight branch, both of " +
                        "which render as the picture you started with"
            }
            require(drewCut > DREW_SOMETHING) {
                "the adaptive cut changed ${"%.4f".format(drewCut)} of the frame"
            }
            "the overlay marked ${"%.1f".format(drewEllipses * 100)}% of the frame, the cut " +
                    "${"%.1f".format(drewCut * 100)}%"
        }

        guard("both producers find the same shape in the same cloud, where a cell holds enough of it") {
            // Deliberately NOT a comparison of the two overlays as pictures. At the leaf level they
            // look different and should: a leaf cell holds one or two points, so the point producer
            // reports a singular covariance and no ellipse, while the raster producer — summarising
            // a *splat* of those points — sees a smooth little blob in every cell and draws a small
            // circle. That difference is information, not error; it is the sub-cell structure the
            // rasterisation already threw away.
            //
            // Two levels up, a cell holds a sixteenth of the set and both producers have a shape to
            // report. That is where they have to agree, and it is asserted on the covariance itself
            // rather than on a picture of it.
            val points = plane(renderer, cloud, "cloud-covariance-2", "17-cloud-covariance")
            val field = plane(renderer, cloud, "cloudfield-covariance-2", "18-cloudfield-covariance")
            var worst = 0.0
            var worstAt = ""
            var anisotropic = 0
            (0 until 4).forEach { cy ->
                (0 until 4).forEach { cx ->
                    if (points.code(cx, cy, ALPHA) < 128) return@forEach
                    val cxx = points.linear(cx, cy, 0)
                    val cyy = points.linear(cx, cy, 1)
                    if (cxx > 1e-4 && abs(cxx - cyy) > 0.25 * (cxx + cyy)) anisotropic++
                    listOf(0 to "cxx", 1 to "cyy", 2 to "cxy").forEach { (channel, label) ->
                        val a = points.linear(cx, cy, channel)
                        val b = field.linear(cx, cy, channel)
                        val error = abs(a - b)
                        if (error > worst) {
                            worst = error
                            worstAt = "$label at ($cx, $cy): points ${"%.4f".format(a)}, raster ${"%.4f".format(b)}"
                        }
                    }
                }
            }
            // A splat is a point convolved with a Gaussian, so the raster's variance is the point
            // set's plus the splat's own — about r² = 4e-4, which at this gain is 0.4. The floor is
            // set above that and well under a disagreement about *which* points a cell holds.
            require(worst < COVARIANCE_AGREEMENT_FLOOR) {
                "the two producers' covariances differ by up to ${"%.4f".format(worst)} at $worstAt — " +
                        "more than the splat's own width accounts for, so they are not summarising the " +
                        "same mass"
            }
            require(anisotropic >= 2) {
                "only $anisotropic cells came back measurably anisotropic — the clusters are stretched " +
                        "2:1 and 1:4, so a summary that reports them all round has lost the off-diagonal " +
                        "or is reading the wrong level"
            }
            require(fieldEllipses.distinctLumaBuckets >= 8) {
                "the raster overlay has ${fieldEllipses.distinctLumaBuckets} levels"
            }
            "worst covariance disagreement ${"%.4f".format(worst)} at gain " +
                    "${COVARIANCE_GAIN.toInt()} ($worstAt), $anisotropic cells anisotropic; the overlays " +
                    "differ as pictures by ${"%.3f".format(fieldEllipses.differenceFrom(cloudEllipses))} " +
                    "mean luma, which is the sub-cell structure the splat lost"
        }
    }

    private fun cloudChain(): List<FabricatePassSpec> =
        listOf(
            FabricatePassSpec(
                name = "cloud-points",
                fragment = cloudPointsFragment(CLOUD_GRID),
                size = FabricatePassSize.Absolute(CLOUD_GRID, CLOUD_GRID),
                format = VK_FORMAT_R32G32B32A32_SFLOAT,
                source = FabricatePassChain.CHAIN_INPUT
            ),
            FabricatePassSpec(
                name = "cloud-splat",
                fragment = cloudSplatFragment(CLOUD_POINTS, CLOUD_GRID),
                size = FabricatePassSize.Absolute(SPLAT_DIM, SPLAT_DIM),
                format = VK_FORMAT_R32G32B32A32_SFLOAT,
                source = "cloud-points",
                push = mapOf("radius" to SPLAT_RADIUS, "gain" to SPLAT_GAIN)
            ),
            // The plane you summarise is not the plane you look at, and this is the second time
            // that has cost a figure. `cloud-splat` carries the mass in red and the value *ratio*
            // in blue because that is what the raster pyramid weighs and averages — and a ratio
            // stays at full strength wherever the mass is merely small, so drawing it directly is
            // a blue blob the size of the cloud's faintest halo with the overlay lost inside it.
            FabricatePassSpec(
                name = "cloud-view",
                fragment = CLOUD_VIEW_FRAGMENT,
                size = FabricatePassSize.Absolute(SPLAT_DIM, SPLAT_DIM),
                source = "cloud-splat"
            )
        ) + FabricatePassLibrary.mortonPointQuadtree(
            prefix = "cloud",
            points = "cloud-points",
            pointGrid = CLOUD_GRID,
            depth = CLOUD_DEPTH,
            // A quarter of the points land in one leaf cell, so its density against a uniform
            // spread is about 64 — correct, and four hundred times what an 8-bit readback can
            // show. This is the knob for looking at one, and it scales the weight and the moments
            // together so every ratio taken from them is unchanged.
            densityScale = CLOUD_DENSITY_SCALE
        ) + FabricatePassLibrary.summaryEllipses(
            name = "cloud-ellipses",
            over = "cloud-view",
            prefix = "cloud",
            depth = CLOUD_DEPTH,
            weightGain = 60f
        ) + FabricatePassLibrary.summaryPyramid(
            prefix = "cloudfield",
            resolution = CLOUD_FIELD_LEAF,
            source = "cloud-splat",
            // The mass channel, explicitly, and not luminance. The splat's green and blue carry the
            // *value* field, which is a ratio — `Σwv / Σw` — and therefore stays at full strength
            // wherever the mass is merely small rather than zero. Summarising luminance gave every
            // cell a uniform pedestal of about 0.2 covering the whole cell, which is a perfectly
            // plausible density field whose covariance is the cell's own: it read 4.1e-3 against the
            // point producer's 7.4e-4, and the picture of it looked fine.
            weightChannel = 0,
            valueChannel = 2
        ) + FabricatePassLibrary.summaryEllipses(
            name = "cloudfield-ellipses",
            over = "cloud-view",
            prefix = "cloudfield",
            depth = CLOUD_DEPTH,
            weightGain = 24f
        ) + FabricatePassLibrary.adaptiveSummaryCells(
            prefix = "cloud",
            name = "cloud-cut",
            over = "cloud-view",
            coarsest = 1,
            finest = CLOUD_DEPTH,
            // The criterion that needs the second moments, and therefore the one an occupancy
            // quadtree cannot express: refine where the mass is narrower than the cell holding it.
            criterion = FabricatePassLibrary.SubdivisionCriterion.SPREAD,
            threshold = CLOUD_CUT_SPREAD,
            weightGain = 40f
        ) + FabricatePassLibrary.summaryCovariance(
            name = "cloud-covariance-2",
            prefix = "cloud",
            depth = 2,
            gain = COVARIANCE_GAIN
        ) + FabricatePassLibrary.summaryCovariance(
            name = "cloudfield-covariance-2",
            prefix = "cloudfield",
            depth = 2,
            gain = COVARIANCE_GAIN
        )

    private fun rampSource(name: String, base: Float, amplitude: Float) = FabricatePassSpec(
        name = name,
        fragment = RAMP_FRAGMENT,
        size = FabricatePassSize.Absolute(GRID, GRID),
        // fp32 and not the chain input's format, and it is load-bearing: at an amplitude of 1/4096
        // an 8-bit source is a constant, and the variance under test would be exactly zero in both
        // representations — an A/B that agrees perfectly because there is nothing to measure.
        format = VK_FORMAT_R32G32B32A32_SFLOAT,
        source = FabricatePassChain.CHAIN_INPUT,
        push = mapOf("base" to base, "amplitude" to amplitude)
    )

    private fun cloudPointsFragment(width: Int): String = """
        #version 450
        layout(location = 0) in vec2 vUv;
        layout(location = 0) out vec4 outPoint;

        const int WIDTH = $width;

        float hash1(float n) { return fract(sin(n) * 43758.5453123); }

        void main() {
            ivec2 p = ivec2(gl_FragCoord.xy);
            float i = float(p.y * WIDTH + p.x);
            int which = int(mod(i, 3.0));

            // Each cluster sits inside one depth-2 cell, and that placement is a decision the
            // measurement depends on rather than an aesthetic one. The raster producer summarises a
            // *splat* of these points, and a splat spreads mass across whatever boundary it sits
            // on — so a cluster straddling a cell edge makes the two producers genuinely disagree
            // about which cell its mass is in, by an amount that has nothing to do with whether
            // either of them works. The first version of this file put a cluster centre exactly on
            // u = 0.5 and measured a covariance disagreement of 0.89 that was entirely that.
            vec2 centre = which == 0 ? vec2(0.375, 0.375) : which == 1 ? vec2(0.625, 0.375) : vec2(0.625, 0.625);
            // One round, two stretched — and the stretched pair rotated off the axes, so the
            // off-diagonal of the covariance is not zero by symmetry. Nothing else in this file
            // reads the cross moment, and a plane nobody reads is a plane that can be wrong.
            vec2 skew = which == 0 ? vec2(1.0, 1.0) : which == 1 ? vec2(2.0, 0.45) : vec2(0.45, 1.8);
            float lean = which == 0 ? 0.0 : which == 1 ? 0.5 : -0.7;
            float radius = which == 0 ? 0.10 : 0.05;

            float angle = hash1(i * 1.7 + 3.0) * 6.2831853;
            vec2 offset = vec2(cos(angle), sin(angle)) * (radius * pow(hash1(i * 2.3 + 11.0), 0.7)) * skew;
            vec2 turned = vec2(
                offset.x * cos(lean) - offset.y * sin(lean),
                offset.x * sin(lean) + offset.y * cos(lean)
            );

            outPoint = vec4(
                clamp(centre + turned, vec2(0.01), vec2(0.99)),
                0.35 + 0.65 * hash1(i * 3.1 + 7.0),
                0.2 + 0.7 * hash1(i * 5.9 + 19.0)
            );
        }
    """