feat(sample): live indexing progress in bottom bar + dex surface warmup

- LspServerService exposes buildProgress StateFlow fed by the in-process
  server's onBuildProgress listener (host hook on LuaLanguageServer) — the app
  UI shows 'PARSING n/12' live, no client round-trip
- After the cold rebuild completes, run one completion query to warm the Java
  member surfaces (dex/framework hydration) so the user's FIRST completion
  popup is fast instead of paying the 3s surface-build cost

Author: dingyi222666

android/sample/src/main/java/io/github/dingyi222666/luaparser/sample/LspServerService.kt

@@ -145,15 +145,21 @@ class LspServerService : Service() {
      * [LuaLanguageServerLauncher] connection over the socket streams and blocks
      * until the lsp4j reading loop finishes (peer disconnect, error or cancel).
      */
+    /** Live workspace-build status for the app UI ("PARSING 5/12", ...). */
+    val buildProgress = kotlinx.coroutines.flow.MutableStateFlow("indexing: starting")
+
     private suspend fun serve(client: LocalSocket) {
         try {
+            // Fresh LuaLanguageServer per connection (mandatory, see
+            // LuaLspServerHost's concurrency contract) + no-op exit hook.
+            val server = LuaLanguageServer()
+            server.setOnBuildProgressListener { done, total, phase ->
+                buildProgress.value = "$phase $done/$total"
+            }
             val connection = LuaLanguageServerLauncher.launch(
                 client.inputStream,
-                client.outputStream
-                // Defaults are correct here: a FRESH LuaLanguageServer per
-                // connection (mandatory, see LuaLspServerHost's concurrency
-                // contract) and a no-op exit hook (an embedded server must
-                // never kill the host app process on LSP `exit`).
+                client.outputStream,
+                server = server
             )
             // Blocks until the peer closes the stream or we get cancelled.
             connection.listening.get()

android/sample/src/main/java/io/github/dingyi222666/luaparser/sample/MainActivity.kt

@@ -168,6 +168,14 @@ class MainActivity : AppCompatActivity(), FileBrowserFragment.Listener {
         subscribeDirtyTracking()
         diagnosticsBar.setOnClickListener { jumpToFirstProblem() }
 
+        // Live indexing status in the bottom bar: the service hosts the LSP
+        // in-process, so progress arrives without any client round-trip.
+        lifecycleScope.launch {
+            LspServerService.buildProgress.collect { status ->
+                diagSummary.text = status
+            }
+        }
+
         lifecycleScope.launch {
             val t0 = System.currentTimeMillis()
             fun mark(phase: String) {

src/jvmMain/kotlin/io/github/dingyi222666/luaparser/lsp/LuaLanguageServer.kt

@@ -369,6 +369,19 @@ class LuaLanguageServer(
 
     override fun getWorkspaceService(): WorkspaceService = workspace
 
+    /**
+     * Host hook (in-process embedding): receives throttled workspace build
+     * progress (phase + completed/total) so the app UI can show indexing status
+     * directly — no client round-trip needed.
+     */
+    fun setOnBuildProgressListener(listener: ((Int, Int, String) -> Unit)?) {
+        languageService.onBuildProgress = listener?.let { cb ->
+            { progress: io.github.dingyi222666.luaparser.semantic.workspace.AnalysisProgress ->
+                cb(progress.completedFiles, progress.totalFiles, progress.phase.name)
+            }
+        }
+    }
+
     /** Test/embedding hook: wait for the background workspace build to settle. */
     internal fun flushBackgroundRebuild(timeoutMs: Long = 60_000): Boolean =
         languageService.awaitWorkspaceReady(timeoutMs)
@@ -380,7 +393,12 @@ class LuaLanguageServer(
             }
         }
         // Forward background-build progress as standard $/progress work-done
-        // notifications (create/report/end) so editors show indexing status.
+        // notifications for capability-advertising clients. When the client
+        // doesn't support them (sora), leave any host-set listener in place —
+        // an in-process host gets progress directly.
+        if (languageService.onBuildProgress != null) {
+            return
+        }
         languageService.onBuildProgress = { progress ->
             val proxy = client
             // sora's client proxy throws UnsupportedOperationException on

src/jvmMain/kotlin/io/github/dingyi222666/luaparser/lsp/LuaLanguageService.kt

@@ -323,6 +323,13 @@ class LuaLanguageService(
                 workspaceGeneration != generationAtStart
             }
             if (!moved) {
+                // Warm the Java member surfaces (dex/framework classes) so the
+                // FIRST user completion isn't the one paying the build cost.
+                runCatching {
+                    queries.completions(
+                        VirtualPath.of("warmup/main.lua"), Position(1, 1)
+                    )
+                }
                 return
             }
             attempts += 1