private const val EXPORT_PREAMBLE = "var Box._qqq by InheritanceFromContext<kotlin.Double>() /**/"

    private val failures = mutableListOf<String>()

    private class Outcome(val verdict: String, val results: List<ResultValue?>, val detail: String)

    private fun engineFor(tag: String, preamble: String?): Pair<KotlinInterface2, Box> {
        val box = Box("repl-decls-$tag")
        // `_qqq` resolves against this box itself, so no topology (and no session) is needed.
        box.setPropertyRaw("qqq", 10.0, doResync = false)
        preamble?.let { box.preamble = it }
        val ki = KotlinInterface2(
            implicitReceivers = listOf(KotlinType(Box::class)),
            filePrefix = "REPLDECLS_${tag}_"
        )
        ki.associatedBox = box
        box.ki = ki
        return ki to box
    }

    private suspend fun run(ki: KotlinInterface2, box: Box, code: String): Outcome {
        val compileErrors = mutableListOf<String>()
        val evalErrors = mutableListOf<String>()
        var thrown: Throwable? = null
        val results = try {
            standardExecutionPractice(
                ki = ki,
                s = code,
                onCompileError = { d -> d.forEach { compileErrors += firstLine(it) } },
                onEvalError = { d -> d.forEach { evalErrors += firstLine(it) } },
                onEvalException = { t -> thrown = t },
                implicits = listOf(box),
                onSetupCompileError = { block, d -> d.forEach { compileErrors += "$block: ${firstLine(it)}" } },
                onSetupEvalError = { block, d -> d.forEach { evalErrors += "$block: ${firstLine(it)}" } },
                onSetupEvalException = { _, t -> thrown = t },
            )
        } catch (t: Throwable) {
            thrown = t
            emptyList()
        }
        val verdict = when {
            compileErrors.isNotEmpty() -> "COMPILE-ERROR"
            thrown != null || evalErrors.isNotEmpty() -> "EVAL-ERROR"
            else -> "ok"
        }
        val detail = (compileErrors + evalErrors + listOfNotNull(thrown?.let { "${it::class.simpleName}: ${firstLine(it)}" }))
            .joinToString(" | ").take(400)
        return Outcome(verdict, results, detail)
    }

    @JvmStatic
    fun main(args: Array<String>) {

        println("-- a named function that touches the implicit Box receiver --")
        case(
            "A plain fun reads an inherited (preamble) property", EXPORT_PREAMBLE,
            """
            var m = 10
            fun foo(a: Double): Double { return a + 20 + m + _qqq }
            foo(12.0)
            """.trimIndent(),
            expected = "= 52.0"
        )
        case(
            "B plain fun reads a Box member", null,
            """
            fun foo(a: Double): String { return a.toString() + name }
            foo(12.0)
            """.trimIndent(),
            expected = "= 12.0"
        )
        case(
            "C plain fun reads only snippet-local state", null,
            """
            var m = 10
            fun foo(a: Double): Double { return a + 20 + m }
            foo(12.0)
            """.trimIndent(),
            expected = "= 42.0"
        )

        println("-- the same, written as an extension on Box (the pre-fix workaround) --")
        case(
            "D fun Box.foo called at top level", EXPORT_PREAMBLE,
            """
            var m = 10
            fun Box.foo(a: Double): Double { return a + 20 + m + _qqq }
            foo(12.0)
            """.trimIndent(),
            expected = "= 52.0"
        )
        case(
            "E fun Box.foo called inside a lambda", EXPORT_PREAMBLE,
            """
            var m = 10
            fun Box.foo(a: Double): Double { return a + 20 + m + _qqq }
            run { foo(12.0) }
            """.trimIndent(),
            expected = "= 52.0"
        )
        case(
            "F fun Box.foo called via thisBox inside a lambda", EXPORT_PREAMBLE,
            """
            var m = 10
            fun Box.foo(a: Double): Double { return a + 20 + m + _qqq }
            run { thisBox.foo(12.0) }
            """.trimIndent(),
            expected = "= 52.0"
        )

        println("-- reading the receiver from other positions --")
        case(
            "G preamble property at snippet top level", EXPORT_PREAMBLE,
            "_qqq + 1.0", expected = "= 11.0"
        )
        case(
            "H preamble property inside a lambda", EXPORT_PREAMBLE,
            "run { _qqq + 1.0 }", expected = "= 11.0"
        )
        case(
            "I local fun inside a lambda", EXPORT_PREAMBLE,
            """
            run {
                fun foo(a: Double): Double { return a + 20 + _qqq }
                foo(12.0)
            }
            """.trimIndent(),
            expected = "= 42.0"
        )
        case(
            "J val holding a lambda", EXPORT_PREAMBLE,
            """
            var m = 10
            val foo = { a: Double -> a + 20 + m + _qqq }
            foo(12.0)
            """.trimIndent(),
            expected = "= 52.0"
        )

        println("-- the edit sequence that used to leave a dead snippet behind --")
        sequence(
            "L plain fun, then the fun Box.foo version, then thisBox", EXPORT_PREAMBLE,
            listOf(
                """
                var m = 10
                fun foo(a: Double): Double { return a + 20 + m + _qqq }
                foo(12.0)
                """.trimIndent() to "= 52.0",
                """
                var m = 10
                fun Box.foo(a: Double): Double { return a + 20 + m + _qqq }
                thisBox.foo(12.0)
                """.trimIndent() to "= 52.0",
            )
        )

        println("-- delegated properties at snippet top level --")
        case(
            "N var by a provideDelegate provider", null,
            """
            import afield.runtime.kotlin.ReplSnippetDeclarationsSmokeTest.provideDelegateProvider
            var x by provideDelegateProvider()
            x
            """.trimIndent(),
            expected = "= 1"
        )
        case(
            "O var by a plain getValue/setValue delegate", null,
            """
            import afield.runtime.kotlin.ReplSnippetDeclarationsSmokeTest.plainDelegate
            var x by plainDelegate()
            x
            """.trimIndent(),
            expected = "= 7"
        )
        case(
            "P local var by a provideDelegate provider, inside a lambda", null,
            """
            import afield.runtime.kotlin.ReplSnippetDeclarationsSmokeTest.provideDelegateProvider
            run {
                var x by provideDelegateProvider()
                x
            }
            """.trimIndent(),
            expected = "= 1"
        )
        case(
            "Q val by a provideDelegate provider", null,
            """
            import afield.runtime.kotlin.ReplSnippetDeclarationsSmokeTest.provideDelegateProvider
            val x by provideDelegateProvider()
            x
            """.trimIndent(),
            expected = "= 1"
        )

        println("-- EXPRESSION-bodied functions that reach the receiver --")
        // A third defect of the same family, fixed in the fork on 2026-08-25 and pre-dating the two
        // above. `FirImplicitBodyResolve.resolveDeclaration` builds the designation for an INFERRED
        // return type as file + script + outerClasses, finding the script with
        // `firstIsInstanceOrNull<FirScript>()` -- which can never match a `FirReplSnippet`. Without
        // the snippet in that designation the designated transformer never runs `withReplSnippet`,
        // so the snippet's implicit receivers are absent from the tower and the box's own members
        // come back "inapplicable because of a receiver type mismatch". Only inferred return types
        // take that jump, which is why every case above (block bodies, all of them) resolved fine.
        case(
            "S expr body calling println", null,
            "fun f(a : Double) = println(\"\"\" \${a} \"\"\")\nf(10.0)",
            expected = "Unit"
        )
        case(
            "T expr body reading a Box member", null,
            "fun f(a : Double) = name + a\nf(10.0)",
            expected = "= 10.0"
        )
        case(
            "U expr body calling _printlnHere directly", null,
            "fun f(a : Double) = _printlnHere(1, a)\nf(10.0)",
            expected = "Unit"
        )

        println("-- destructuring with an underscore at snippet top level --")
        // Found 2026-09-28. A top-level `_` entry became a snippet-class property named
        // `<unused var>`, and loading the class failed with `ClassFormatError: Illegal method name
        // "get<unused var>"` -- an eval-time diagnostic that Field did not report, so the box
        // looked as though it never finished. `(a, b)` was always fine. Fixed in the fork: a `_`
        // entry is a local of `$$eval`, as inside any function body.
        case(
            "V (a, _) = pair", null,
            "val p = 1f to 2f\nval (a, _) = p\na",
            expected = "= 1.0"
        )
        case(
            "W (_, b) and (_, _, c) positional", null,
            "val (_, b) = 1 to 2\nval (_, _, c) = Triple(3, 4, 5)\nb * 10 + c",
            expected = "= 25"
        )
        case(
            "X var (x, _) with a list", null,
            "var (x, _) = listOf(40, 99)\nx += 2\nx",
            expected = "= 42"
        )
        sequence(
            "Y named entries of a `_` destructuring stay visible to the next snippet", null,
            listOf(
                "val (a, _) = 6 to 0\na" to "= 6",
                "a * 7" to "= 42",
            )
        )

        println("-- name-based destructuring (full form and [a, b]; short form off) at snippet top level --")
        // Field enables the full form and square-bracket positional form, not the short form, so a
        // plain `(a, b)` stays positional (case V). These go through the same snippet path as the
        // `_` fix above; Z2's `val _ = second` is a renamed underscore, which must stay a local.
        case(
            "Z1 (val age, val name) = data class, by name and out of order", null,
            "data class P(val name: String, val age: Int)\n(val age, val name) = P(\"Ada\", 36)\n\"\$name \$age\"",
            expected = "= Ada 36"
        )
        case(
            "Z2 (val n = first, val _ = second) renamed with an underscore", null,
            "(val n = first, val _ = second) = \"left\" to \"right\"\nn",
            expected = "= left"
        )
        case(
            "Z3 [_, z] square-bracket positional", null,
            "val [x, y] = listOf(10, 20)\nval [_, z] = Triple(1, 2, 3)\nx + y + z",
            expected = "= 32"
        )
        sequence(
            "Z4 a name-based entry stays visible to the next snippet", null,
            listOf(
                "(val first, val _ = second) = 6 to 0\nfirst" to "= 6",
                "first * 7" to "= 42",
            )
        )

        println("-- calls, as statements, to functions that have no callableId --")
        // Found 2026-09-16 and again 2026-10-04 in box code; fixed in Field's build of the Wither
        // plugin (libs/wither-plugin.jar), not in the fork. Wither's IR pass asked every call that
        // stands as a statement for its callee's `callableId`, which throws for a local function and
        // for a member of a local or anonymous class, a property setter included. The compile then
        // died with `IrGenerationExtensionException: IrFunctionImpl@... has no callableId`, reported
        // against the box's last line. A call whose value is used, as in case I, is never a
        // statement, which is why I passed throughout.
        case(
            "LF1 local fun in run { }, called as a statement", null,
            """
            var out = 0
            run {
                fun bump() { out += 1 }
                bump()
                bump()
            }
            out
            """.trimIndent(),
            expected = "= 2"
        )
        case(
            "LF2 local fun inside a named fun", null,
            """
            var total = 0
            fun outer(): Int {
                fun inner(k: Int) { total += k }
                inner(2)
                inner(3)
                return total
            }
            outer()
            """.trimIndent(),
            expected = "= 5"
        )
        case(
            "LF3 local fun inside a local fun, inside a lambda", null,
            """
            run {
                var n = 0
                fun outer() {
                    fun inner() { n += 10 }
                    inner()
                    inner()
                }
                outer()
                n
            }
            """.trimIndent(),
            expected = "= 20"
        )
        case(
            "LF4 local fun capturing a lambda parameter, in listOf(...).map { }", null,
            """
            var count = 0
            val doubled = listOf(1, 2, 3).map { x ->
                fun add() { count += x }
                add()
                x * 2
            }
            "${'$'}count ${'$'}doubled"
            """.trimIndent(),
            expected = "= 6 [2, 4, 6]"
        )
        case(
            "LF5 local fun capturing enclosing vars and a List, the once.keys shape", null,
            """
            var x = 0.0
            var y = 0.0
            val sizes = listOf(3.0, 4.0, 5.0)
            val placed = mutableListOf<String>()
            listOf("a", "b", "c").forEach { key ->
                fun layout() {
                    x += sizes[placed.size]
                    y = x * 2
                    placed += "${'$'}key@${'$'}x,${'$'}y"
                }
                layout()
            }
            placed.joinToString(" ")
            """.trimIndent(),
            expected = "= a@3.0,6.0 b@7.0,14.0 c@12.0,24.0"
        )
        case(
            "LF6 local fun reading an inherited (preamble) property", EXPORT_PREAMBLE,
            """
            var acc = 0.0
            run {
                fun add() { acc += _qqq }
                add()
                add()
            }
            acc
            """.trimIndent(),
            expected = "= 20.0"
        )
        case(
            "LF7 member of a local class, called as a statement", null,
            """
            run {
                class Counter { var n = 0; fun bump() { n += 1 } }
                val c = Counter()
                c.bump()
                c.bump()
                c.n
            }
            """.trimIndent(),
            expected = "= 2"
        )
        case(
            "LF8 property write inside an anonymous ReadWriteProperty", null,
            """
            import kotlin.properties.ReadWriteProperty
            import kotlin.reflect.KProperty
            fun make(): ReadWriteProperty<Any?, Int> = object : ReadWriteProperty<Any?, Int> {
                private var v = 40
                override fun getValue(thisRef: Any?, property: KProperty<*>): Int = v
                override fun setValue(thisRef: Any?, property: KProperty<*>, value: Int) { v = value }
            }
            var a: Int by make()
            a += 2
            a
            """.trimIndent(),
            expected = "= 42"
        )
        case(
            "LF9 property write inside an anonymous ReadOnlyProperty", null,
            """
            import kotlin.properties.ReadOnlyProperty
            import kotlin.reflect.KProperty
            fun make(): ReadOnlyProperty<Any?, Int> = object : ReadOnlyProperty<Any?, Int> {
                private var v = 0
                override fun getValue(thisRef: Any?, property: KProperty<*>): Int { v = 42; return v }
            }
            val a: Int by make()
            a
            """.trimIndent(),
            expected = "= 42"
        )

        println("-- a class or object that reaches the box receiver --")
        case("CR1 println inside a class member", null,
            "class C { fun g(): Int { println(\"from C\"); return 42 } }\nC().g()", expected = "42")
        case("CR2 display inside a class member", null,
            "class C { fun g(): Int { display(\"from C\"); return 42 } }\nC().g()", expected = "42")
        case("CR3 a lambda property of a class", null,
            "class C { val f = { println(\"from f\"); 42 } }\nC().f()", expected = "42")
        case("CR4 an object", null,
            "object O { fun g(): Int { println(\"from O\"); return 42 } }\nO.g()", expected = "42")
        case("CR5 the box's own property, read inside a class", null,
            "class C { fun g() = name == thisBoxName }\nval thisBoxName = name\nC().g()", expected = "true")
        case("CR6 a class declared in one snippet, constructed in the next",
            "class C(val n: Int) { fun g(): Int { println(\"from C\"); return n } }",
            "C(42).g()", expected = "42")

        println("-- the real keyCamera delegate, as five published sites spell it --")
        compilesOnly(
            "R var kc by keyCamera(camera=camera)",
            "import afield.graphics.vulkan.util.keyCamera\nval camera = Camera()\nvar kc by keyCamera(camera=camera)\nkc"
        )

        println("-- known-open behaviour, reported not asserted --")
        staleDeclarationShadowing()

        if (failures.isNotEmpty()) {
            System.err.println("REPL snippet declarations smoke FAILED with ${failures.size} problem(s):")
            failures.forEach { System.err.println("  - $it") }
            exitProcess(1)
        }
        println("REPL snippet declarations smoke passed")
    }

private val LOCAL_FUN_STATEMENTS_SNIPPET = """
var out = 0
run {
    fun bump() { out += 1 }
    bump()
    bump()
}

var total = 0
fun outer(): Int {
    fun inner(k: Int) { total += k }
    inner(2)
    inner(3)
    return total
}

var nested = 0
run {
    fun outerLocal() {
        fun innerLocal() { nested += 10 }
        innerLocal()
        innerLocal()
    }
    outerLocal()
}

var count = 0
val doubled = listOf(1, 2, 3).map { x ->
    fun add() { count += x }
    add()
    x * 2
}

var px = 0.0
val sizes = listOf(3.0, 4.0, 5.0)
val placed = mutableListOf<String>()
listOf("a", "b", "c").forEach { key ->
    fun layout() {
        px += sizes[placed.size]
        placed += key + "@" + px
    }
    layout()
}

val bumps = run {
    class Counter { var n = 0; fun bump() { n += 1 } }
    val c = Counter()
    c.bump()
    c.bump()
    c.n
}

println(listOf("local-fun-statements", out, outer(), nested, count, doubled, placed, bumps).joinToString(" "))
""".trimIndent()