val DEMO_SOURCE: String = """
        #rectsl
        ->wall 20 10 meters
        ->duration 6
        ->fps 30

        # colour legend across the top: 40 swatches sweeping viridis
        "leg" rect  0.5 0.8 ->wh
          40 '( fc 9.6 *  4.3 ->offset  "viridis" f colormap solid ->fill ) array
        ;

        # bar chart from data, viridis by value, staggered grow-in
        '( 4 7 2 9 5 8 3 6 1 6 5 9 4 7 3 8 ) data  normalize  "viridis" bars
          '( '( 0=0 0.7=1 ) ease-out ->alpha ) each
          0.05 ->stagger-time
    """.trimIndent()

    private fun source(name: String): String = when (name) {
        "colormap-legend" -> """
            #rectsl
            ->wall 24 4 abstract
            ->duration 4
            ->fps 30
            "swatch" rect  0.7 3 ->wh
              24 '( fc 11 *  0 ->offset  "viridis" f colormap solid ->fill ) array
            ;
        """.trimIndent()
        "data-bars" -> """
            #rectsl
            ->wall 18 8 abstract
            ->duration 5
            ->fps 30
            '( 3 7 2 9 5 8 4 6 1 6 ) data  normalize  "magma" bars
              '( '( 0=0 0.6=1 ) ease-out ->alpha ) each
              0.07 ->stagger-time
        """.trimIndent()
        "heatmap-field" -> """
            #rectsl
            ->wall 12 8 abstract
            ->duration 4
            ->fps 30
            0 1 48 linspace  '( 6 * sin 1 + ) data-map  8 6 "turbo" heat
              '( '( 0=0 0.5=1 ) ease-in-out ->alpha ) each
              0.03 ->stagger-time
        """.trimIndent()
        "scatter-plot" -> """
            #rectsl
            ->wall 10 10 abstract
            ->duration 4
            ->fps 30
            0 1 40 linspace  dup  '( 7 * sin ) data-map  "plasma" scatter
        """.trimIndent()
        "data-inspect" -> """
            #rectsl
            ->wall 16 6 abstract
            ->duration 2
            ->fps 30
            '( 12 5 27 3 19 8 ) data
              dup extent  drop drop
              dup dmin drop
              dup dmax drop
              dup data-len drop
              dup 2 data-at drop
              "coolwarm" bars
        """.trimIndent()
        "dataviz-demo" -> DEMO_SOURCE
        "plot-axes" -> PLOT_SOURCE
        else -> error("unknown program $name")
    }

    private fun renderColormaps(): BufferedImage {
        val names = Colormaps.names
        val w = 640
        val labelW = 96
        val rowH = 40
        val gap = 10
        val pad = 12
        val h = pad * 2 + names.size * rowH + (names.size - 1) * gap
        val img = BufferedImage(w, h, BufferedImage.TYPE_INT_RGB)
        val g = img.createGraphics()
        g.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON)
        g.color = Color(24, 24, 28)
        g.fillRect(0, 0, w, h)
        g.font = Font(Font.SANS_SERIF, Font.PLAIN, 13)
        names.forEachIndexed { row, name ->
            val y = pad + row * (rowH + gap)
            g.color = Color.WHITE
            g.drawString(name, 8, y + rowH / 2 + 5)
            val barX = labelW
            val barW = w - labelW - pad
            for (px in 0 until barW) {
                val t = px / (barW - 1).toDouble()
                g.color = awt(Colormaps.sample(name, t))
                g.fillRect(barX + px, y, 1, rowH)
            }
        }
        g.dispose()
        return img
    }

    private fun assertColormapSanity() {
        // viridis: dark purple at 0 → yellow at 1.
        val v0 = Colormaps.sample("viridis", 0.0)
        val v1 = Colormaps.sample("viridis", 1.0)
        check(v0.r < 0.4 && v0.g < 0.2 && v0.b in 0.25..0.5) { "viridis(0) not dark-purple: $v0" }
        check(v1.r > 0.8 && v1.g > 0.7 && v1.b < 0.35) { "viridis(1) not yellow: $v1" }
        // magma/inferno start near-black.
        check(Colormaps.sample("magma", 0.0).let { it.r < 0.1 && it.g < 0.1 && it.b < 0.1 }) { "magma(0) not near-black" }
        // coolwarm diverging: blue at 0, ~grey at 0.5, red at 1.
        val c0 = Colormaps.sample("coolwarm", 0.0)
        val c1 = Colormaps.sample("coolwarm", 1.0)
        check(c0.b > c0.r && c0.b > 0.6) { "coolwarm(0) not blue: $c0" }
        check(c1.r > c1.b && c1.r > 0.6) { "coolwarm(1) not red: $c1" }
        // turbo starts dark blue-purple, ends dark red.
        check(Colormaps.sample("turbo", 0.0).b > Colormaps.sample("turbo", 0.0).g) { "turbo(0) not blue-ish" }
        println("colormap sanity: viridis/magma/coolwarm/turbo endpoints correct")
    }

    private fun renderProgram(program: SceneProgram, time: Double): BufferedImage {
        val aspect = program.wall.width / program.wall.height
        val longSide = 900
        val (w, h) = if (aspect >= 1.0) longSide to (longSide / aspect).roundToInt()
        else (longSide * aspect).roundToInt() to longSide
        val img = BufferedImage(w.coerceAtLeast(2), h.coerceAtLeast(2), BufferedImage.TYPE_INT_RGB)
        val g = img.createGraphics()
        g.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON)
        g.color = awt(program.background)
        g.fillRect(0, 0, img.width, img.height)
        g.stroke = BasicStroke(1f)

        val sx = img.width / program.wall.width
        val sy = img.height / program.wall.height
        program.sample(time).rects.forEach { r ->
            drawRect(g, r, img.width, img.height, sx, sy)
        }
        g.dispose()
        return img
    }

    private fun drawRect(g: java.awt.Graphics2D, r: SampledRect, w: Int, h: Int, sx: Double, sy: Double) {
        val pw = r.size.x * r.scale.x * sx
        val ph = r.size.y * r.scale.y * sy
        if (pw <= 0.0 || ph <= 0.0) return
        // wall origin at centre, +y up → flip vertical for image space.
        val cx = w / 2.0 + r.center.x * sx
        val cy = h / 2.0 - r.center.y * sy
        val old = g.transform
        val tf = AffineTransform()
        tf.translate(cx, cy)
        tf.rotate(-r.rotation) // negated: image y runs downward
        g.transform = tf
        g.paint = when (val fill = r.fill) {
            is PaintSpec.Solid -> awt(fill.color, r.alpha)
            is PaintSpec.LinearGradient -> awt(fill.c0, r.alpha) // approximate with the start colour
        }
        g.fill(Rectangle2D.Double(-pw / 2.0, -ph / 2.0, pw, ph))
        g.transform = old
    }

    private fun paintedFraction(img: BufferedImage, background: Color4): Double {
        val bg = awt(background).rgb and 0xFFFFFF
        var painted = 0
        val total = img.width * img.height
        var i = 0
        val step = if (total > 200_000) 4 else 1 // subsample large images
        var y = 0
        while (y < img.height) {
            var x = 0
            while (x < img.width) {
                if ((img.getRGB(x, y) and 0xFFFFFF) != bg) painted++
                x += step
                i++
            }
            y += step
        }
        return painted.toDouble() / i.coerceAtLeast(1)
    }

    private fun awt(c: Color4, alphaMul: Double = 1.0): Color {
        fun b(v: Double) = (v.coerceIn(0.0, 1.0) * 255.0).roundToInt().coerceIn(0, 255)
        return Color(b(c.r), b(c.g), b(c.b), b(c.a * alphaMul))
    }
}