KotlinJs.kt

package afield.lang.remotejs

import afield.ai.agent.*
import afield.ai.conversation.*
import afield.ai.tools.*
import afield.animation.gesture.*
import afield.animation.interpolation.*
import afield.animation.keyframes.*
import afield.app.diagnostics.*
import afield.app.notifications.*
import afield.app.protocol.*
import afield.app.server.*
import afield.app.settings.*
import afield.audio.synth.*
import afield.data.table.*
import afield.document.context.*
import afield.document.graph.*
import afield.document.history.*
import afield.document.persistence.*
import afield.document.properties.*
import afield.document.workspace.*
import afield.graphics.color.*
import afield.graphics.paint.*
import afield.graphics.vulkan.*
import afield.math.functions.*
import afield.media.capture.*
import afield.media.stream.*
import afield.media.video.*
import afield.runtime.completion.*
import afield.runtime.execution.*
import afield.runtime.kotlin.*
import afield.runtime.lifecycle.*
import afield.tools.automation.*
import afield.tools.docs.*
import afield.ui.controls.*
import afield.ui.layout.*
import afield.ui.notation.*
import afield.ui.output.*
import afield.ui.output.templates.*
import afield.ui.slides.*
import afield.ui.visualization.*
import afield.app.diagnostics.logging.lprintln
import afield.runtime.MainLanguageRuntime
import afield.runtime.TopologyWatcher
import afield.runtime.applyRuntimeToggle
import afield.runtime.isMainLanguage
import afield.runtime.registerMainLanguageRuntime
import afield.ai.learning.*
import afield.ai.retrieval.*
import afield.animation.motion.*
import afield.app.commands.*
import afield.audio.analysis.*
import afield.data.collections.*
import afield.data.formats.*
import afield.data.graph.*
import afield.data.sorting.*
import afield.geometry.mesh.*
import afield.geometry.path.*
import afield.geometry.spatial.*
import afield.graphics.interaction.*
import afield.graphics.render.*
import afield.graphics.shader.*
import afield.graphics.text.*
import afield.graphics.vulkan.buffers.*
import afield.io.osc.*
import afield.io.process.*
import afield.lang.lambda.*
import afield.lang.python.*
import afield.lang.remotejs.*
import afield.lang.stacksl.*
import afield.math.autodiff.*
import afield.math.control.*
import afield.math.estimation.*
import afield.math.linalg.*
import afield.math.optimization.*
import afield.math.statistics.*
import afield.math.units.*
import afield.media.image.*
import afield.runtime.languages.*
import afield.simulation.agents.*
import afield.simulation.automata.*
import afield.simulation.particles.*
import afield.study.build.*
import afield.study.evidence.*
import afield.study.search.*
import afield.study.source.*
import afield.study.ui.*
import java.util.concurrent.ConcurrentHashMap
import java.util.concurrent.Executors

    private fun completeOffLoop(inside: Box, completionRequest: CompletionRequest): Completion? {
        val pos = completionRequest.position
        val selection = try {
            KotlinJsHeadProfiles.resolveForBox(inside, completionRequest.allCode)
        } catch (e: IllegalArgumentException) {
            notify(e.message ?: "Invalid Kotlin/JS head marker", "kotlinjs_error")
            return null
        }

        // Stage 1: reuse the rich K2 Analysis-API completion, but scope the analysis classpath to the
        // Kotlin stdlib only (KotlinJsExecution.kotlinStdlibRoots). The box has no JVM classpath — its
        // symbol universe is stdlib + its own declarations (present in `allCode`) + the selected head
        // profile's JVM-analysis-safe declaration model + keywords. Profile declarations stay at file
        // scope so nested types and member/callback inference work; their public callables are also
        // represented as local stubs for discoverability.
        val stdlibRoots = AaCompletionClient.kotlinStdlibRoots()
        if (stdlibRoots.isEmpty()) return null

        // The sidecar builds a fresh Analysis-API session per distinct classpath and answers
        // "warming up" (empty) on the first call(s) for a cold stdlib session. Retry a few
        // times so a user's first completion in a session isn't silently empty.
        var success: afield.runtime.kotlin.CompletionResult.Success? = null
        var lastDetail = ""
        repeat(4) { attempt ->
            if (success != null) return@repeat
            val outcome = AaCompletionClient.complete(
                snippet = completionRequest.allCode,
                cursor = pos,
                preamble = "",
                declarations = selection.profile.completionDeclarations,
                implicitReceivers = emptyList(),
                classpathRootsOverride = stdlibRoots,
                jsTarget = true,
            )
            lastDetail = outcome.detail
            success = outcome.result as? afield.runtime.kotlin.CompletionResult.Success
            if (success == null && attempt < 3) Thread.sleep(300)
        }
        val built = success
        if (built == null) {
            lprintln("info,kotlinjs", "completion backend=AA(stdlib) → empty ($lastDetail)")
            return null
        }
        return Completion(
            boundsStart = built.bounds.start,
            boundsEnd = built.bounds.end,
            metadata = built.metadata.map {
                Metadata(
                    icon = it.icon,
                    tail = it.tail,
                    text = it.text,
                    displayText = it.displayText,
                    documentation = "",
                )
            },
        )
    }

    private fun runKotlin(
        inside: Box,
        execute: Execute,
        launchable: Boolean,
        code: String,
        strand: String,
        reply: (Message) -> Unit,
    ) {
        // The receipt every engine owes an awaited run (ExecutionVerdict.kt). Before 2026-10-24 a
        // Kotlin→JS run published none, so every backdoor `run` of one timed out, errors included.
        val trace = ExecutionTrace.forEngine(inside, execute, if (launchable) "launch" else "run", reply)
        configureOutputProxies(inside, trace.reply)
        val settle = KotlinJsReceipt(trace)

        val selection = try {
            KotlinJsHeadProfiles.resolveForBox(inside, code)
        } catch (e: IllegalArgumentException) {
            inside.output.errorProxy(e.message ?: "Invalid Kotlin/JS head marker", "code", 0)
            settle.finish(false, e.message ?: "Invalid Kotlin/JS head marker")
            return
        }
        val connected = selection.profile.connectedHeadCount()

        if (connected == 0 && selection.profile != KotlinJsHeadProfiles.visionMetal) {
            // Nothing would run it; this used to compile, warn in a toast and report success.
            notify("Warning! no connected ${selection.profile.id} heads", "kotlinjs")
            inside.output.errorProxy(RemoteJsBoxSurface.NO_HEAD, "code", -1)
            settle.finish(false, RemoteJsBoxSurface.NO_HEAD)
            return
        } else if (connected == 0)
            notify("compiling Kotlin → ${selection.profile.id}; program will replay when the head connects", "kotlinjs")
        else
            notify("compiling Kotlin → ${selection.profile.id} for $connected head(s)", "kotlinjs")

        if (!launchable) {
            runFragment(inside, execute, code, selection, settle)
            return
        }

        val lifecycleName = kotlinJsLifecycleName(inside, strand)
        val key = "${inside.id}\u0000$strand"
        launches.remove(key)?.let { previous ->
            previous.cancel()
            previous.selection.profile.stop(inside, previous.selection, listOf(previous.lifecycleName))
        }

        val generation = synchronized(inside) {
            val next = (inside.runGeneration[strand] ?: -1) + 1
            inside.runGeneration[strand] = next
            inside.currentRunningStates[strand] = RunningState(next, "launch")
            next
        }
        send(Message("is-running").payload(IsRunning(execute.uid, true, generation, strand, "launch")))

        lateinit var tracker: KotlinJsLaunchTracker
        tracker = KotlinJsLaunchTracker(
            box = inside,
            strand = strand,
            generation = generation,
            lifecycleName = lifecycleName,
            selection = selection,
            notifyStopped = {
                send(Message("is-running").payload(IsRunning(execute.uid, false, generation, strand, "launch")))
            },
            onFinished = { launches.remove(key, tracker) },
        )
        launches[key] = tracker

        kotlinJsCompilePool.submit {
            try {
                val sent = compileAndSendKotlin(
                    inside,
                    code,
                    launchable = true,
                    selectedHead = selection,
                    lifecycleName = lifecycleName,
                    onResponse = { response -> settle.observe(response, launch = true); tracker.onResponse(response) },
                    sendGate = tracker::sendIfActive,
                )
                if (!sent) settle.finish(false, "Kotlin → JS did not compile, or the launch was replaced")
                else if (selection.profile == KotlinJsHeadProfiles.visionMetal && connected == 0) settle.finish(true)
                tracker.deliveryFinished(
                    sent = sent,
                    durableWithoutResponse = false,
                )
            } catch (e: Exception) {
                lprintln("error,kotlinjs", e.stackTraceToString())
                notify("Kotlin → JS failed: ${e.message}", "kotlinjs_error")
                inside.output.errorProxy(e.message ?: "compile error", "code", 0)
                settle.finish(false, e.message ?: "compile error")
                tracker.cancel()
            }
        }
    }

    private fun runFragment(
        inside: Box,
        execute: Execute,
        code: String,
        selection: KotlinJsHeadSelection,
        settle: KotlinJsReceipt,
    ) {
        val watermark = ++inside.fragmentGeneration
        send(Message("is-running").payload(IsRunning(execute.uid, true, watermark, "__fragment__")))
        val boxSource = inside.getPropertyRaw(execute.property) as? String
        val fragmentContext = boxSource?.takeIf(String::isNotBlank)?.let {
            val firstLine = execute.line.coerceAtLeast(0) + 1
            KotlinJsFragmentContext(
                boxSource = it,
                activeUserLines = firstLine..(firstLine + code.count { c -> c == '\n' }),
            )
        }
        kotlinJsCompilePool.submit {
            try {
                val sent = compileAndSendKotlin(
                    inside,
                    code,
                    launchable = false,
                    selectedHead = selection,
                    fragmentContext = fragmentContext,
                    onResponse = { response -> settle.observe(response, launch = false); response.kind != "ERROR" && response.kind != "RUN-STOP" },
                )
                if (!sent) settle.finish(false, "Kotlin → JS did not compile")
                else if (selection.profile == KotlinJsHeadProfiles.visionMetal) settle.finish(true)
            } catch (e: Exception) {
                lprintln("error,kotlinjs", e.stackTraceToString())
                notify("Kotlin → JS failed: ${e.message}", "kotlinjs_error")
                inside.output.errorProxy(e.message ?: "compile error", "code", 0)
                settle.finish(false, e.message ?: "compile error")
            } finally {
                send(Message("is-running").payload(IsRunning(execute.uid, false, watermark, "__fragment__")))
            }
        }
    }
}