From 6943a9d5ba7d49f2f175812e490770d8aceb6b27 Mon Sep 17 00:00:00 2001
From: Daniel Alome <astrocoder007@gmail.com>
Date: Tue, 25 Aug 2026 23:43:46 +0100
Subject: [PATCH 01/20] ADFA-2448: Add outline symbol model and containment
 tree builder

---
 .../language/outline/OutlineProvider.kt       | 10 ++
 .../editor/language/outline/OutlineSymbol.kt  | 31 ++++++
 .../language/outline/OutlineTreeBuilder.kt    | 54 +++++++++++
 .../outline/OutlineTreeBuilderTest.kt         | 94 +++++++++++++++++++
 4 files changed, 189 insertions(+)
 create mode 100644 editor/src/main/java/com/itsaky/androidide/editor/language/outline/OutlineProvider.kt
 create mode 100644 editor/src/main/java/com/itsaky/androidide/editor/language/outline/OutlineSymbol.kt
 create mode 100644 editor/src/main/java/com/itsaky/androidide/editor/language/outline/OutlineTreeBuilder.kt
 create mode 100644 editor/src/test/java/com/itsaky/androidide/editor/language/outline/OutlineTreeBuilderTest.kt

diff --git a/editor/src/main/java/com/itsaky/androidide/editor/language/outline/OutlineProvider.kt b/editor/src/main/java/com/itsaky/androidide/editor/language/outline/OutlineProvider.kt
new file mode 100644
index 0000000000..7ae47f33f2
--- /dev/null
+++ b/editor/src/main/java/com/itsaky/androidide/editor/language/outline/OutlineProvider.kt
@@ -0,0 +1,10 @@
+package com.itsaky.androidide.editor.language.outline
+
+interface OutlineProvider {
+	fun supports(fileExtension: String): Boolean
+
+	suspend fun outlineOf(
+		fileExtension: String,
+		text: CharSequence,
+	): List<OutlineSymbol>
+}
diff --git a/editor/src/main/java/com/itsaky/androidide/editor/language/outline/OutlineSymbol.kt b/editor/src/main/java/com/itsaky/androidide/editor/language/outline/OutlineSymbol.kt
new file mode 100644
index 0000000000..3a31d7523c
--- /dev/null
+++ b/editor/src/main/java/com/itsaky/androidide/editor/language/outline/OutlineSymbol.kt
@@ -0,0 +1,31 @@
+package com.itsaky.androidide.editor.language.outline
+
+import com.itsaky.androidide.models.Range
+
+enum class OutlineSymbolKind(
+	val badge: Char,
+) {
+	CLASS('C'),
+	INTERFACE('I'),
+	ENUM('E'),
+	ENUM_MEMBER('V'),
+	RECORD('R'),
+	ANNOTATION('A'),
+	OBJECT('O'),
+	COMPANION('O'),
+	TYPE_ALIAS('T'),
+	CONSTRUCTOR('N'),
+	METHOD('M'),
+	FIELD('F'),
+	PROPERTY('P'),
+	ELEMENT('X'),
+}
+
+data class OutlineSymbol(
+	val name: String,
+	val detail: String?,
+	val kind: OutlineSymbolKind,
+	val range: Range,
+	val selectionRange: Range,
+	val children: List<OutlineSymbol>,
+)
diff --git a/editor/src/main/java/com/itsaky/androidide/editor/language/outline/OutlineTreeBuilder.kt b/editor/src/main/java/com/itsaky/androidide/editor/language/outline/OutlineTreeBuilder.kt
new file mode 100644
index 0000000000..1bc0e96237
--- /dev/null
+++ b/editor/src/main/java/com/itsaky/androidide/editor/language/outline/OutlineTreeBuilder.kt
@@ -0,0 +1,54 @@
+package com.itsaky.androidide.editor.language.outline
+
+import com.itsaky.androidide.models.Range
+
+internal data class RawOutlineSymbol(
+	val name: String,
+	val detail: String?,
+	val kind: OutlineSymbolKind,
+	val range: Range,
+	val selectionRange: Range,
+)
+
+internal object OutlineTreeBuilder {
+	fun build(raw: List<RawOutlineSymbol>): List<OutlineSymbol> {
+		val sorted =
+			raw.sortedWith(
+				compareBy({ it.range.start.index }, { -it.range.end.index }),
+			)
+		val roots = mutableListOf<MutableNode>()
+		val stack = ArrayDeque<MutableNode>()
+		for (symbol in sorted) {
+			while (stack.isNotEmpty() && stack
+					.last()
+					.raw.range.end.index <= symbol.range.start.index
+			) {
+				stack.removeLast()
+			}
+			val node = MutableNode(symbol)
+			if (stack.isEmpty()) {
+				roots.add(node)
+			} else {
+				stack.last().children.add(node)
+			}
+			stack.addLast(node)
+		}
+		return roots.map { it.freeze() }
+	}
+
+	private class MutableNode(
+		val raw: RawOutlineSymbol,
+	) {
+		val children = mutableListOf<MutableNode>()
+
+		fun freeze(): OutlineSymbol =
+			OutlineSymbol(
+				name = raw.name,
+				detail = raw.detail,
+				kind = raw.kind,
+				range = raw.range,
+				selectionRange = raw.selectionRange,
+				children = children.map { it.freeze() },
+			)
+	}
+}
diff --git a/editor/src/test/java/com/itsaky/androidide/editor/language/outline/OutlineTreeBuilderTest.kt b/editor/src/test/java/com/itsaky/androidide/editor/language/outline/OutlineTreeBuilderTest.kt
new file mode 100644
index 0000000000..2ead91780a
--- /dev/null
+++ b/editor/src/test/java/com/itsaky/androidide/editor/language/outline/OutlineTreeBuilderTest.kt
@@ -0,0 +1,94 @@
+package com.itsaky.androidide.editor.language.outline
+
+import com.google.common.truth.Truth.assertThat
+import com.itsaky.androidide.models.Position
+import com.itsaky.androidide.models.Range
+import org.junit.Test
+
+class OutlineTreeBuilderTest {
+	private fun raw(
+		name: String,
+		start: Int,
+		end: Int,
+		kind: OutlineSymbolKind = OutlineSymbolKind.METHOD,
+	) = RawOutlineSymbol(
+		name = name,
+		detail = null,
+		kind = kind,
+		range = Range(Position(0, 0, start), Position(0, 0, end)),
+		selectionRange = Range(Position(0, 0, start), Position(0, 0, start)),
+	)
+
+	@Test
+	fun `empty input produces empty tree`() {
+		assertThat(OutlineTreeBuilder.build(emptyList())).isEmpty()
+	}
+
+	@Test
+	fun `single symbol is a root`() {
+		val result = OutlineTreeBuilder.build(listOf(raw("a", 0, 10)))
+		assertThat(result).hasSize(1)
+		assertThat(result[0].name).isEqualTo("a")
+		assertThat(result[0].children).isEmpty()
+	}
+
+	@Test
+	fun `contained symbol becomes a child`() {
+		val result =
+			OutlineTreeBuilder.build(
+				listOf(raw("outer", 0, 100, OutlineSymbolKind.CLASS), raw("inner", 10, 50)),
+			)
+		assertThat(result).hasSize(1)
+		assertThat(result[0].name).isEqualTo("outer")
+		assertThat(result[0].children.map { it.name }).containsExactly("inner")
+	}
+
+	@Test
+	fun `adjacent symbols do not nest`() {
+		val result = OutlineTreeBuilder.build(listOf(raw("a", 0, 10), raw("b", 10, 20)))
+		assertThat(result.map { it.name }).containsExactly("a", "b").inOrder()
+		assertThat(result[0].children).isEmpty()
+	}
+
+	@Test
+	fun `siblings keep document order`() {
+		val result =
+			OutlineTreeBuilder.build(
+				listOf(
+					raw("parent", 0, 100, OutlineSymbolKind.CLASS),
+					raw("second", 40, 60),
+					raw("first", 10, 30),
+				),
+			)
+		assertThat(result[0].children.map { it.name }).containsExactly("first", "second").inOrder()
+	}
+
+	@Test
+	fun `same start offset nests the shorter inside the longer`() {
+		val result =
+			OutlineTreeBuilder.build(
+				listOf(raw("short", 0, 20), raw("long", 0, 100, OutlineSymbolKind.CLASS)),
+			)
+		assertThat(result).hasSize(1)
+		assertThat(result[0].name).isEqualTo("long")
+		assertThat(result[0].children.map { it.name }).containsExactly("short")
+	}
+
+	@Test
+	fun `deep nesting chains through the stack`() {
+		val result =
+			OutlineTreeBuilder.build(
+				listOf(
+					raw("l1", 0, 100, OutlineSymbolKind.CLASS),
+					raw("l2", 10, 90, OutlineSymbolKind.CLASS),
+					raw("l3", 20, 80),
+					raw("uncle", 91, 99),
+				),
+			)
+		assertThat(result).hasSize(1)
+		val l1 = result[0]
+		assertThat(l1.children.map { it.name }).containsExactly("l2", "uncle").inOrder()
+		val l2 = l1.children[0]
+		assertThat(l2.children.map { it.name }).containsExactly("l3")
+	}
+}

From d6e2f456e53e42a9984f47c732676d86a6e9756c Mon Sep 17 00:00:00 2001
From: Daniel Alome <astrocoder007@gmail.com>
Date: Wed, 26 Aug 2026 00:26:02 +0100
Subject: [PATCH 02/20] ADFA-2448: Add outline tree-sitter queries for java,
 kotlin, xml

---
 editor/build.gradle.kts                       |  4 +-
 editor/src/androidTest/AndroidManifest.xml    |  9 +++
 .../outline/TreeSitterOutlineQueryTest.kt     | 57 +++++++++++++++++++
 .../assets/editor/treesitter/java/outline.scm | 29 ++++++++++
 .../assets/editor/treesitter/kt/outline.scm   | 27 +++++++++
 .../assets/editor/treesitter/xml/outline.scm  | 23 ++++++++
 6 files changed, 148 insertions(+), 1 deletion(-)
 create mode 100644 editor/src/androidTest/AndroidManifest.xml
 create mode 100644 editor/src/androidTest/java/com/itsaky/androidide/editor/language/outline/TreeSitterOutlineQueryTest.kt
 create mode 100644 editor/src/main/assets/editor/treesitter/java/outline.scm
 create mode 100644 editor/src/main/assets/editor/treesitter/kt/outline.scm
 create mode 100644 editor/src/main/assets/editor/treesitter/xml/outline.scm

diff --git a/editor/build.gradle.kts b/editor/build.gradle.kts
index c58ee88d42..04d67a8d9d 100644
--- a/editor/build.gradle.kts
+++ b/editor/build.gradle.kts
@@ -59,5 +59,7 @@ dependencies {
 	implementation(projects.idetooltips)
 
 	testImplementation(projects.testing.unit)
-	androidTestImplementation(projects.testing.android)
+	androidTestImplementation(projects.testing.android) {
+		exclude(group = "org.jetbrains.kotlin", module = "kotlin-reflect")
+	}
 }
diff --git a/editor/src/androidTest/AndroidManifest.xml b/editor/src/androidTest/AndroidManifest.xml
new file mode 100644
index 0000000000..a0720473d9
--- /dev/null
+++ b/editor/src/androidTest/AndroidManifest.xml
@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+
+	<application>
+		<meta-data
+			android:name="io.sentry.auto-init"
+			android:value="false" />
+	</application>
+</manifest>
diff --git a/editor/src/androidTest/java/com/itsaky/androidide/editor/language/outline/TreeSitterOutlineQueryTest.kt b/editor/src/androidTest/java/com/itsaky/androidide/editor/language/outline/TreeSitterOutlineQueryTest.kt
new file mode 100644
index 0000000000..d8766c2948
--- /dev/null
+++ b/editor/src/androidTest/java/com/itsaky/androidide/editor/language/outline/TreeSitterOutlineQueryTest.kt
@@ -0,0 +1,57 @@
+package com.itsaky.androidide.editor.language.outline
+
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.test.platform.app.InstrumentationRegistry
+import com.google.common.truth.Truth.assertThat
+import com.itsaky.androidide.treesitter.TSLanguage
+import com.itsaky.androidide.treesitter.TSQuery
+import com.itsaky.androidide.treesitter.TSQueryError
+import com.itsaky.androidide.treesitter.TreeSitter
+import com.itsaky.androidide.treesitter.java.TSLanguageJava
+import com.itsaky.androidide.treesitter.kotlin.TSLanguageKotlin
+import com.itsaky.androidide.treesitter.xml.TSLanguageXml
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+
+@RunWith(AndroidJUnit4::class)
+class TreeSitterOutlineQueryTest {
+	@Before
+	fun loadNative() {
+		TreeSitter.loadLibrary()
+	}
+
+	@Test
+	fun javaOutlineQueryCompiles() {
+		assertCompiles("java", TSLanguageJava.getInstance())
+	}
+
+	@Test
+	fun kotlinOutlineQueryCompiles() {
+		assertCompiles("kt", TSLanguageKotlin.getInstance())
+	}
+
+	@Test
+	fun xmlOutlineQueryCompiles() {
+		assertCompiles("xml", TSLanguageXml.getInstance())
+	}
+
+	private fun assertCompiles(
+		type: String,
+		language: TSLanguage,
+	) {
+		val context = InstrumentationRegistry.getInstrumentation().targetContext
+		val scm =
+			context.assets
+				.open("editor/treesitter/$type/outline.scm")
+				.reader()
+				.readText()
+		val query = TSQuery.create(language, scm)
+		try {
+			assertThat(query.errorType).isEqualTo(TSQueryError.None)
+			assertThat(query.patternCount).isGreaterThan(0)
+		} finally {
+			query.close()
+		}
+	}
+}
diff --git a/editor/src/main/assets/editor/treesitter/java/outline.scm b/editor/src/main/assets/editor/treesitter/java/outline.scm
new file mode 100644
index 0000000000..913408e580
--- /dev/null
+++ b/editor/src/main/assets/editor/treesitter/java/outline.scm
@@ -0,0 +1,29 @@
+(class_declaration
+  name: (identifier) @name) @symbol.class
+
+(interface_declaration
+  name: (identifier) @name) @symbol.interface
+
+(enum_declaration
+  name: (identifier) @name) @symbol.enum
+
+(record_declaration
+  name: (identifier) @name) @symbol.record
+
+(annotation_type_declaration
+  name: (identifier) @name) @symbol.annotation
+
+(enum_constant
+  name: (identifier) @name) @symbol.enumMember
+
+(constructor_declaration
+  name: (identifier) @name
+  parameters: (formal_parameters) @detail) @symbol.constructor
+
+(method_declaration
+  name: (identifier) @name
+  parameters: (formal_parameters) @detail) @symbol.method
+
+(field_declaration
+  declarator: (variable_declarator
+    name: (identifier) @name)) @symbol.field
diff --git a/editor/src/main/assets/editor/treesitter/kt/outline.scm b/editor/src/main/assets/editor/treesitter/kt/outline.scm
new file mode 100644
index 0000000000..c515a659f6
--- /dev/null
+++ b/editor/src/main/assets/editor/treesitter/kt/outline.scm
@@ -0,0 +1,27 @@
+(class_declaration
+  (type_identifier) @name) @symbol.class
+
+(object_declaration
+  (type_identifier) @name) @symbol.object
+
+(companion_object) @symbol.companion
+
+(type_alias
+  (type_identifier) @name) @symbol.typeAlias
+
+(enum_entry
+  (simple_identifier) @name) @symbol.enumMember
+
+(function_declaration
+  (simple_identifier) @name
+  (function_value_parameters) @detail) @symbol.method
+
+(secondary_constructor
+  (function_value_parameters) @detail) @symbol.constructor
+
+(property_declaration
+  (variable_declaration
+    (simple_identifier) @name)) @symbol.property
+
+(class_parameter
+  (simple_identifier) @name) @symbol.property
diff --git a/editor/src/main/assets/editor/treesitter/xml/outline.scm b/editor/src/main/assets/editor/treesitter/xml/outline.scm
new file mode 100644
index 0000000000..9404840341
--- /dev/null
+++ b/editor/src/main/assets/editor/treesitter/xml/outline.scm
@@ -0,0 +1,23 @@
+(end_tag_element
+  (tag_start
+    tag_name: (name) @name)) @symbol.element
+
+(empty_element
+  tag_name: (name) @name) @symbol.element
+
+(empty_element
+  tag_name: (name) @name
+  (attribute
+    (xml_attr
+      attr_name: (name) @_a
+      (attr_value) @detail))
+  (#match? @_a "^id$")) @symbol.element
+
+(end_tag_element
+  (tag_start
+    tag_name: (name) @name
+    (attribute
+      (xml_attr
+        attr_name: (name) @_a
+        (attr_value) @detail)))
+  (#match? @_a "^id$")) @symbol.element

From 81c1eb6cbb777f191556eff7c1a80068b9d91531 Mon Sep 17 00:00:00 2001
From: Daniel Alome <astrocoder007@gmail.com>
Date: Wed, 26 Aug 2026 00:26:02 +0100
Subject: [PATCH 03/20] ADFA-2448: Add tree-sitter outline extraction provider

---
 .../outline/TreeSitterOutlineProviderTest.kt  | 172 +++++++++++++++
 .../outline/TreeSitterOutlineProvider.kt      | 202 ++++++++++++++++++
 2 files changed, 374 insertions(+)
 create mode 100644 editor/src/androidTest/java/com/itsaky/androidide/editor/language/outline/TreeSitterOutlineProviderTest.kt
 create mode 100644 editor/src/main/java/com/itsaky/androidide/editor/language/outline/TreeSitterOutlineProvider.kt

diff --git a/editor/src/androidTest/java/com/itsaky/androidide/editor/language/outline/TreeSitterOutlineProviderTest.kt b/editor/src/androidTest/java/com/itsaky/androidide/editor/language/outline/TreeSitterOutlineProviderTest.kt
new file mode 100644
index 0000000000..f9b355e9bf
--- /dev/null
+++ b/editor/src/androidTest/java/com/itsaky/androidide/editor/language/outline/TreeSitterOutlineProviderTest.kt
@@ -0,0 +1,172 @@
+package com.itsaky.androidide.editor.language.outline
+
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.test.platform.app.InstrumentationRegistry
+import com.google.common.truth.Truth.assertThat
+import kotlinx.coroutines.runBlocking
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+
+@RunWith(AndroidJUnit4::class)
+class TreeSitterOutlineProviderTest {
+	private lateinit var provider: TreeSitterOutlineProvider
+
+	private val javaSource =
+		"""
+		public class Main {
+			private int count;
+			public Main() {
+			}
+			public void run(String[] args) {
+			}
+			interface Inner {
+				void call();
+			}
+			enum Kind {
+				LOCAL, REMOTE
+			}
+		}
+		""".trimIndent()
+
+	private val kotlinSource =
+		"""
+		class Repo(val name: String) {
+			companion object {
+				val EMPTY = Repo("")
+			}
+			var count = 0
+			fun add(item: String): Boolean {
+				return true
+			}
+			constructor(name: String, count: Int) : this(name) {
+				this.count = count
+			}
+		}
+		fun topLevel() {
+		}
+		""".trimIndent()
+
+	private val xmlSource =
+		"""
+		<LinearLayout>
+			<TextView android:id="@+id/title" />
+			<FrameLayout>
+				<Button android:id="@+id/submit" />
+			</FrameLayout>
+			<View />
+		</LinearLayout>
+		""".trimIndent()
+
+	@Before
+	fun setUp() {
+		provider =
+			TreeSitterOutlineProvider(
+				InstrumentationRegistry.getInstrumentation().targetContext,
+			)
+	}
+
+	@Test
+	fun supportsExactlyTheConfiguredExtensions() {
+		assertThat(provider.supports("java")).isTrue()
+		assertThat(provider.supports("kt")).isTrue()
+		assertThat(provider.supports("kts")).isTrue()
+		assertThat(provider.supports("xml")).isTrue()
+		assertThat(provider.supports("XML")).isTrue()
+		assertThat(provider.supports("json")).isFalse()
+		assertThat(provider.supports("gradle")).isFalse()
+		assertThat(provider.supports("")).isFalse()
+	}
+
+	@Test
+	fun javaOutlineHasExpectedStructure() =
+		runBlocking<Unit> {
+			val roots = provider.outlineOf("java", javaSource)
+			assertThat(roots).hasSize(1)
+			val main = roots[0]
+			assertThat(main.name).isEqualTo("Main")
+			assertThat(main.kind).isEqualTo(OutlineSymbolKind.CLASS)
+			assertThat(main.children.map { it.name })
+				.containsExactly("count", "Main", "run", "Inner", "Kind")
+				.inOrder()
+			assertThat(main.children.map { it.kind })
+				.containsExactly(
+					OutlineSymbolKind.FIELD,
+					OutlineSymbolKind.CONSTRUCTOR,
+					OutlineSymbolKind.METHOD,
+					OutlineSymbolKind.INTERFACE,
+					OutlineSymbolKind.ENUM,
+				).inOrder()
+			val run = main.children[2]
+			assertThat(run.detail).isEqualTo("(String[] args)")
+			val inner = main.children[3]
+			assertThat(inner.children.map { it.name }).containsExactly("call")
+			val kind = main.children[4]
+			assertThat(kind.children.map { it.name }).containsExactly("LOCAL", "REMOTE").inOrder()
+			assertThat(kind.children.map { it.kind }.toSet())
+				.containsExactly(OutlineSymbolKind.ENUM_MEMBER)
+		}
+
+	@Test
+	fun columnsAreCharacterColumnsNotBytes() =
+		runBlocking<Unit> {
+			val roots = provider.outlineOf("java", javaSource)
+			val run = roots[0].children.first { it.name == "run" }
+			assertThat(run.selectionRange.start.line).isEqualTo(4)
+			assertThat(run.selectionRange.start.column).isEqualTo(13)
+		}
+
+	@Test
+	fun kotlinOutlineHasExpectedStructure() =
+		runBlocking<Unit> {
+			val roots = provider.outlineOf("kt", kotlinSource)
+			assertThat(roots.map { it.name }).containsExactly("Repo", "topLevel").inOrder()
+			val repo = roots[0]
+			assertThat(repo.kind).isEqualTo(OutlineSymbolKind.CLASS)
+			val childNames = repo.children.map { it.name }
+			assertThat(childNames)
+				.containsExactly("name", "companion object", "count", "add", "constructor")
+				.inOrder()
+			val companion = repo.children[1]
+			assertThat(companion.kind).isEqualTo(OutlineSymbolKind.COMPANION)
+			assertThat(companion.children.map { it.name }).containsExactly("EMPTY")
+			val add = repo.children[3]
+			assertThat(add.kind).isEqualTo(OutlineSymbolKind.METHOD)
+			assertThat(add.detail).isEqualTo("(item: String)")
+			val ctor = repo.children[4]
+			assertThat(ctor.kind).isEqualTo(OutlineSymbolKind.CONSTRUCTOR)
+		}
+
+	@Test
+	fun xmlOutlineNestsElementsAndShowsIds() =
+		runBlocking<Unit> {
+			val roots = provider.outlineOf("xml", xmlSource)
+			assertThat(roots).hasSize(1)
+			val root = roots[0]
+			assertThat(root.name).isEqualTo("LinearLayout")
+			assertThat(root.kind).isEqualTo(OutlineSymbolKind.ELEMENT)
+			assertThat(root.detail).isNull()
+			assertThat(root.children.map { it.name })
+				.containsExactly("TextView", "FrameLayout", "View")
+				.inOrder()
+			assertThat(root.children[0].detail).isEqualTo("@+id/title")
+			assertThat(root.children[1].children.map { it.name }).containsExactly("Button")
+			assertThat(root.children[1].children[0].detail).isEqualTo("@+id/submit")
+			assertThat(root.children[2].detail).isNull()
+		}
+
+	@Test
+	fun emptySourceProducesEmptyOutline() =
+		runBlocking<Unit> {
+			assertThat(provider.outlineOf("java", "")).isEmpty()
+		}
+
+	@Test
+	fun repeatedCallsAreStable() =
+		runBlocking<Unit> {
+			val first = provider.outlineOf("java", javaSource)
+			repeat(25) {
+				assertThat(provider.outlineOf("java", javaSource)).isEqualTo(first)
+			}
+		}
+}
diff --git a/editor/src/main/java/com/itsaky/androidide/editor/language/outline/TreeSitterOutlineProvider.kt b/editor/src/main/java/com/itsaky/androidide/editor/language/outline/TreeSitterOutlineProvider.kt
new file mode 100644
index 0000000000..2dd0ea785b
--- /dev/null
+++ b/editor/src/main/java/com/itsaky/androidide/editor/language/outline/TreeSitterOutlineProvider.kt
@@ -0,0 +1,202 @@
+package com.itsaky.androidide.editor.language.outline
+
+import android.content.Context
+import com.itsaky.androidide.editor.language.treesitter.predicates.AnyOfPredicate
+import com.itsaky.androidide.editor.language.treesitter.predicates.EqualPredicate
+import com.itsaky.androidide.editor.language.treesitter.predicates.MatchPredicate
+import com.itsaky.androidide.editor.language.treesitter.predicates.NotEqualPredicate
+import com.itsaky.androidide.editor.language.treesitter.predicates.NotMatchPredicate
+import com.itsaky.androidide.models.Position
+import com.itsaky.androidide.models.Range
+import com.itsaky.androidide.treesitter.TSLanguage
+import com.itsaky.androidide.treesitter.TSNode
+import com.itsaky.androidide.treesitter.TSParser
+import com.itsaky.androidide.treesitter.TSQuery
+import com.itsaky.androidide.treesitter.TSQueryCursor
+import com.itsaky.androidide.treesitter.TSQueryError
+import com.itsaky.androidide.treesitter.TSTree
+import com.itsaky.androidide.treesitter.TreeSitter
+import com.itsaky.androidide.treesitter.api.safeExecQueryCursor
+import com.itsaky.androidide.treesitter.java.TSLanguageJava
+import com.itsaky.androidide.treesitter.kotlin.TSLanguageKotlin
+import com.itsaky.androidide.treesitter.xml.TSLanguageXml
+import io.github.rosemoe.sora.editor.ts.predicate.Predicator
+import java.util.concurrent.ConcurrentHashMap
+
+class TreeSitterOutlineProvider(
+	context: Context,
+) : OutlineProvider {
+	private val appContext = context.applicationContext
+
+	private val queriesByType = ConcurrentHashMap<String, LanguageQueries>()
+
+	private val predicates =
+		listOf(
+			MatchPredicate,
+			NotMatchPredicate,
+			EqualPredicate,
+			NotEqualPredicate,
+			AnyOfPredicate,
+		)
+
+	private class LanguageQueries(
+		val language: TSLanguage,
+		val query: TSQuery,
+		val predicator: Predicator,
+	)
+
+	companion object {
+		private const val BASE_PATH = "editor/treesitter"
+
+		private val TYPE_BY_EXTENSION =
+			mapOf(
+				"java" to "java",
+				"kt" to "kt",
+				"kts" to "kt",
+				"xml" to "xml",
+			)
+
+		private const val SYMBOL_CAPTURE_PREFIX = "symbol."
+		private const val NAME_CAPTURE = "name"
+		private const val DETAIL_CAPTURE = "detail"
+
+		init {
+			TreeSitter.loadLibrary()
+		}
+	}
+
+	override fun supports(fileExtension: String): Boolean = fileExtension.lowercase() in TYPE_BY_EXTENSION
+
+	override suspend fun outlineOf(
+		fileExtension: String,
+		text: CharSequence,
+	): List<OutlineSymbol> {
+		val type =
+			TYPE_BY_EXTENSION[fileExtension.lowercase()]
+				?: throw IllegalArgumentException("No outline support for file extension '$fileExtension'")
+		val queries = queriesByType.computeIfAbsent(type) { loadQueries(it) }
+		val source = text.toString()
+		return TSParser.create().use { parser ->
+			parser.language = queries.language
+			parser.parseString(source).use { tree ->
+				extract(queries, tree, source)
+			}
+		}
+	}
+
+	private fun loadQueries(type: String): LanguageQueries {
+		val scm =
+			appContext.assets
+				.open("$BASE_PATH/$type/outline.scm")
+				.reader()
+				.readText()
+		val language = languageFor(type)
+		val query = TSQuery.create(language, scm)
+		if (query.errorType != TSQueryError.None) {
+			throw IllegalArgumentException(
+				"outline.scm for '$type' failed to parse: ${query.errorType.name} at byte offset ${query.errorOffset}",
+			)
+		}
+		return LanguageQueries(language, query, Predicator(query))
+	}
+
+	private fun languageFor(type: String): TSLanguage =
+		when (type) {
+			"java" -> TSLanguageJava.getInstance()
+			"kt" -> TSLanguageKotlin.getInstance()
+			"xml" -> TSLanguageXml.getInstance()
+			else -> throw IllegalArgumentException("Unknown outline language type '$type'")
+		}
+
+	private fun extract(
+		queries: LanguageQueries,
+		tree: TSTree,
+		source: String,
+	): List<OutlineSymbol> {
+		val rawByNode = LinkedHashMap<Pair<Int, Int>, RawOutlineSymbol>()
+		TSQueryCursor.create().use { cursor ->
+			cursor.safeExecQueryCursor(
+				query = queries.query,
+				tree = tree,
+				recycleNodeAfterUse = true,
+				debugName = "TreeSitterOutlineProvider.extract()",
+			) { match ->
+				if (!queries.predicator.doPredicate(predicates, source, match)) {
+					return@safeExecQueryCursor
+				}
+				var kind: OutlineSymbolKind? = null
+				var symbolStartByte = 0
+				var symbolEndByte = 0
+				var symbolRange: Range? = null
+				var name: String? = null
+				var selectionRange: Range? = null
+				var detail: String? = null
+				match.captures.forEach { capture ->
+					val captureName = queries.query.getCaptureNameForId(capture.index)
+					val node = capture.node
+					when {
+						captureName.startsWith(SYMBOL_CAPTURE_PREFIX) -> {
+							kind = kindOf(captureName.removePrefix(SYMBOL_CAPTURE_PREFIX))
+							symbolStartByte = node.startByte
+							symbolEndByte = node.endByte
+							symbolRange = rangeOf(node)
+						}
+
+						captureName == NAME_CAPTURE -> {
+							name = textOf(node, source)
+							selectionRange = rangeOf(node)
+						}
+
+						captureName == DETAIL_CAPTURE -> {
+							detail = textOf(node, source).trim('"', '\'')
+						}
+					}
+				}
+				val resolvedKind = kind ?: return@safeExecQueryCursor
+				val range = symbolRange ?: return@safeExecQueryCursor
+				val resolvedName = name ?: defaultNameFor(resolvedKind) ?: return@safeExecQueryCursor
+				val raw =
+					RawOutlineSymbol(
+						name = resolvedName,
+						detail = detail,
+						kind = resolvedKind,
+						range = range,
+						selectionRange = selectionRange ?: Range(range.start, range.start),
+					)
+				val key = symbolStartByte to symbolEndByte
+				val existing = rawByNode[key]
+				if (existing == null || (existing.detail == null && raw.detail != null)) {
+					rawByNode[key] = raw
+				}
+			}
+		}
+		return OutlineTreeBuilder.build(rawByNode.values.toList())
+	}
+
+	private fun kindOf(suffix: String): OutlineSymbolKind {
+		val constantName = suffix.replace(Regex("([a-z])([A-Z])"), "$1_$2").uppercase()
+		return OutlineSymbolKind.entries.find { it.name == constantName }
+			?: throw IllegalArgumentException("Unknown outline symbol kind capture '@symbol.$suffix'")
+	}
+
+	private fun defaultNameFor(kind: OutlineSymbolKind): String? =
+		when (kind) {
+			OutlineSymbolKind.COMPANION -> "companion object"
+			OutlineSymbolKind.CONSTRUCTOR -> "constructor"
+			else -> null
+		}
+
+	private fun textOf(
+		node: TSNode,
+		source: String,
+	): String = source.substring(node.startByte / 2, node.endByte / 2)
+
+	private fun rangeOf(node: TSNode): Range {
+		val start = node.startPoint
+		val end = node.endPoint
+		return Range(
+			Position(start.row, start.column / 2, node.startByte / 2),
+			Position(end.row, end.column / 2, node.endByte / 2),
+		)
+	}
+}

From dbb0a1a57a54ecb65c146c7d3622487440b966a0 Mon Sep 17 00:00:00 2001
From: Daniel Alome <astrocoder007@gmail.com>
Date: Wed, 26 Aug 2026 00:26:02 +0100
Subject: [PATCH 04/20] ADFA-2448: Add outline UDF state types and view model

---
 .../androidide/ui/models/OutlineUiState.kt    |  42 ++++
 .../androidide/viewmodel/OutlineViewModel.kt  | 113 ++++++++++
 .../viewmodel/OutlineViewModelTest.kt         | 194 ++++++++++++++++++
 3 files changed, 349 insertions(+)
 create mode 100644 app/src/main/java/com/itsaky/androidide/ui/models/OutlineUiState.kt
 create mode 100644 app/src/main/java/com/itsaky/androidide/viewmodel/OutlineViewModel.kt
 create mode 100644 app/src/test/java/com/itsaky/androidide/viewmodel/OutlineViewModelTest.kt

diff --git a/app/src/main/java/com/itsaky/androidide/ui/models/OutlineUiState.kt b/app/src/main/java/com/itsaky/androidide/ui/models/OutlineUiState.kt
new file mode 100644
index 0000000000..d1cc18e5a5
--- /dev/null
+++ b/app/src/main/java/com/itsaky/androidide/ui/models/OutlineUiState.kt
@@ -0,0 +1,42 @@
+package com.itsaky.androidide.ui.models
+
+import com.itsaky.androidide.editor.language.outline.OutlineSymbol
+import com.itsaky.androidide.models.Position
+
+sealed interface OutlineUiState {
+	data object NoFileOpen : OutlineUiState
+
+	data class Unsupported(
+		val fileName: String,
+	) : OutlineUiState
+
+	data class Loading(
+		val fileName: String,
+	) : OutlineUiState
+
+	data class Empty(
+		val fileName: String,
+	) : OutlineUiState
+
+	data class Content(
+		val fileName: String,
+		val symbols: List<OutlineSymbol>,
+		val collapsedPaths: Set<String>,
+	) : OutlineUiState
+}
+
+sealed interface OutlineUiEvent {
+	data class SymbolClicked(
+		val symbol: OutlineSymbol,
+	) : OutlineUiEvent
+
+	data class ToggleCollapsed(
+		val path: String,
+	) : OutlineUiEvent
+}
+
+sealed interface OutlineUiEffect {
+	data class NavigateTo(
+		val position: Position,
+	) : OutlineUiEffect
+}
diff --git a/app/src/main/java/com/itsaky/androidide/viewmodel/OutlineViewModel.kt b/app/src/main/java/com/itsaky/androidide/viewmodel/OutlineViewModel.kt
new file mode 100644
index 0000000000..915a5e6a32
--- /dev/null
+++ b/app/src/main/java/com/itsaky/androidide/viewmodel/OutlineViewModel.kt
@@ -0,0 +1,113 @@
+package com.itsaky.androidide.viewmodel
+
+import androidx.lifecycle.ViewModel
+import androidx.lifecycle.viewModelScope
+import com.itsaky.androidide.editor.language.outline.OutlineProvider
+import com.itsaky.androidide.ui.models.OutlineUiEffect
+import com.itsaky.androidide.ui.models.OutlineUiEvent
+import com.itsaky.androidide.ui.models.OutlineUiState
+import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.FlowPreview
+import kotlinx.coroutines.flow.MutableSharedFlow
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.asSharedFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.collectLatest
+import kotlinx.coroutines.flow.debounce
+import kotlinx.coroutines.flow.update
+import kotlinx.coroutines.launch
+
+class OutlineViewModel(
+	private val outlineProvider: OutlineProvider,
+	private val computeDispatcher: CoroutineDispatcher = Dispatchers.Default,
+) : ViewModel() {
+	private data class Snapshot(
+		val fileName: String,
+		val extension: String,
+		val text: String,
+		val immediate: Boolean,
+	)
+
+	private val snapshots = MutableStateFlow<Snapshot?>(null)
+
+	private val _uiState = MutableStateFlow<OutlineUiState>(OutlineUiState.NoFileOpen)
+	val uiState = _uiState.asStateFlow()
+
+	private val _effects = MutableSharedFlow<OutlineUiEffect>()
+	val effects = _effects.asSharedFlow()
+
+	private var collapsedPaths = emptySet<String>()
+	private var collapsedForFile: String? = null
+
+	companion object {
+		private const val DEBOUNCE_MILLIS = 250L
+	}
+
+	init {
+		viewModelScope.launch(computeDispatcher) {
+			@OptIn(FlowPreview::class)
+			snapshots
+				.debounce { snapshot ->
+					if (snapshot == null || snapshot.immediate) 0L else DEBOUNCE_MILLIS
+				}.collectLatest { snapshot -> compute(snapshot) }
+		}
+	}
+
+	fun onSnapshot(
+		fileName: String,
+		extension: String,
+		text: String,
+		immediate: Boolean,
+	) {
+		snapshots.value = Snapshot(fileName, extension, text, immediate)
+	}
+
+	fun onNoEditor() {
+		snapshots.value = null
+	}
+
+	fun onEvent(event: OutlineUiEvent) {
+		when (event) {
+			is OutlineUiEvent.SymbolClicked -> {
+				viewModelScope.launch {
+					_effects.emit(OutlineUiEffect.NavigateTo(event.symbol.selectionRange.start))
+				}
+			}
+
+			is OutlineUiEvent.ToggleCollapsed -> {
+				toggleCollapsed(event.path)
+			}
+		}
+	}
+
+	private suspend fun compute(snapshot: Snapshot?) {
+		if (snapshot == null) {
+			_uiState.value = OutlineUiState.NoFileOpen
+			return
+		}
+		if (!outlineProvider.supports(snapshot.extension)) {
+			_uiState.value = OutlineUiState.Unsupported(snapshot.fileName)
+			return
+		}
+		if (collapsedForFile != snapshot.fileName) {
+			collapsedForFile = snapshot.fileName
+			collapsedPaths = emptySet()
+			_uiState.value = OutlineUiState.Loading(snapshot.fileName)
+		}
+		val symbols = outlineProvider.outlineOf(snapshot.extension, snapshot.text)
+		_uiState.value =
+			if (symbols.isEmpty()) {
+				OutlineUiState.Empty(snapshot.fileName)
+			} else {
+				OutlineUiState.Content(snapshot.fileName, symbols, collapsedPaths)
+			}
+	}
+
+	private fun toggleCollapsed(path: String) {
+		collapsedPaths = if (path in collapsedPaths) collapsedPaths - path else collapsedPaths + path
+		_uiState.update { state ->
+			if (state is OutlineUiState.Content) state.copy(collapsedPaths = collapsedPaths) else state
+		}
+	}
+}
diff --git a/app/src/test/java/com/itsaky/androidide/viewmodel/OutlineViewModelTest.kt b/app/src/test/java/com/itsaky/androidide/viewmodel/OutlineViewModelTest.kt
new file mode 100644
index 0000000000..aedf3b8d86
--- /dev/null
+++ b/app/src/test/java/com/itsaky/androidide/viewmodel/OutlineViewModelTest.kt
@@ -0,0 +1,194 @@
+package com.itsaky.androidide.viewmodel
+
+import com.google.common.truth.Truth.assertThat
+import com.itsaky.androidide.editor.language.outline.OutlineProvider
+import com.itsaky.androidide.editor.language.outline.OutlineSymbol
+import com.itsaky.androidide.editor.language.outline.OutlineSymbolKind
+import com.itsaky.androidide.models.Position
+import com.itsaky.androidide.models.Range
+import com.itsaky.androidide.ui.models.OutlineUiEffect
+import com.itsaky.androidide.ui.models.OutlineUiEvent
+import com.itsaky.androidide.ui.models.OutlineUiState
+import kotlinx.coroutines.CompletableDeferred
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.test.TestScope
+import kotlinx.coroutines.test.UnconfinedTestDispatcher
+import kotlinx.coroutines.test.advanceTimeBy
+import kotlinx.coroutines.test.advanceUntilIdle
+import kotlinx.coroutines.test.runTest
+import org.junit.Rule
+import org.junit.Test
+
+@OptIn(ExperimentalCoroutinesApi::class)
+class OutlineViewModelTest {
+	@get:Rule
+	val mainDispatcherRule = MainDispatcherRule()
+
+	private class FakeOutlineProvider : OutlineProvider {
+		var symbols: List<OutlineSymbol> = emptyList()
+		var callCount = 0
+		var gate: CompletableDeferred<Unit>? = null
+
+		override fun supports(fileExtension: String) = fileExtension == "java"
+
+		override suspend fun outlineOf(
+			fileExtension: String,
+			text: CharSequence,
+		): List<OutlineSymbol> {
+			callCount++
+			gate?.await()
+			return symbols
+		}
+	}
+
+	private fun symbol(
+		name: String,
+		start: Int = 0,
+		end: Int = 100,
+	) = OutlineSymbol(
+		name = name,
+		detail = null,
+		kind = OutlineSymbolKind.CLASS,
+		range = Range(Position(0, 0, start), Position(9, 0, end)),
+		selectionRange =
+			Range(
+				Position(0, 6, start + 6),
+				Position(0, 6 + name.length, start + 6 + name.length),
+			),
+		children = emptyList(),
+	)
+
+	private fun TestScope.viewModel(provider: FakeOutlineProvider) = OutlineViewModel(provider, UnconfinedTestDispatcher(testScheduler))
+
+	@Test
+	fun `initial state is NoFileOpen`() =
+		runTest {
+			val vm = viewModel(FakeOutlineProvider())
+			assertThat(vm.uiState.value).isEqualTo(OutlineUiState.NoFileOpen)
+		}
+
+	@Test
+	fun `unsupported extension yields Unsupported`() =
+		runTest {
+			val vm = viewModel(FakeOutlineProvider())
+			vm.onSnapshot("build.gradle", "gradle", "task a {}", immediate = true)
+			advanceUntilIdle()
+			assertThat(vm.uiState.value).isEqualTo(OutlineUiState.Unsupported("build.gradle"))
+		}
+
+	@Test
+	fun `immediate snapshot with symbols yields Content without debounce delay`() =
+		runTest {
+			val provider = FakeOutlineProvider().apply { symbols = listOf(symbol("Main")) }
+			val vm = viewModel(provider)
+			vm.onSnapshot("Main.java", "java", "class Main {}", immediate = true)
+			advanceTimeBy(1)
+			val state = vm.uiState.value
+			assertThat(state).isInstanceOf(OutlineUiState.Content::class.java)
+			assertThat((state as OutlineUiState.Content).symbols.map { it.name })
+				.containsExactly("Main")
+		}
+
+	@Test
+	fun `no symbols yields Empty`() =
+		runTest {
+			val vm = viewModel(FakeOutlineProvider())
+			vm.onSnapshot("Main.java", "java", "", immediate = true)
+			advanceUntilIdle()
+			assertThat(vm.uiState.value).isEqualTo(OutlineUiState.Empty("Main.java"))
+		}
+
+	@Test
+	fun `rapid edits coalesce into one computation`() =
+		runTest {
+			val provider = FakeOutlineProvider().apply { symbols = listOf(symbol("Main")) }
+			val vm = viewModel(provider)
+			vm.onSnapshot("Main.java", "java", "class Main {}", immediate = true)
+			advanceUntilIdle()
+			val callsAfterSeed = provider.callCount
+			vm.onSnapshot("Main.java", "java", "class Main {a}", immediate = false)
+			advanceTimeBy(100)
+			vm.onSnapshot("Main.java", "java", "class Main {ab}", immediate = false)
+			advanceTimeBy(100)
+			vm.onSnapshot("Main.java", "java", "class Main {abc}", immediate = false)
+			advanceUntilIdle()
+			assertThat(provider.callCount).isEqualTo(callsAfterSeed + 1)
+		}
+
+	@Test
+	fun `collapse survives a re-parse of the same file`() =
+		runTest {
+			val provider = FakeOutlineProvider().apply { symbols = listOf(symbol("Main")) }
+			val vm = viewModel(provider)
+			vm.onSnapshot("Main.java", "java", "v1", immediate = true)
+			advanceUntilIdle()
+			vm.onEvent(OutlineUiEvent.ToggleCollapsed("Main"))
+			assertThat((vm.uiState.value as OutlineUiState.Content).collapsedPaths)
+				.containsExactly("Main")
+			vm.onSnapshot("Main.java", "java", "v2", immediate = false)
+			advanceUntilIdle()
+			assertThat((vm.uiState.value as OutlineUiState.Content).collapsedPaths)
+				.containsExactly("Main")
+		}
+
+	@Test
+	fun `switching files shows Loading while computing and resets collapse state`() =
+		runTest {
+			val provider = FakeOutlineProvider().apply { symbols = listOf(symbol("Main")) }
+			val vm = viewModel(provider)
+			vm.onSnapshot("Main.java", "java", "v1", immediate = true)
+			advanceUntilIdle()
+			vm.onEvent(OutlineUiEvent.ToggleCollapsed("Main"))
+			provider.gate = CompletableDeferred()
+			vm.onSnapshot("Other.java", "java", "v1", immediate = true)
+			advanceUntilIdle()
+			assertThat(vm.uiState.value).isEqualTo(OutlineUiState.Loading("Other.java"))
+			provider.gate!!.complete(Unit)
+			advanceUntilIdle()
+			assertThat((vm.uiState.value as OutlineUiState.Content).collapsedPaths).isEmpty()
+		}
+
+	@Test
+	fun `re-parse of same file keeps previous content visible while computing`() =
+		runTest {
+			val provider = FakeOutlineProvider().apply { symbols = listOf(symbol("Main")) }
+			val vm = viewModel(provider)
+			vm.onSnapshot("Main.java", "java", "v1", immediate = true)
+			advanceUntilIdle()
+			provider.gate = CompletableDeferred()
+			vm.onSnapshot("Main.java", "java", "v2", immediate = false)
+			advanceUntilIdle()
+			assertThat(vm.uiState.value).isInstanceOf(OutlineUiState.Content::class.java)
+			provider.gate!!.complete(Unit)
+			advanceUntilIdle()
+			assertThat(vm.uiState.value).isInstanceOf(OutlineUiState.Content::class.java)
+		}
+
+	@Test
+	fun `symbol click emits NavigateTo the selection start`() =
+		runTest {
+			val target = symbol("Main")
+			val vm = viewModel(FakeOutlineProvider())
+			val effects = mutableListOf<OutlineUiEffect>()
+			backgroundScope.launch(UnconfinedTestDispatcher(testScheduler)) {
+				vm.effects.collect { effects.add(it) }
+			}
+			vm.onEvent(OutlineUiEvent.SymbolClicked(target))
+			advanceUntilIdle()
+			assertThat(effects)
+				.containsExactly(OutlineUiEffect.NavigateTo(target.selectionRange.start))
+		}
+
+	@Test
+	fun `onNoEditor returns to NoFileOpen`() =
+		runTest {
+			val provider = FakeOutlineProvider().apply { symbols = listOf(symbol("Main")) }
+			val vm = viewModel(provider)
+			vm.onSnapshot("Main.java", "java", "v1", immediate = true)
+			advanceUntilIdle()
+			vm.onNoEditor()
+			advanceUntilIdle()
+			assertThat(vm.uiState.value).isEqualTo(OutlineUiState.NoFileOpen)
+		}
+}

From 931f720cc9890edf61f4a705b06af100b64a1836 Mon Sep 17 00:00:00 2001
From: Daniel Alome <astrocoder007@gmail.com>
Date: Wed, 26 Aug 2026 00:26:02 +0100
Subject: [PATCH 05/20] ADFA-2448: Add outline Compose panel and row flattening

---
 app/build.gradle.kts                          |   1 +
 .../androidide/ui/outline/OutlinePanel.kt     | 179 ++++++++++++++++++
 .../androidide/ui/outline/OutlineRows.kt      |  43 +++++
 .../androidide/ui/outline/OutlineRowsTest.kt  |  65 +++++++
 resources/src/main/res/values/strings.xml     |   7 +
 5 files changed, 295 insertions(+)
 create mode 100644 app/src/main/java/com/itsaky/androidide/ui/outline/OutlinePanel.kt
 create mode 100644 app/src/main/java/com/itsaky/androidide/ui/outline/OutlineRows.kt
 create mode 100644 app/src/test/java/com/itsaky/androidide/ui/outline/OutlineRowsTest.kt

diff --git a/app/build.gradle.kts b/app/build.gradle.kts
index b21c2d872f..5b5f2dce5a 100644
--- a/app/build.gradle.kts
+++ b/app/build.gradle.kts
@@ -307,6 +307,7 @@ dependencies {
 	implementation(libs.compose.material3)
 	implementation(libs.compose.activity)
 	implementation(libs.compose.lifecycle.runtime)
+	implementation(projects.commonCompose)
 	implementation(libs.compose.ui.tooling.preview)
 	debugImplementation(libs.compose.ui.tooling)
 
diff --git a/app/src/main/java/com/itsaky/androidide/ui/outline/OutlinePanel.kt b/app/src/main/java/com/itsaky/androidide/ui/outline/OutlinePanel.kt
new file mode 100644
index 0000000000..ab6eb6100d
--- /dev/null
+++ b/app/src/main/java/com/itsaky/androidide/ui/outline/OutlinePanel.kt
@@ -0,0 +1,179 @@
+package com.itsaky.androidide.ui.outline
+
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.lazy.LazyColumn
+import androidx.compose.foundation.lazy.items
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.ArrowDropDown
+import androidx.compose.material3.Icon
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.remember
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.rotate
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.semantics.contentDescription
+import androidx.compose.ui.semantics.semantics
+import androidx.compose.ui.text.font.FontFamily
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.text.style.TextOverflow
+import androidx.compose.ui.unit.dp
+import androidx.lifecycle.compose.collectAsStateWithLifecycle
+import com.itsaky.androidide.R
+import com.itsaky.androidide.ui.models.OutlineUiEvent
+import com.itsaky.androidide.ui.models.OutlineUiState
+import com.itsaky.androidide.viewmodel.OutlineViewModel
+
+private const val MAX_INDENT_DEPTH = 6
+private val INDENT_STEP = 14.dp
+
+@Composable
+fun OutlinePanel(
+	viewModel: OutlineViewModel,
+	modifier: Modifier = Modifier,
+) {
+	val state by viewModel.uiState.collectAsStateWithLifecycle()
+	OutlinePanelContent(state = state, onEvent = viewModel::onEvent, modifier = modifier)
+}
+
+@Composable
+internal fun OutlinePanelContent(
+	state: OutlineUiState,
+	onEvent: (OutlineUiEvent) -> Unit,
+	modifier: Modifier = Modifier,
+) {
+	when (state) {
+		is OutlineUiState.NoFileOpen -> {
+			CenteredMessage(stringResource(R.string.outline_no_file_open), modifier)
+		}
+
+		is OutlineUiState.Unsupported -> {
+			CenteredMessage(stringResource(R.string.outline_unsupported, state.fileName), modifier)
+		}
+
+		is OutlineUiState.Loading -> {
+			CenteredMessage(stringResource(R.string.outline_loading), modifier)
+		}
+
+		is OutlineUiState.Empty -> {
+			CenteredMessage(stringResource(R.string.outline_empty), modifier)
+		}
+
+		is OutlineUiState.Content -> {
+			OutlineTree(state, onEvent, modifier)
+		}
+	}
+}
+
+@Composable
+private fun CenteredMessage(
+	message: String,
+	modifier: Modifier = Modifier,
+) {
+	Box(
+		modifier =
+			modifier
+				.fillMaxSize()
+				.padding(24.dp),
+		contentAlignment = Alignment.Center,
+	) {
+		Text(
+			text = message,
+			style = MaterialTheme.typography.bodyMedium,
+			color = MaterialTheme.colorScheme.onSurfaceVariant,
+		)
+	}
+}
+
+@Composable
+private fun OutlineTree(
+	state: OutlineUiState.Content,
+	onEvent: (OutlineUiEvent) -> Unit,
+	modifier: Modifier = Modifier,
+) {
+	val rows =
+		remember(state.symbols, state.collapsedPaths) {
+			flattenOutline(state.symbols, state.collapsedPaths)
+		}
+	LazyColumn(modifier = modifier.fillMaxSize()) {
+		items(rows, key = { it.path }) { row ->
+			OutlineRow(row = row, onEvent = onEvent)
+		}
+	}
+}
+
+@Composable
+private fun OutlineRow(
+	row: OutlineRowModel,
+	onEvent: (OutlineUiEvent) -> Unit,
+	modifier: Modifier = Modifier,
+) {
+	val symbol = row.symbol
+	val kindLabel =
+		symbol.kind.name
+			.lowercase()
+			.replace('_', ' ')
+	val rowDescription = listOfNotNull(kindLabel, symbol.name, symbol.detail).joinToString(", ")
+	val indent = INDENT_STEP * minOf(row.depth, MAX_INDENT_DEPTH)
+	Row(
+		verticalAlignment = Alignment.CenterVertically,
+		modifier =
+			modifier
+				.fillMaxWidth()
+				.clickable { onEvent(OutlineUiEvent.SymbolClicked(symbol)) }
+				.padding(start = 4.dp + indent, top = 8.dp, bottom = 8.dp, end = 12.dp)
+				.semantics { contentDescription = rowDescription },
+	) {
+		if (row.hasChildren) {
+			val toggleDescription =
+				stringResource(
+					if (row.collapsed) R.string.cd_outline_expand else R.string.cd_outline_collapse,
+				)
+			Icon(
+				imageVector = Icons.Filled.ArrowDropDown,
+				contentDescription = toggleDescription,
+				modifier =
+					Modifier
+						.size(24.dp)
+						.rotate(if (row.collapsed) -90f else 0f)
+						.clickable { onEvent(OutlineUiEvent.ToggleCollapsed(row.path)) },
+			)
+		} else {
+			Spacer(modifier = Modifier.size(24.dp))
+		}
+		Text(
+			text = symbol.kind.badge.toString(),
+			fontFamily = FontFamily.Monospace,
+			fontWeight = FontWeight.Bold,
+			style = MaterialTheme.typography.bodyMedium,
+			color = MaterialTheme.colorScheme.primary,
+			modifier = Modifier.padding(horizontal = 6.dp),
+		)
+		Column(modifier = Modifier.weight(1f)) {
+			Text(
+				text = symbol.name,
+				style = MaterialTheme.typography.bodyMedium,
+			)
+			symbol.detail?.let { detail ->
+				Text(
+					text = detail,
+					style = MaterialTheme.typography.bodySmall,
+					color = MaterialTheme.colorScheme.onSurfaceVariant,
+					maxLines = 1,
+					overflow = TextOverflow.Ellipsis,
+				)
+			}
+		}
+	}
+}
diff --git a/app/src/main/java/com/itsaky/androidide/ui/outline/OutlineRows.kt b/app/src/main/java/com/itsaky/androidide/ui/outline/OutlineRows.kt
new file mode 100644
index 0000000000..1018b99a42
--- /dev/null
+++ b/app/src/main/java/com/itsaky/androidide/ui/outline/OutlineRows.kt
@@ -0,0 +1,43 @@
+package com.itsaky.androidide.ui.outline
+
+import com.itsaky.androidide.editor.language.outline.OutlineSymbol
+
+internal data class OutlineRowModel(
+	val symbol: OutlineSymbol,
+	val path: String,
+	val depth: Int,
+	val hasChildren: Boolean,
+	val collapsed: Boolean,
+)
+
+internal fun flattenOutline(
+	symbols: List<OutlineSymbol>,
+	collapsedPaths: Set<String>,
+): List<OutlineRowModel> {
+	val rows = mutableListOf<OutlineRowModel>()
+
+	fun walk(siblings: List<OutlineSymbol>, parentPath: String, depth: Int) {
+		val occurrences = mutableMapOf<String, Int>()
+		siblings.forEach { symbol ->
+			val n = occurrences.merge(symbol.name, 1, Int::plus)!!
+			val segment = if (n == 1) symbol.name else "${symbol.name}#$n"
+			val path = if (parentPath.isEmpty()) segment else "$parentPath/$segment"
+			val collapsed = path in collapsedPaths
+			rows.add(
+				OutlineRowModel(
+					symbol = symbol,
+					path = path,
+					depth = depth,
+					hasChildren = symbol.children.isNotEmpty(),
+					collapsed = collapsed,
+				),
+			)
+			if (!collapsed) {
+				walk(symbol.children, path, depth + 1)
+			}
+		}
+	}
+
+	walk(symbols, "", 0)
+	return rows
+}
diff --git a/app/src/test/java/com/itsaky/androidide/ui/outline/OutlineRowsTest.kt b/app/src/test/java/com/itsaky/androidide/ui/outline/OutlineRowsTest.kt
new file mode 100644
index 0000000000..b49dfb4fa0
--- /dev/null
+++ b/app/src/test/java/com/itsaky/androidide/ui/outline/OutlineRowsTest.kt
@@ -0,0 +1,65 @@
+package com.itsaky.androidide.ui.outline
+
+import com.google.common.truth.Truth.assertThat
+import com.itsaky.androidide.editor.language.outline.OutlineSymbol
+import com.itsaky.androidide.editor.language.outline.OutlineSymbolKind
+import com.itsaky.androidide.models.Position
+import com.itsaky.androidide.models.Range
+import org.junit.Test
+
+class OutlineRowsTest {
+	private fun symbol(
+		name: String,
+		children: List<OutlineSymbol> = emptyList(),
+	) = OutlineSymbol(
+		name = name,
+		detail = null,
+		kind = OutlineSymbolKind.METHOD,
+		range = Range(Position(0, 0, 0), Position(0, 0, 1)),
+		selectionRange = Range(Position(0, 0, 0), Position(0, 0, 1)),
+		children = children,
+	)
+
+	@Test
+	fun `flattens depth-first with depths`() {
+		val tree = listOf(symbol("a", listOf(symbol("b", listOf(symbol("c"))))), symbol("d"))
+		val rows = flattenOutline(tree, emptySet())
+		assertThat(rows.map { it.symbol.name }).containsExactly("a", "b", "c", "d").inOrder()
+		assertThat(rows.map { it.depth }).containsExactly(0, 1, 2, 0).inOrder()
+	}
+
+	@Test
+	fun `collapsed path hides descendants but keeps the row`() {
+		val tree = listOf(symbol("a", listOf(symbol("b", listOf(symbol("c"))))))
+		val rows = flattenOutline(tree, setOf("a/b"))
+		assertThat(rows.map { it.symbol.name }).containsExactly("a", "b").inOrder()
+		assertThat(rows[1].collapsed).isTrue()
+		assertThat(rows[1].hasChildren).isTrue()
+	}
+
+	@Test
+	fun `same-named siblings get ordinal-suffixed paths`() {
+		val tree = listOf(symbol("cls", listOf(symbol("bind"), symbol("bind"), symbol("other"))))
+		val rows = flattenOutline(tree, emptySet())
+		assertThat(rows.map { it.path })
+			.containsExactly("cls", "cls/bind", "cls/bind#2", "cls/other")
+			.inOrder()
+	}
+
+	@Test
+	fun `paths are unique even in deep duplicate trees`() {
+		val tree =
+			listOf(
+				symbol("a", listOf(symbol("x"))),
+				symbol("a", listOf(symbol("x"))),
+			)
+		val rows = flattenOutline(tree, emptySet())
+		assertThat(rows.map { it.path }.toSet()).hasSize(4)
+	}
+
+	@Test
+	fun `hasChildren reflects the tree not the visibility`() {
+		val rows = flattenOutline(listOf(symbol("leaf")), emptySet())
+		assertThat(rows[0].hasChildren).isFalse()
+	}
+}
diff --git a/resources/src/main/res/values/strings.xml b/resources/src/main/res/values/strings.xml
index ca8fe80b79..0d24d7f6d5 100644
--- a/resources/src/main/res/values/strings.xml
+++ b/resources/src/main/res/values/strings.xml
@@ -1673,4 +1673,11 @@
 	<string name="floating_window_action_dock">Dock to editor</string>
 	<string name="floating_window_action_close">Close</string>
 
+  <string name="title_document_outline">Outline</string>
+  <string name="outline_no_file_open">No file open</string>
+  <string name="outline_unsupported">No outline available for %1$s</string>
+  <string name="outline_empty">No symbols found in this file</string>
+  <string name="outline_loading">Building outline...</string>
+  <string name="cd_outline_expand">Expand</string>
+  <string name="cd_outline_collapse">Collapse</string>
 </resources>

From 7695fd37d5d1ef90ab451f1f05741ca5d8d540fe Mon Sep 17 00:00:00 2001
From: Daniel Alome <astrocoder007@gmail.com>
Date: Tue, 8 Sep 2026 15:32:23 +0100
Subject: [PATCH 06/20] style: spotless reformat EditorSidebarActions, no
 functional change

---
 .../androidide/utils/EditorSidebarActions.kt  | 463 +++++++++---------
 1 file changed, 238 insertions(+), 225 deletions(-)

diff --git a/app/src/main/java/com/itsaky/androidide/utils/EditorSidebarActions.kt b/app/src/main/java/com/itsaky/androidide/utils/EditorSidebarActions.kt
index 39395b33ce..12d342d5cb 100644
--- a/app/src/main/java/com/itsaky/androidide/utils/EditorSidebarActions.kt
+++ b/app/src/main/java/com/itsaky/androidide/utils/EditorSidebarActions.kt
@@ -39,7 +39,9 @@ import com.itsaky.androidide.actions.ActionData
 import com.itsaky.androidide.actions.ActionItem
 import com.itsaky.androidide.actions.ActionsRegistry
 import com.itsaky.androidide.actions.FillMenuParams
+import com.itsaky.androidide.actions.PluginSidebarActionItem
 import com.itsaky.androidide.actions.SidebarActionItem
+import com.itsaky.androidide.actions.SidebarSlotManager
 import com.itsaky.androidide.actions.internal.DefaultActionsRegistry
 import com.itsaky.androidide.actions.sidebar.BuildVariantsSidebarAction
 import com.itsaky.androidide.actions.sidebar.CloseProjectSidebarAction
@@ -47,12 +49,10 @@ import com.itsaky.androidide.actions.sidebar.FileTreeSidebarAction
 import com.itsaky.androidide.actions.sidebar.HelpSideBarAction
 import com.itsaky.androidide.actions.sidebar.PreferencesSidebarAction
 import com.itsaky.androidide.actions.sidebar.TerminalSidebarAction
+import com.itsaky.androidide.eventbus.events.plugin.PluginCrashedEvent
 import com.itsaky.androidide.fragments.sidebar.EditorSidebarFragment
 import com.itsaky.androidide.plugins.extensions.UIExtension
-import com.itsaky.androidide.actions.PluginSidebarActionItem
-import com.itsaky.androidide.actions.SidebarSlotManager
 import com.itsaky.androidide.plugins.manager.core.PluginManager
-import com.itsaky.androidide.eventbus.events.plugin.PluginCrashedEvent
 import org.greenrobot.eventbus.EventBus
 import java.lang.ref.WeakReference
 
@@ -64,228 +64,241 @@ import java.lang.ref.WeakReference
  */
 
 object ContactDetails {
-    const val EMAIL_SUPPORT = "feedback@appdevforall.org"
+	const val EMAIL_SUPPORT = "feedback@appdevforall.org"
 }
 
 internal object EditorSidebarActions {
-
-    private var previousDestinationListener: NavController.OnDestinationChangedListener? = null
-    private var previousNavController: WeakReference<NavController>? = null
-
-    @JvmStatic
-    fun registerActions(context: Context) {
-        val registry = ActionsRegistry.getInstance()
-        var order = -1
-
-        @Suppress("KotlinConstantConditions")
-        registry.registerAction(FileTreeSidebarAction(context, ++order))
-        registry.registerAction(BuildVariantsSidebarAction(context, ++order))
-        registry.registerAction(TerminalSidebarAction(context, ++order))
-        registry.registerAction(PreferencesSidebarAction(context, ++order))
-        registry.registerAction(CloseProjectSidebarAction(context, ++order))
-        registry.registerAction(HelpSideBarAction(context, ++order))
-
-        // Set built-in item count (6 items) for sidebar slot management
-        SidebarSlotManager.setBuiltInItemCount(order + 1)
-
-        // Register plugin sidebar items
-        registerPluginSidebarActions(context, registry, ++order)
-    }
-
-    @JvmStatic
-    fun setup(sidebarFragment: EditorSidebarFragment) {
-        val binding = sidebarFragment.getBinding() ?: return
-        val controller = binding.editorSidebarFragmentContainer.getFragment<NavHostFragment>().navController
-        val context = sidebarFragment.requireContext()
-        val rail = binding.navigation
-
-
-        val registry = ActionsRegistry.getInstance()
-        val actions = registry.getActions(ActionItem.Location.EDITOR_SIDEBAR)
-        if (actions.isEmpty()) {
-            return
-        }
-
-        rail.background = (rail.background as MaterialShapeDrawable).apply {
-            shapeAppearanceModel = shapeAppearanceModel.roundedOnRight()
-        }
-
-        rail.menu.clear()
-
-        val data = ActionData.create(context)
-        val titleRef = WeakReference(binding.title)
-        val params = FillMenuParams(
-            data,
-            ActionItem.Location.EDITOR_SIDEBAR,
-            rail.menu
-        ) { actionsRegistry, action, item, actionsData ->
-            action as SidebarActionItem
-
-            if (action.fragmentClass == null) {
-                (actionsRegistry as DefaultActionsRegistry).executeAction(action, actionsData)
-                return@FillMenuParams true
-            }
-
-            return@FillMenuParams try {
-                controller.navigate(action.id, navOptions {
-                    launchSingleTop = true
-                    restoreState = true
-                })
-
-                val result = controller.currentDestination?.matchDestination(action.id) == true
-                if (result) {
-                    item.isChecked = true
-                    titleRef.get()?.text = item.title
-                }
-
-                result
-            } catch (e: IllegalArgumentException) {
-                false
-            }
-        }
-
-        registry.fillMenu(params)
-
-        rail.menu.forEach { item ->
-            val view = rail.findViewById<View>(item.itemId)
-            val action = actions.values.find { it.itemId == item.itemId } as? SidebarActionItem
-
-            if (view != null && action != null) {
-                val tag = action.retrieveTooltipTag(false)
-                sidebarFragment.setupTooltip(view, tag, action.retrieveTooltipCategory())
-            }
-        }
-
-        controller.graph = controller.createGraph(startDestination = FileTreeSidebarAction.ID) {
-            actions.forEach { (actionId, action) ->
-                if (action !is SidebarActionItem) {
-                    throw IllegalStateException(
-                        "Actions registered at location ${ActionItem.Location.EDITOR_SIDEBAR}" +
-                                " must implement ${SidebarActionItem::class.java.simpleName}"
-                    )
-                }
-
-                val fragment = action.fragmentClass ?: return@forEach
-
-                val builder = FragmentNavigatorDestinationBuilder(
-                    provider[FragmentNavigator::class],
-                    actionId,
-                    fragment
-                )
-
-                builder.apply {
-                    action.apply { buildNavigation() }
-                }
-
-                destination(builder)
-            }
-        }
-
-        previousDestinationListener?.let { stale ->
-            previousNavController?.get()?.removeOnDestinationChangedListener(stale)
-        }
-
-        val railRef = WeakReference(rail)
-        val destinationListener = object : NavController.OnDestinationChangedListener {
-            override fun onDestinationChanged(
-                controller: NavController,
-                destination: NavDestination,
-                arguments: Bundle?
-            ) {
-                val railView = railRef.get()
-                if (railView == null) {
-                    controller.removeOnDestinationChangedListener(this)
-                    return
-                }
-                railView.menu.forEach { item ->
-                    if (destination.matchDestination(item.itemId)) {
-                        item.isChecked = true
-                        titleRef.get()?.text = item.title
-                    }
-                }
-            }
-        }
-        controller.addOnDestinationChangedListener(destinationListener)
-        previousDestinationListener = destinationListener
-        previousNavController = WeakReference(controller)
-
-        rail.menu.findItem(FileTreeSidebarAction.ID.hashCode())?.also {
-            it.isChecked = true
-            binding.title.text = it.title
-        }
-    }
-
-    /**
-     * Determines whether the given `route` matches the NavDestination. This handles
-     * both the default case (the destination's route matches the given route) and the nested case where
-     * the given route is a parent/grandparent/etc of the destination.
-     */
-    @JvmStatic
-    internal fun NavDestination.matchDestination(route: String): Boolean =
-        hierarchy.any { it.route == route }
-
-    @JvmStatic
-    internal fun NavDestination.matchDestination(@IdRes destId: Int): Boolean =
-        hierarchy.any { it.id == destId }
-
-    @JvmStatic
-    internal fun ShapeAppearanceModel.roundedOnRight(cornerSize: Float = 28f): ShapeAppearanceModel {
-        return toBuilder().run {
-            setTopRightCorner(CornerFamily.ROUNDED, cornerSize)
-            setBottomRightCorner(CornerFamily.ROUNDED, cornerSize)
-            build()
-        }
-    }
-
-    /**
-     * Register plugin UI contributions to the sidebar.
-     *
-     * @param context The application context
-     * @param registry The actions registry
-     * @param startOrder The starting order for plugin actions
-     */
-    @JvmStatic
-    private fun registerPluginSidebarActions(context: Context, registry: ActionsRegistry, startOrder: Int) {
-        var order = startOrder
-
-        val pluginManager = PluginManager.getInstance() ?: return
-
-        pluginManager.getAllPluginInstances()
-            .filterIsInstance<UIExtension>()
-            .forEach { plugin ->
-                val pluginId = pluginManager.getPluginIdForInstance(plugin as com.itsaky.androidide.plugins.IPlugin)
-                    ?: return@forEach
-
-                try {
-                    val declaredSlots = SidebarSlotManager.getDeclaredSlots(pluginId)
-                    val sideMenuItems = plugin.getSideMenuItems()
-
-                    if (sideMenuItems.isEmpty()) return@forEach
-
-                    if (sideMenuItems.size > declaredSlots) {
-                        Log.w("EditorSidebarActions",
-                            "Plugin '$pluginId' returned ${sideMenuItems.size} sidebar items " +
-                            "but only declared $declaredSlots in manifest — skipping"
-                        )
-                        return@forEach
-                    }
-
-                    sideMenuItems.forEach { navItem ->
-                        val action = PluginSidebarActionItem(context, navItem, order++, pluginId)
-                        registry.registerAction(action)
-                    }
-                } catch (e: Exception) {
-                    Log.e("EditorSidebarActions", "Plugin '$pluginId' crashed in getSideMenuItems()", e)
-                    val result = pluginManager.recordPluginCrash(pluginId)
-                    val wasDisabled = result is PluginManager.CrashResult.Disabled
-                    val crashCount = when (result) {
-                        is PluginManager.CrashResult.Recorded -> result.crashCount
-                        is PluginManager.CrashResult.Disabled -> pluginManager.crashTracker.getCrashCount(pluginId)
-                    }
-                    EventBus.getDefault().post(
-                        PluginCrashedEvent(pluginId, result.pluginName, crashCount, wasDisabled, Log.getStackTraceString(e))
-                    )
-                }
-            }
-    }
-}
\ No newline at end of file
+	private var previousDestinationListener: NavController.OnDestinationChangedListener? = null
+	private var previousNavController: WeakReference<NavController>? = null
+
+	@JvmStatic
+	fun registerActions(context: Context) {
+		val registry = ActionsRegistry.getInstance()
+		var order = -1
+
+		@Suppress("KotlinConstantConditions")
+		registry.registerAction(FileTreeSidebarAction(context, ++order))
+		registry.registerAction(BuildVariantsSidebarAction(context, ++order))
+		registry.registerAction(TerminalSidebarAction(context, ++order))
+		registry.registerAction(PreferencesSidebarAction(context, ++order))
+		registry.registerAction(CloseProjectSidebarAction(context, ++order))
+		registry.registerAction(HelpSideBarAction(context, ++order))
+
+		// Set built-in item count (6 items) for sidebar slot management
+		SidebarSlotManager.setBuiltInItemCount(order + 1)
+
+		// Register plugin sidebar items
+		registerPluginSidebarActions(context, registry, ++order)
+	}
+
+	@JvmStatic
+	fun setup(sidebarFragment: EditorSidebarFragment) {
+		val binding = sidebarFragment.getBinding() ?: return
+		val controller = binding.editorSidebarFragmentContainer.getFragment<NavHostFragment>().navController
+		val context = sidebarFragment.requireContext()
+		val rail = binding.navigation
+
+		val registry = ActionsRegistry.getInstance()
+		val actions = registry.getActions(ActionItem.Location.EDITOR_SIDEBAR)
+		if (actions.isEmpty()) {
+			return
+		}
+
+		rail.background =
+			(rail.background as MaterialShapeDrawable).apply {
+				shapeAppearanceModel = shapeAppearanceModel.roundedOnRight()
+			}
+
+		rail.menu.clear()
+
+		val data = ActionData.create(context)
+		val titleRef = WeakReference(binding.title)
+		val params =
+			FillMenuParams(
+				data,
+				ActionItem.Location.EDITOR_SIDEBAR,
+				rail.menu,
+			) { actionsRegistry, action, item, actionsData ->
+				action as SidebarActionItem
+
+				if (action.fragmentClass == null) {
+					(actionsRegistry as DefaultActionsRegistry).executeAction(action, actionsData)
+					return@FillMenuParams true
+				}
+
+				return@FillMenuParams try {
+					controller.navigate(
+						action.id,
+						navOptions {
+							launchSingleTop = true
+							restoreState = true
+						},
+					)
+
+					val result = controller.currentDestination?.matchDestination(action.id) == true
+					if (result) {
+						item.isChecked = true
+						titleRef.get()?.text = item.title
+					}
+
+					result
+				} catch (e: IllegalArgumentException) {
+					false
+				}
+			}
+
+		registry.fillMenu(params)
+
+		rail.menu.forEach { item ->
+			val view = rail.findViewById<View>(item.itemId)
+			val action = actions.values.find { it.itemId == item.itemId } as? SidebarActionItem
+
+			if (view != null && action != null) {
+				val tag = action.retrieveTooltipTag(false)
+				sidebarFragment.setupTooltip(view, tag, action.retrieveTooltipCategory())
+			}
+		}
+
+		controller.graph =
+			controller.createGraph(startDestination = FileTreeSidebarAction.ID) {
+				actions.forEach { (actionId, action) ->
+					if (action !is SidebarActionItem) {
+						throw IllegalStateException(
+							"Actions registered at location ${ActionItem.Location.EDITOR_SIDEBAR}" +
+								" must implement ${SidebarActionItem::class.java.simpleName}",
+						)
+					}
+
+					val fragment = action.fragmentClass ?: return@forEach
+
+					val builder =
+						FragmentNavigatorDestinationBuilder(
+							provider[FragmentNavigator::class],
+							actionId,
+							fragment,
+						)
+
+					builder.apply {
+						action.apply { buildNavigation() }
+					}
+
+					destination(builder)
+				}
+			}
+
+		previousDestinationListener?.let { stale ->
+			previousNavController?.get()?.removeOnDestinationChangedListener(stale)
+		}
+
+		val railRef = WeakReference(rail)
+		val destinationListener =
+			object : NavController.OnDestinationChangedListener {
+				override fun onDestinationChanged(
+					controller: NavController,
+					destination: NavDestination,
+					arguments: Bundle?,
+				) {
+					val railView = railRef.get()
+					if (railView == null) {
+						controller.removeOnDestinationChangedListener(this)
+						return
+					}
+					railView.menu.forEach { item ->
+						if (destination.matchDestination(item.itemId)) {
+							item.isChecked = true
+							titleRef.get()?.text = item.title
+						}
+					}
+				}
+			}
+		controller.addOnDestinationChangedListener(destinationListener)
+		previousDestinationListener = destinationListener
+		previousNavController = WeakReference(controller)
+
+		rail.menu.findItem(FileTreeSidebarAction.ID.hashCode())?.also {
+			it.isChecked = true
+			binding.title.text = it.title
+		}
+	}
+
+	/**
+	 * Determines whether the given `route` matches the NavDestination. This handles
+	 * both the default case (the destination's route matches the given route) and the nested case where
+	 * the given route is a parent/grandparent/etc of the destination.
+	 */
+	@JvmStatic
+	internal fun NavDestination.matchDestination(route: String): Boolean = hierarchy.any { it.route == route }
+
+	@JvmStatic
+	internal fun NavDestination.matchDestination(
+		@IdRes destId: Int,
+	): Boolean = hierarchy.any { it.id == destId }
+
+	@JvmStatic
+	internal fun ShapeAppearanceModel.roundedOnRight(cornerSize: Float = 28f): ShapeAppearanceModel =
+		toBuilder().run {
+			setTopRightCorner(CornerFamily.ROUNDED, cornerSize)
+			setBottomRightCorner(CornerFamily.ROUNDED, cornerSize)
+			build()
+		}
+
+	/**
+	 * Register plugin UI contributions to the sidebar.
+	 *
+	 * @param context The application context
+	 * @param registry The actions registry
+	 * @param startOrder The starting order for plugin actions
+	 */
+	@JvmStatic
+	private fun registerPluginSidebarActions(
+		context: Context,
+		registry: ActionsRegistry,
+		startOrder: Int,
+	) {
+		var order = startOrder
+
+		val pluginManager = PluginManager.getInstance() ?: return
+
+		pluginManager
+			.getAllPluginInstances()
+			.filterIsInstance<UIExtension>()
+			.forEach { plugin ->
+				val pluginId =
+					pluginManager.getPluginIdForInstance(plugin as com.itsaky.androidide.plugins.IPlugin)
+						?: return@forEach
+
+				try {
+					val declaredSlots = SidebarSlotManager.getDeclaredSlots(pluginId)
+					val sideMenuItems = plugin.getSideMenuItems()
+
+					if (sideMenuItems.isEmpty()) return@forEach
+
+					if (sideMenuItems.size > declaredSlots) {
+						Log.w(
+							"EditorSidebarActions",
+							"Plugin '$pluginId' returned ${sideMenuItems.size} sidebar items " +
+								"but only declared $declaredSlots in manifest — skipping",
+						)
+						return@forEach
+					}
+
+					sideMenuItems.forEach { navItem ->
+						val action = PluginSidebarActionItem(context, navItem, order++, pluginId)
+						registry.registerAction(action)
+					}
+				} catch (e: Exception) {
+					Log.e("EditorSidebarActions", "Plugin '$pluginId' crashed in getSideMenuItems()", e)
+					val result = pluginManager.recordPluginCrash(pluginId)
+					val wasDisabled = result is PluginManager.CrashResult.Disabled
+					val crashCount =
+						when (result) {
+							is PluginManager.CrashResult.Recorded -> result.crashCount
+							is PluginManager.CrashResult.Disabled -> pluginManager.crashTracker.getCrashCount(pluginId)
+						}
+					EventBus.getDefault().post(
+						PluginCrashedEvent(pluginId, result.pluginName, crashCount, wasDisabled, Log.getStackTraceString(e)),
+					)
+				}
+			}
+	}
+}

From 1f8fa628dccdc71e1ce47bdb8203e8bad0d5f4d6 Mon Sep 17 00:00:00 2001
From: Daniel Alome <astrocoder007@gmail.com>
Date: Wed, 26 Aug 2026 00:26:02 +0100
Subject: [PATCH 07/20] ADFA-2448: Add outline sidebar panel with symbol
 navigation

---
 ARCHITECTURE.md                               |   2 +-
 .../actions/sidebar/OutlineSidebarAction.kt   |  28 ++++
 .../com/itsaky/androidide/di/AppModule.kt     |   5 +
 .../fragments/sidebar/OutlineFragment.kt      | 133 ++++++++++++++++++
 .../androidide/utils/EditorSidebarActions.kt  |   4 +-
 .../androidide/idetooltips/TooltipTag.kt      |   1 +
 .../src/main/res/drawable/ic_outline.xml      |  11 ++
 7 files changed, 182 insertions(+), 2 deletions(-)
 create mode 100644 app/src/main/java/com/itsaky/androidide/actions/sidebar/OutlineSidebarAction.kt
 create mode 100644 app/src/main/java/com/itsaky/androidide/fragments/sidebar/OutlineFragment.kt
 create mode 100644 resources/src/main/res/drawable/ic_outline.xml

diff --git a/ARCHITECTURE.md b/ARCHITECTURE.md
index b07e6867a4..b38503199b 100644
--- a/ARCHITECTURE.md
+++ b/ARCHITECTURE.md
@@ -67,7 +67,7 @@ Strategy: **layer-and-subsystem based**, not feature-by-feature. The Gradle buil
 |---|---|---|
 | Application | `app` | The IDE itself — activities, fragments, services, DI, agent, web server. Wires everything together. |
 | Build engine | `subprojects:tooling-api*`, `gradle-plugin*`, `subprojects:projects`, `subprojects:builder-model-impl` | Runs a real Gradle build of the user's project out-of-process and streams events back. |
-| Language tooling | `lsp:{api,java,kotlin,xml,indexing,refactor-core,ui,…}`, `lexers`, `editor*`, `editor-treesitter` | Language servers, indexing, the Sora-based editor and highlighting. `lsp:refactor-core` holds the language-agnostic half of the refactorings (offset spans, block geometry, rewrite composition, name primitives) so `lsp:java` and `lsp:kotlin` share one copy; `lsp:ui` holds the Compose sheets they share. Neither depends on a language server. |
+| Language tooling | `lsp:{api,java,kotlin,xml,indexing,refactor-core,ui,…}`, `lexers`, `editor*`, `editor-treesitter` | Language servers, indexing, the Sora-based editor and highlighting, and the tree-sitter document outline (`editor/.../language/outline`, rendered by `app`'s sidebar `OutlineFragment`). `lsp:refactor-core` holds the language-agnostic half of the refactorings (offset spans, block geometry, rewrite composition, name primitives) so `lsp:java` and `lsp:kotlin` share one copy; `lsp:ui` holds the Compose sheets they share. Neither depends on a language server. |
 | UI design tooling | `layouteditor`, `uidesigner`, `xml-inflater`, `vectormaster`, `compose-preview` | Visual/XML design surfaces for the *user's* app. |
 | Shell | `termux:{termux-app,termux-shared,termux-view,termux-emulator}` | Embedded Termux shell and terminal. |
 | Plugin system | `plugin-api`, `plugin-api:plugin-builder`, `plugin-manager` | In-app plugin SDK + manager — `AndroidManifest.xml` `<meta-data>` contract, permissions, extensions. See [plugin-api.md](docs/plugin-api.md) for the API surface & compatibility policy. |
diff --git a/app/src/main/java/com/itsaky/androidide/actions/sidebar/OutlineSidebarAction.kt b/app/src/main/java/com/itsaky/androidide/actions/sidebar/OutlineSidebarAction.kt
new file mode 100644
index 0000000000..1b2436855f
--- /dev/null
+++ b/app/src/main/java/com/itsaky/androidide/actions/sidebar/OutlineSidebarAction.kt
@@ -0,0 +1,28 @@
+package com.itsaky.androidide.actions.sidebar
+
+import android.content.Context
+import androidx.core.content.ContextCompat
+import androidx.fragment.app.Fragment
+import com.itsaky.androidide.R
+import com.itsaky.androidide.fragments.sidebar.OutlineFragment
+import com.itsaky.androidide.idetooltips.TooltipTag
+import kotlin.reflect.KClass
+
+class OutlineSidebarAction(
+	context: Context,
+	override val order: Int,
+) : AbstractSidebarAction() {
+	companion object {
+		const val ID = "ide.editor.sidebar.outline"
+	}
+
+	override val id: String = ID
+	override val fragmentClass: KClass<out Fragment> = OutlineFragment::class
+
+	init {
+		label = context.getString(R.string.title_document_outline)
+		icon = ContextCompat.getDrawable(context, R.drawable.ic_outline)
+	}
+
+	override fun retrieveTooltipTag(isAlternateContext: Boolean) = TooltipTag.OUTLINE_SIDEBAR
+}
diff --git a/app/src/main/java/com/itsaky/androidide/di/AppModule.kt b/app/src/main/java/com/itsaky/androidide/di/AppModule.kt
index b1aece6ba5..a9c1a7a8fb 100644
--- a/app/src/main/java/com/itsaky/androidide/di/AppModule.kt
+++ b/app/src/main/java/com/itsaky/androidide/di/AppModule.kt
@@ -4,6 +4,8 @@ import com.itsaky.androidide.actions.FileActionManager
 import com.itsaky.androidide.analytics.AnalyticsManager
 import com.itsaky.androidide.analytics.IAnalyticsManager
 import com.itsaky.androidide.deeplink.PendingDeepLinkOpen
+import com.itsaky.androidide.editor.language.outline.OutlineProvider
+import com.itsaky.androidide.editor.language.outline.TreeSitterOutlineProvider
 import com.itsaky.androidide.git.core.GitCredentialsManager
 import com.itsaky.androidide.repositories.RecentProjectRepository
 import com.itsaky.androidide.repositories.RecentProjectRepositoryImpl
@@ -11,6 +13,7 @@ import com.itsaky.androidide.roomData.recentproject.RecentProjectRoomDatabase
 import com.itsaky.androidide.viewmodel.CloneRepositoryViewModel
 import com.itsaky.androidide.viewmodel.GitBottomSheetViewModel
 import com.itsaky.androidide.viewmodel.MainViewModel
+import com.itsaky.androidide.viewmodel.OutlineViewModel
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.SupervisorJob
@@ -35,6 +38,8 @@ val coreModule =
 		}
 		viewModel { MainViewModel() }
 		viewModel { CloneRepositoryViewModel(get(), get()) }
+		single<OutlineProvider> { TreeSitterOutlineProvider(androidContext()) }
+		viewModel { OutlineViewModel(get()) }
 
 		// Named, because an unqualified single<CoroutineScope> is claimed by type alone: this one
 		// instance was serving both the Room database below and EditorHandlerActivity's saveAllAsync,
diff --git a/app/src/main/java/com/itsaky/androidide/fragments/sidebar/OutlineFragment.kt b/app/src/main/java/com/itsaky/androidide/fragments/sidebar/OutlineFragment.kt
new file mode 100644
index 0000000000..f04d422f65
--- /dev/null
+++ b/app/src/main/java/com/itsaky/androidide/fragments/sidebar/OutlineFragment.kt
@@ -0,0 +1,133 @@
+package com.itsaky.androidide.fragments.sidebar
+
+import android.os.Bundle
+import android.view.LayoutInflater
+import android.view.View
+import android.view.ViewGroup
+import androidx.compose.ui.platform.ComposeView
+import androidx.compose.ui.platform.ViewCompositionStrategy
+import androidx.core.view.GravityCompat
+import androidx.fragment.app.Fragment
+import androidx.lifecycle.Lifecycle
+import androidx.lifecycle.lifecycleScope
+import androidx.lifecycle.repeatOnLifecycle
+import com.itsaky.androidide.activities.editor.EditorHandlerActivity
+import com.itsaky.androidide.common.compose.IdeTheme
+import com.itsaky.androidide.eventbus.events.editor.DocumentChangeEvent
+import com.itsaky.androidide.eventbus.events.editor.DocumentCloseEvent
+import com.itsaky.androidide.eventbus.events.editor.DocumentOpenEvent
+import com.itsaky.androidide.eventbus.events.editor.DocumentSelectedEvent
+import com.itsaky.androidide.models.Position
+import com.itsaky.androidide.ui.models.OutlineUiEffect
+import com.itsaky.androidide.ui.outline.OutlinePanel
+import com.itsaky.androidide.viewmodel.OutlineViewModel
+import kotlinx.coroutines.launch
+import org.greenrobot.eventbus.EventBus
+import org.greenrobot.eventbus.Subscribe
+import org.greenrobot.eventbus.ThreadMode.MAIN
+import org.koin.androidx.viewmodel.ext.android.activityViewModel
+import java.nio.file.Path
+
+class OutlineFragment : Fragment() {
+	private val viewModel: OutlineViewModel by activityViewModel()
+
+	override fun onCreateView(
+		inflater: LayoutInflater,
+		container: ViewGroup?,
+		savedInstanceState: Bundle?,
+	): View =
+		ComposeView(requireContext()).apply {
+			setViewCompositionStrategy(ViewCompositionStrategy.DisposeOnViewTreeLifecycleDestroyed)
+			setContent {
+				IdeTheme {
+					OutlinePanel(viewModel)
+				}
+			}
+		}
+
+	override fun onViewCreated(
+		view: View,
+		savedInstanceState: Bundle?,
+	) {
+		super.onViewCreated(view, savedInstanceState)
+		viewLifecycleOwner.lifecycleScope.launch {
+			viewLifecycleOwner.repeatOnLifecycle(Lifecycle.State.STARTED) {
+				viewModel.effects.collect { effect ->
+					when (effect) {
+						is OutlineUiEffect.NavigateTo -> navigateTo(effect.position)
+					}
+				}
+			}
+		}
+	}
+
+	override fun onStart() {
+		super.onStart()
+		if (!EventBus.getDefault().isRegistered(this)) {
+			EventBus.getDefault().register(this)
+		}
+		seedFromCurrentEditor()
+	}
+
+	override fun onStop() {
+		EventBus.getDefault().unregister(this)
+		super.onStop()
+	}
+
+	@Subscribe(threadMode = MAIN)
+	fun onDocumentChanged(event: DocumentChangeEvent) {
+		val text = event.newText ?: return
+		viewModel.onSnapshot(
+			fileName = event.changedFile.fileName.toString(),
+			extension = extensionOf(event.changedFile),
+			text = text,
+			immediate = false,
+		)
+	}
+
+	@Subscribe(threadMode = MAIN)
+	fun onDocumentOpened(event: DocumentOpenEvent) {
+		viewModel.onSnapshot(
+			fileName = event.openedFile.fileName.toString(),
+			extension = extensionOf(event.openedFile),
+			text = event.text,
+			immediate = true,
+		)
+	}
+
+	@Subscribe(threadMode = MAIN)
+	fun onDocumentSelected(event: DocumentSelectedEvent) {
+		seedFromCurrentEditor()
+	}
+
+	@Subscribe(threadMode = MAIN)
+	fun onDocumentClosed(event: DocumentCloseEvent) {
+		seedFromCurrentEditor()
+	}
+
+	private fun seedFromCurrentEditor() {
+		val editor = (activity as? EditorHandlerActivity)?.getCurrentEditor()?.editor
+		val file = editor?.file
+		if (editor == null || file == null) {
+			viewModel.onNoEditor()
+			return
+		}
+		viewModel.onSnapshot(
+			fileName = file.name,
+			extension = file.extension,
+			text = editor.text.toString(),
+			immediate = true,
+		)
+	}
+
+	private fun navigateTo(position: Position) {
+		val editorActivity = activity as? EditorHandlerActivity ?: return
+		editorActivity.binding.editorDrawerLayout.closeDrawer(GravityCompat.START)
+		val editor = editorActivity.getCurrentEditor()?.editor ?: return
+		if (editor.isValidPosition(position, true)) {
+			editor.setSelection(position)
+		}
+	}
+
+	private fun extensionOf(path: Path): String = path.fileName.toString().substringAfterLast('.', "")
+}
diff --git a/app/src/main/java/com/itsaky/androidide/utils/EditorSidebarActions.kt b/app/src/main/java/com/itsaky/androidide/utils/EditorSidebarActions.kt
index 12d342d5cb..0d68cc12f8 100644
--- a/app/src/main/java/com/itsaky/androidide/utils/EditorSidebarActions.kt
+++ b/app/src/main/java/com/itsaky/androidide/utils/EditorSidebarActions.kt
@@ -47,6 +47,7 @@ import com.itsaky.androidide.actions.sidebar.BuildVariantsSidebarAction
 import com.itsaky.androidide.actions.sidebar.CloseProjectSidebarAction
 import com.itsaky.androidide.actions.sidebar.FileTreeSidebarAction
 import com.itsaky.androidide.actions.sidebar.HelpSideBarAction
+import com.itsaky.androidide.actions.sidebar.OutlineSidebarAction
 import com.itsaky.androidide.actions.sidebar.PreferencesSidebarAction
 import com.itsaky.androidide.actions.sidebar.TerminalSidebarAction
 import com.itsaky.androidide.eventbus.events.plugin.PluginCrashedEvent
@@ -78,13 +79,14 @@ internal object EditorSidebarActions {
 
 		@Suppress("KotlinConstantConditions")
 		registry.registerAction(FileTreeSidebarAction(context, ++order))
+		registry.registerAction(OutlineSidebarAction(context, ++order))
 		registry.registerAction(BuildVariantsSidebarAction(context, ++order))
 		registry.registerAction(TerminalSidebarAction(context, ++order))
 		registry.registerAction(PreferencesSidebarAction(context, ++order))
 		registry.registerAction(CloseProjectSidebarAction(context, ++order))
 		registry.registerAction(HelpSideBarAction(context, ++order))
 
-		// Set built-in item count (6 items) for sidebar slot management
+		// Set built-in item count (7 items) for sidebar slot management
 		SidebarSlotManager.setBuiltInItemCount(order + 1)
 
 		// Register plugin sidebar items
diff --git a/idetooltips/src/main/java/com/itsaky/androidide/idetooltips/TooltipTag.kt b/idetooltips/src/main/java/com/itsaky/androidide/idetooltips/TooltipTag.kt
index 7c4e23f0e3..ada87beee5 100644
--- a/idetooltips/src/main/java/com/itsaky/androidide/idetooltips/TooltipTag.kt
+++ b/idetooltips/src/main/java/com/itsaky/androidide/idetooltips/TooltipTag.kt
@@ -4,6 +4,7 @@ object TooltipTag {
 	const val BUILD_VARIANT_SIDEBAR = "project.sidebar.buildvariants"
 	const val CLOSE_PROJECT_SIDEBAR = "project.sidebar.closeproject"
 	const val FILE_TREE_SIDEBAR = "project.sidebar.filetree"
+	const val OUTLINE_SIDEBAR = "project.sidebar.outline"
 	const val HELP_SIDEBAR = "project.help"
 	const val PREFERENCES_SIDEBAR = "main.prefs"
 	const val TERMINAL_SIDEBAR = "project.sidebar.terminal"
diff --git a/resources/src/main/res/drawable/ic_outline.xml b/resources/src/main/res/drawable/ic_outline.xml
new file mode 100644
index 0000000000..0ddc5682bf
--- /dev/null
+++ b/resources/src/main/res/drawable/ic_outline.xml
@@ -0,0 +1,11 @@
+<vector
+	xmlns:android="http://schemas.android.com/apk/res/android"
+	android:width="24dp"
+	android:height="24dp"
+	android:viewportWidth="24"
+	android:viewportHeight="24"
+	android:tint="?attr/colorControlNormal">
+	<path
+		android:fillColor="@android:color/white"
+		android:pathData="M4,6m-1.5,0a1.5,1.5 0,1 1,3 0a1.5,1.5 0,1 1,-3 0M8,5h12v2H8ZM7,12m-1.5,0a1.5,1.5 0,1 1,3 0a1.5,1.5 0,1 1,-3 0M11,11h9v2h-9ZM7,18m-1.5,0a1.5,1.5 0,1 1,3 0a1.5,1.5 0,1 1,-3 0M11,17h9v2h-9Z" />
+</vector>

From 5258438eb6795437cc19a62e1a6e4955ca9830f1 Mon Sep 17 00:00:00 2001
From: Daniel Alome <astrocoder007@gmail.com>
Date: Wed, 26 Aug 2026 10:27:03 +0100
Subject: [PATCH 08/20] ADFA-2448: Read outline change snapshots from
 FileManager

---
 .../itsaky/androidide/fragments/sidebar/OutlineFragment.kt    | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/app/src/main/java/com/itsaky/androidide/fragments/sidebar/OutlineFragment.kt b/app/src/main/java/com/itsaky/androidide/fragments/sidebar/OutlineFragment.kt
index f04d422f65..5d00c82215 100644
--- a/app/src/main/java/com/itsaky/androidide/fragments/sidebar/OutlineFragment.kt
+++ b/app/src/main/java/com/itsaky/androidide/fragments/sidebar/OutlineFragment.kt
@@ -18,6 +18,7 @@ import com.itsaky.androidide.eventbus.events.editor.DocumentCloseEvent
 import com.itsaky.androidide.eventbus.events.editor.DocumentOpenEvent
 import com.itsaky.androidide.eventbus.events.editor.DocumentSelectedEvent
 import com.itsaky.androidide.models.Position
+import com.itsaky.androidide.projects.FileManager
 import com.itsaky.androidide.ui.models.OutlineUiEffect
 import com.itsaky.androidide.ui.outline.OutlinePanel
 import com.itsaky.androidide.viewmodel.OutlineViewModel
@@ -76,11 +77,10 @@ class OutlineFragment : Fragment() {
 
 	@Subscribe(threadMode = MAIN)
 	fun onDocumentChanged(event: DocumentChangeEvent) {
-		val text = event.newText ?: return
 		viewModel.onSnapshot(
 			fileName = event.changedFile.fileName.toString(),
 			extension = extensionOf(event.changedFile),
-			text = text,
+			text = event.newText ?: FileManager.getDocumentContents(event.changedFile),
 			immediate = false,
 		)
 	}

From 63b90d4bdb5052a76b65dc58dafe08152ba99d0d Mon Sep 17 00:00:00 2001
From: Daniel Alome <astrocoder007@gmail.com>
Date: Wed, 26 Aug 2026 10:27:03 +0100
Subject: [PATCH 09/20] ADFA-2448: Color outline badges by symbol kind group

---
 .../androidide/ui/outline/OutlinePanel.kt     | 29 ++++++++++++++++++-
 1 file changed, 28 insertions(+), 1 deletion(-)

diff --git a/app/src/main/java/com/itsaky/androidide/ui/outline/OutlinePanel.kt b/app/src/main/java/com/itsaky/androidide/ui/outline/OutlinePanel.kt
index ab6eb6100d..240fa8d013 100644
--- a/app/src/main/java/com/itsaky/androidide/ui/outline/OutlinePanel.kt
+++ b/app/src/main/java/com/itsaky/androidide/ui/outline/OutlinePanel.kt
@@ -1,6 +1,7 @@
 package com.itsaky.androidide.ui.outline
 
 import androidx.compose.foundation.clickable
+import androidx.compose.foundation.isSystemInDarkTheme
 import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.Row
@@ -22,6 +23,7 @@ import androidx.compose.runtime.remember
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.draw.rotate
+import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.semantics.contentDescription
 import androidx.compose.ui.semantics.semantics
@@ -31,6 +33,7 @@ import androidx.compose.ui.text.style.TextOverflow
 import androidx.compose.ui.unit.dp
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import com.itsaky.androidide.R
+import com.itsaky.androidide.editor.language.outline.OutlineSymbolKind
 import com.itsaky.androidide.ui.models.OutlineUiEvent
 import com.itsaky.androidide.ui.models.OutlineUiState
 import com.itsaky.androidide.viewmodel.OutlineViewModel
@@ -38,6 +41,30 @@ import com.itsaky.androidide.viewmodel.OutlineViewModel
 private const val MAX_INDENT_DEPTH = 6
 private val INDENT_STEP = 14.dp
 
+private val TYPE_BADGE_LIGHT = Color(0xFF6650C4)
+private val TYPE_BADGE_DARK = Color(0xFFB9A8FF)
+private val CALLABLE_BADGE_LIGHT = Color(0xFF0B6E77)
+private val CALLABLE_BADGE_DARK = Color(0xFF7FD8DF)
+private val DATA_BADGE_LIGHT = Color(0xFFA05A00)
+private val DATA_BADGE_DARK = Color(0xFFF0B45C)
+
+@Composable
+private fun badgeColorFor(kind: OutlineSymbolKind): Color {
+	val dark = isSystemInDarkTheme()
+	return when (kind) {
+		OutlineSymbolKind.METHOD,
+		OutlineSymbolKind.CONSTRUCTOR,
+		-> if (dark) CALLABLE_BADGE_DARK else CALLABLE_BADGE_LIGHT
+
+		OutlineSymbolKind.FIELD,
+		OutlineSymbolKind.PROPERTY,
+		OutlineSymbolKind.ENUM_MEMBER,
+		-> if (dark) DATA_BADGE_DARK else DATA_BADGE_LIGHT
+
+		else -> if (dark) TYPE_BADGE_DARK else TYPE_BADGE_LIGHT
+	}
+}
+
 @Composable
 fun OutlinePanel(
 	viewModel: OutlineViewModel,
@@ -157,7 +184,7 @@ private fun OutlineRow(
 			fontFamily = FontFamily.Monospace,
 			fontWeight = FontWeight.Bold,
 			style = MaterialTheme.typography.bodyMedium,
-			color = MaterialTheme.colorScheme.primary,
+			color = badgeColorFor(symbol.kind),
 			modifier = Modifier.padding(horizontal = 6.dp),
 		)
 		Column(modifier = Modifier.weight(1f)) {

From d902119a8931dcf601fe0691e252c63ff5a002d2 Mon Sep 17 00:00:00 2001
From: Daniel Alome <astrocoder007@gmail.com>
Date: Sun, 30 Aug 2026 21:54:17 +0100
Subject: [PATCH 10/20] ADFA-2448: Scroll the outline target into view after
 the drawer closes

---
 .../fragments/sidebar/OutlineFragment.kt      | 24 +++++++++++++++----
 1 file changed, 20 insertions(+), 4 deletions(-)

diff --git a/app/src/main/java/com/itsaky/androidide/fragments/sidebar/OutlineFragment.kt b/app/src/main/java/com/itsaky/androidide/fragments/sidebar/OutlineFragment.kt
index 5d00c82215..863161784d 100644
--- a/app/src/main/java/com/itsaky/androidide/fragments/sidebar/OutlineFragment.kt
+++ b/app/src/main/java/com/itsaky/androidide/fragments/sidebar/OutlineFragment.kt
@@ -7,6 +7,7 @@ import android.view.ViewGroup
 import androidx.compose.ui.platform.ComposeView
 import androidx.compose.ui.platform.ViewCompositionStrategy
 import androidx.core.view.GravityCompat
+import androidx.drawerlayout.widget.DrawerLayout
 import androidx.fragment.app.Fragment
 import androidx.lifecycle.Lifecycle
 import androidx.lifecycle.lifecycleScope
@@ -122,11 +123,26 @@ class OutlineFragment : Fragment() {
 
 	private fun navigateTo(position: Position) {
 		val editorActivity = activity as? EditorHandlerActivity ?: return
-		editorActivity.binding.editorDrawerLayout.closeDrawer(GravityCompat.START)
-		val editor = editorActivity.getCurrentEditor()?.editor ?: return
-		if (editor.isValidPosition(position, true)) {
-			editor.setSelection(position)
+		val drawer = editorActivity.binding.editorDrawerLayout
+		val editor = editorActivity.getCurrentEditor()?.editor
+		if (editor == null || !editor.isValidPosition(position, true)) {
+			drawer.closeDrawer(GravityCompat.START)
+			return
+		}
+		editor.setSelection(position)
+		if (!drawer.isDrawerOpen(GravityCompat.START)) {
+			editor.ensurePositionVisible(position.line, position.column, true)
+			return
 		}
+		drawer.addDrawerListener(
+			object : DrawerLayout.SimpleDrawerListener() {
+				override fun onDrawerClosed(drawerView: View) {
+					drawer.removeDrawerListener(this)
+					editor.ensurePositionVisible(position.line, position.column, true)
+				}
+			},
+		)
+		drawer.closeDrawer(GravityCompat.START)
 	}
 
 	private fun extensionOf(path: Path): String = path.fileName.toString().substringAfterLast('.', "")

From 1b611d578dbf5bed52b410f90731f54c0855cdb2 Mon Sep 17 00:00:00 2001
From: Daniel Alome <astrocoder007@gmail.com>
Date: Sun, 30 Aug 2026 21:54:20 +0100
Subject: [PATCH 11/20] ADFA-2448: Use two-letter mnemonic badges for outline
 symbol kinds

---
 .../editor/language/outline/OutlineSymbol.kt  | 30 +++++++++----------
 1 file changed, 15 insertions(+), 15 deletions(-)

diff --git a/editor/src/main/java/com/itsaky/androidide/editor/language/outline/OutlineSymbol.kt b/editor/src/main/java/com/itsaky/androidide/editor/language/outline/OutlineSymbol.kt
index 3a31d7523c..7b504cc073 100644
--- a/editor/src/main/java/com/itsaky/androidide/editor/language/outline/OutlineSymbol.kt
+++ b/editor/src/main/java/com/itsaky/androidide/editor/language/outline/OutlineSymbol.kt
@@ -3,22 +3,22 @@ package com.itsaky.androidide.editor.language.outline
 import com.itsaky.androidide.models.Range
 
 enum class OutlineSymbolKind(
-	val badge: Char,
+	val badge: String,
 ) {
-	CLASS('C'),
-	INTERFACE('I'),
-	ENUM('E'),
-	ENUM_MEMBER('V'),
-	RECORD('R'),
-	ANNOTATION('A'),
-	OBJECT('O'),
-	COMPANION('O'),
-	TYPE_ALIAS('T'),
-	CONSTRUCTOR('N'),
-	METHOD('M'),
-	FIELD('F'),
-	PROPERTY('P'),
-	ELEMENT('X'),
+	CLASS("Cl"),
+	INTERFACE("In"),
+	ENUM("En"),
+	ENUM_MEMBER("Em"),
+	RECORD("Rc"),
+	ANNOTATION("An"),
+	OBJECT("Ob"),
+	COMPANION("Ob"),
+	TYPE_ALIAS("Ta"),
+	CONSTRUCTOR("Ct"),
+	METHOD("Fn"),
+	FIELD("Fd"),
+	PROPERTY("Pr"),
+	ELEMENT("El"),
 }
 
 data class OutlineSymbol(

From 017a64cf2770d142d8a337090e2f97847ff8716b Mon Sep 17 00:00:00 2001
From: Daniel Alome <astrocoder007@gmail.com>
Date: Sun, 30 Aug 2026 21:54:24 +0100
Subject: [PATCH 12/20] ADFA-2448: Densify outline rows with inline top-aligned
 details

---
 .../androidide/ui/outline/OutlinePanel.kt     | 38 ++++++++++---------
 1 file changed, 20 insertions(+), 18 deletions(-)

diff --git a/app/src/main/java/com/itsaky/androidide/ui/outline/OutlinePanel.kt b/app/src/main/java/com/itsaky/androidide/ui/outline/OutlinePanel.kt
index 240fa8d013..98d2bd4414 100644
--- a/app/src/main/java/com/itsaky/androidide/ui/outline/OutlinePanel.kt
+++ b/app/src/main/java/com/itsaky/androidide/ui/outline/OutlinePanel.kt
@@ -154,12 +154,12 @@ private fun OutlineRow(
 	val rowDescription = listOfNotNull(kindLabel, symbol.name, symbol.detail).joinToString(", ")
 	val indent = INDENT_STEP * minOf(row.depth, MAX_INDENT_DEPTH)
 	Row(
-		verticalAlignment = Alignment.CenterVertically,
+		verticalAlignment = Alignment.Top,
 		modifier =
 			modifier
 				.fillMaxWidth()
 				.clickable { onEvent(OutlineUiEvent.SymbolClicked(symbol)) }
-				.padding(start = 4.dp + indent, top = 8.dp, bottom = 8.dp, end = 12.dp)
+				.padding(start = 4.dp + indent, top = 5.dp, bottom = 5.dp, end = 12.dp)
 				.semantics { contentDescription = rowDescription },
 	) {
 		if (row.hasChildren) {
@@ -172,35 +172,37 @@ private fun OutlineRow(
 				contentDescription = toggleDescription,
 				modifier =
 					Modifier
-						.size(24.dp)
+						.size(22.dp)
 						.rotate(if (row.collapsed) -90f else 0f)
 						.clickable { onEvent(OutlineUiEvent.ToggleCollapsed(row.path)) },
 			)
 		} else {
-			Spacer(modifier = Modifier.size(24.dp))
+			Spacer(modifier = Modifier.size(22.dp))
 		}
 		Text(
-			text = symbol.kind.badge.toString(),
+			text = symbol.kind.badge,
 			fontFamily = FontFamily.Monospace,
 			fontWeight = FontWeight.Bold,
 			style = MaterialTheme.typography.bodyMedium,
 			color = badgeColorFor(symbol.kind),
-			modifier = Modifier.padding(horizontal = 6.dp),
+			modifier = Modifier.padding(start = 2.dp, end = 8.dp),
 		)
-		Column(modifier = Modifier.weight(1f)) {
+		Text(
+			text = symbol.name,
+			style = MaterialTheme.typography.bodyMedium,
+		)
+		symbol.detail?.let { detail ->
 			Text(
-				text = symbol.name,
-				style = MaterialTheme.typography.bodyMedium,
+				text = detail,
+				style = MaterialTheme.typography.bodySmall,
+				color = MaterialTheme.colorScheme.onSurfaceVariant,
+				maxLines = 1,
+				overflow = TextOverflow.Ellipsis,
+				modifier =
+					Modifier
+						.weight(1f, fill = false)
+						.padding(start = 8.dp, top = 2.dp),
 			)
-			symbol.detail?.let { detail ->
-				Text(
-					text = detail,
-					style = MaterialTheme.typography.bodySmall,
-					color = MaterialTheme.colorScheme.onSurfaceVariant,
-					maxLines = 1,
-					overflow = TextOverflow.Ellipsis,
-				)
-			}
 		}
 	}
 }

From bbbf6f11fb5833ca6bc59e91b99edcbf443f1c83 Mon Sep 17 00:00:00 2001
From: Daniel Alome <astrocoder007@gmail.com>
Date: Mon, 31 Aug 2026 12:39:57 +0100
Subject: [PATCH 13/20] ADFA-2448: Draw hierarchy connector lines in the
 outline

---
 .../androidide/ui/outline/OutlinePanel.kt     | 21 +++++++++++++++++--
 1 file changed, 19 insertions(+), 2 deletions(-)

diff --git a/app/src/main/java/com/itsaky/androidide/ui/outline/OutlinePanel.kt b/app/src/main/java/com/itsaky/androidide/ui/outline/OutlinePanel.kt
index 98d2bd4414..fd2c2b6c25 100644
--- a/app/src/main/java/com/itsaky/androidide/ui/outline/OutlinePanel.kt
+++ b/app/src/main/java/com/itsaky/androidide/ui/outline/OutlinePanel.kt
@@ -22,7 +22,9 @@ import androidx.compose.runtime.getValue
 import androidx.compose.runtime.remember
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.drawBehind
 import androidx.compose.ui.draw.rotate
+import androidx.compose.ui.geometry.Offset
 import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.semantics.contentDescription
@@ -152,14 +154,29 @@ private fun OutlineRow(
 			.lowercase()
 			.replace('_', ' ')
 	val rowDescription = listOfNotNull(kindLabel, symbol.name, symbol.detail).joinToString(", ")
-	val indent = INDENT_STEP * minOf(row.depth, MAX_INDENT_DEPTH)
+	val cappedDepth = minOf(row.depth, MAX_INDENT_DEPTH)
+	val indent = INDENT_STEP * cappedDepth
+	val guideColor = MaterialTheme.colorScheme.outlineVariant
 	Row(
 		verticalAlignment = Alignment.Top,
 		modifier =
 			modifier
 				.fillMaxWidth()
 				.clickable { onEvent(OutlineUiEvent.SymbolClicked(symbol)) }
-				.padding(start = 4.dp + indent, top = 5.dp, bottom = 5.dp, end = 12.dp)
+				.drawBehind {
+					val step = INDENT_STEP.toPx()
+					val stroke = 1.dp.toPx()
+					val base = 15.dp.toPx()
+					for (level in 0 until cappedDepth) {
+						val x = base + level * step
+						drawLine(
+							color = guideColor,
+							start = Offset(x, 0f),
+							end = Offset(x, size.height),
+							strokeWidth = stroke,
+						)
+					}
+				}.padding(start = 4.dp + indent, top = 5.dp, bottom = 5.dp, end = 12.dp)
 				.semantics { contentDescription = rowDescription },
 	) {
 		if (row.hasChildren) {

From dd1e536774fb3e53a641c63c0f8c710078a807cb Mon Sep 17 00:00:00 2001
From: Daniel Alome <astrocoder007@gmail.com>
Date: Mon, 31 Aug 2026 12:40:01 +0100
Subject: [PATCH 14/20] ADFA-2448: Center the tapped symbol in the viewport

---
 .../fragments/sidebar/OutlineFragment.kt        | 17 +++++++++++++++--
 1 file changed, 15 insertions(+), 2 deletions(-)

diff --git a/app/src/main/java/com/itsaky/androidide/fragments/sidebar/OutlineFragment.kt b/app/src/main/java/com/itsaky/androidide/fragments/sidebar/OutlineFragment.kt
index 863161784d..5c87c6bb7f 100644
--- a/app/src/main/java/com/itsaky/androidide/fragments/sidebar/OutlineFragment.kt
+++ b/app/src/main/java/com/itsaky/androidide/fragments/sidebar/OutlineFragment.kt
@@ -131,19 +131,32 @@ class OutlineFragment : Fragment() {
 		}
 		editor.setSelection(position)
 		if (!drawer.isDrawerOpen(GravityCompat.START)) {
-			editor.ensurePositionVisible(position.line, position.column, true)
+			centerPositionInView(editor, position)
 			return
 		}
 		drawer.addDrawerListener(
 			object : DrawerLayout.SimpleDrawerListener() {
 				override fun onDrawerClosed(drawerView: View) {
 					drawer.removeDrawerListener(this)
-					editor.ensurePositionVisible(position.line, position.column, true)
+					centerPositionInView(editor, position)
 				}
 			},
 		)
 		drawer.closeDrawer(GravityCompat.START)
 	}
 
+	private fun centerPositionInView(
+		editor: com.itsaky.androidide.editor.ui.IDEEditor,
+		position: Position,
+	) {
+		val rowY = editor.layout.getCharLayoutOffset(position.line, position.column)[0]
+		val targetY =
+			(rowY - editor.height / 2f)
+				.toInt()
+				.coerceIn(0, editor.scrollMaxY)
+		editor.scroller.startScroll(editor.offsetX, editor.offsetY, 0, targetY - editor.offsetY, 0)
+		editor.postInvalidate()
+	}
+
 	private fun extensionOf(path: Path): String = path.fileName.toString().substringAfterLast('.', "")
 }

From 3fefb062366d9ebc90e6d8ce13779f3572d21241 Mon Sep 17 00:00:00 2001
From: Daniel Alome <astrocoder007@gmail.com>
Date: Mon, 31 Aug 2026 12:40:05 +0100
Subject: [PATCH 15/20] ADFA-2448: Keep the outline pipeline alive through
 parse failures

---
 .../itsaky/androidide/viewmodel/OutlineViewModel.kt | 13 ++++++++++++-
 1 file changed, 12 insertions(+), 1 deletion(-)

diff --git a/app/src/main/java/com/itsaky/androidide/viewmodel/OutlineViewModel.kt b/app/src/main/java/com/itsaky/androidide/viewmodel/OutlineViewModel.kt
index 915a5e6a32..927c253496 100644
--- a/app/src/main/java/com/itsaky/androidide/viewmodel/OutlineViewModel.kt
+++ b/app/src/main/java/com/itsaky/androidide/viewmodel/OutlineViewModel.kt
@@ -6,6 +6,7 @@ import com.itsaky.androidide.editor.language.outline.OutlineProvider
 import com.itsaky.androidide.ui.models.OutlineUiEffect
 import com.itsaky.androidide.ui.models.OutlineUiEvent
 import com.itsaky.androidide.ui.models.OutlineUiState
+import kotlinx.coroutines.CancellationException
 import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.FlowPreview
@@ -17,6 +18,7 @@ import kotlinx.coroutines.flow.collectLatest
 import kotlinx.coroutines.flow.debounce
 import kotlinx.coroutines.flow.update
 import kotlinx.coroutines.launch
+import org.slf4j.LoggerFactory
 
 class OutlineViewModel(
 	private val outlineProvider: OutlineProvider,
@@ -42,6 +44,7 @@ class OutlineViewModel(
 
 	companion object {
 		private const val DEBOUNCE_MILLIS = 250L
+		private val log = LoggerFactory.getLogger(OutlineViewModel::class.java)
 	}
 
 	init {
@@ -95,7 +98,15 @@ class OutlineViewModel(
 			collapsedPaths = emptySet()
 			_uiState.value = OutlineUiState.Loading(snapshot.fileName)
 		}
-		val symbols = outlineProvider.outlineOf(snapshot.extension, snapshot.text)
+		val symbols =
+			try {
+				outlineProvider.outlineOf(snapshot.extension, snapshot.text)
+			} catch (e: CancellationException) {
+				throw e
+			} catch (e: Exception) {
+				log.error("Failed to compute outline for {}", snapshot.fileName, e)
+				emptyList()
+			}
 		_uiState.value =
 			if (symbols.isEmpty()) {
 				OutlineUiState.Empty(snapshot.fileName)

From f7b8597fd2bd6e1440989026cd611c2a56584ea4 Mon Sep 17 00:00:00 2001
From: Daniel Alome <astrocoder007@gmail.com>
Date: Mon, 7 Sep 2026 22:51:21 +0100
Subject: [PATCH 16/20] ADFA-2448: Track only the active document and harden
 the outline pipeline

Review follow-ups from CodeRabbit on #1804:

- OutlineFragment ignores DocumentChangeEvents for files other than the
  active editor's, so an edit to a background tab no longer swaps the
  outline away from the file navigateTo targets. The event always carries
  the new text (IDEEditor posts it), and the active editor's buffer is the
  fallback, so the main-thread FileManager disk read is gone.
- Snapshots are keyed by normalized absolute path instead of basename, so
  two Main.kt files in different modules no longer share collapse state.
- The snapshot collector catches non-cancellation failures around the whole
  computation (supports() included), so one bad file cannot stop later
  refreshes.
- kt/outline.scm lists a class_parameter as a property only when it is
  declared val or var; class Repo(name: String) no longer shows "name".
  The instrumentation fixture gains a plain parameter that must not appear.
- Asset readers for outline.scm are closed after reading (provider and
  query test).

Not changed: the android.util.Log calls in EditorSidebarActions predate this
branch and are outside its scope.
---
 .../fragments/sidebar/OutlineFragment.kt      | 20 ++++++---
 .../androidide/viewmodel/OutlineViewModel.kt  | 26 +++++++----
 .../viewmodel/OutlineViewModelTest.kt         | 44 ++++++++++++++++++-
 .../outline/TreeSitterOutlineProviderTest.kt  |  2 +-
 .../outline/TreeSitterOutlineQueryTest.kt     |  2 +-
 .../assets/editor/treesitter/kt/outline.scm   |  1 +
 .../outline/TreeSitterOutlineProvider.kt      |  2 +-
 7 files changed, 78 insertions(+), 19 deletions(-)

diff --git a/app/src/main/java/com/itsaky/androidide/fragments/sidebar/OutlineFragment.kt b/app/src/main/java/com/itsaky/androidide/fragments/sidebar/OutlineFragment.kt
index 5c87c6bb7f..f7c4cb62f4 100644
--- a/app/src/main/java/com/itsaky/androidide/fragments/sidebar/OutlineFragment.kt
+++ b/app/src/main/java/com/itsaky/androidide/fragments/sidebar/OutlineFragment.kt
@@ -19,7 +19,6 @@ import com.itsaky.androidide.eventbus.events.editor.DocumentCloseEvent
 import com.itsaky.androidide.eventbus.events.editor.DocumentOpenEvent
 import com.itsaky.androidide.eventbus.events.editor.DocumentSelectedEvent
 import com.itsaky.androidide.models.Position
-import com.itsaky.androidide.projects.FileManager
 import com.itsaky.androidide.ui.models.OutlineUiEffect
 import com.itsaky.androidide.ui.outline.OutlinePanel
 import com.itsaky.androidide.viewmodel.OutlineViewModel
@@ -78,10 +77,13 @@ class OutlineFragment : Fragment() {
 
 	@Subscribe(threadMode = MAIN)
 	fun onDocumentChanged(event: DocumentChangeEvent) {
+		val editor = currentEditor() ?: return
+		val file = editor.file ?: return
+		if (normalized(file.toPath()) != normalized(event.changedFile)) return
 		viewModel.onSnapshot(
-			fileName = event.changedFile.fileName.toString(),
-			extension = extensionOf(event.changedFile),
-			text = event.newText ?: FileManager.getDocumentContents(event.changedFile),
+			path = normalized(event.changedFile),
+			extension = file.extension,
+			text = event.newText ?: editor.text.toString(),
 			immediate = false,
 		)
 	}
@@ -89,7 +91,7 @@ class OutlineFragment : Fragment() {
 	@Subscribe(threadMode = MAIN)
 	fun onDocumentOpened(event: DocumentOpenEvent) {
 		viewModel.onSnapshot(
-			fileName = event.openedFile.fileName.toString(),
+			path = normalized(event.openedFile),
 			extension = extensionOf(event.openedFile),
 			text = event.text,
 			immediate = true,
@@ -107,20 +109,24 @@ class OutlineFragment : Fragment() {
 	}
 
 	private fun seedFromCurrentEditor() {
-		val editor = (activity as? EditorHandlerActivity)?.getCurrentEditor()?.editor
+		val editor = currentEditor()
 		val file = editor?.file
 		if (editor == null || file == null) {
 			viewModel.onNoEditor()
 			return
 		}
 		viewModel.onSnapshot(
-			fileName = file.name,
+			path = normalized(file.toPath()),
 			extension = file.extension,
 			text = editor.text.toString(),
 			immediate = true,
 		)
 	}
 
+	private fun currentEditor() = (activity as? EditorHandlerActivity)?.getCurrentEditor()?.editor
+
+	private fun normalized(path: Path): String = path.toAbsolutePath().normalize().toString()
+
 	private fun navigateTo(position: Position) {
 		val editorActivity = activity as? EditorHandlerActivity ?: return
 		val drawer = editorActivity.binding.editorDrawerLayout
diff --git a/app/src/main/java/com/itsaky/androidide/viewmodel/OutlineViewModel.kt b/app/src/main/java/com/itsaky/androidide/viewmodel/OutlineViewModel.kt
index 927c253496..f0759afa42 100644
--- a/app/src/main/java/com/itsaky/androidide/viewmodel/OutlineViewModel.kt
+++ b/app/src/main/java/com/itsaky/androidide/viewmodel/OutlineViewModel.kt
@@ -25,11 +25,13 @@ class OutlineViewModel(
 	private val computeDispatcher: CoroutineDispatcher = Dispatchers.Default,
 ) : ViewModel() {
 	private data class Snapshot(
-		val fileName: String,
+		val path: String,
 		val extension: String,
 		val text: String,
 		val immediate: Boolean,
-	)
+	) {
+		val fileName: String get() = path.substringAfterLast('/')
+	}
 
 	private val snapshots = MutableStateFlow<Snapshot?>(null)
 
@@ -40,7 +42,7 @@ class OutlineViewModel(
 	val effects = _effects.asSharedFlow()
 
 	private var collapsedPaths = emptySet<String>()
-	private var collapsedForFile: String? = null
+	private var collapsedForPath: String? = null
 
 	companion object {
 		private const val DEBOUNCE_MILLIS = 250L
@@ -53,17 +55,25 @@ class OutlineViewModel(
 			snapshots
 				.debounce { snapshot ->
 					if (snapshot == null || snapshot.immediate) 0L else DEBOUNCE_MILLIS
-				}.collectLatest { snapshot -> compute(snapshot) }
+				}.collectLatest { snapshot ->
+					try {
+						compute(snapshot)
+					} catch (e: CancellationException) {
+						throw e
+					} catch (e: Exception) {
+						log.error("Failed to refresh outline for {}", snapshot?.fileName, e)
+					}
+				}
 		}
 	}
 
 	fun onSnapshot(
-		fileName: String,
+		path: String,
 		extension: String,
 		text: String,
 		immediate: Boolean,
 	) {
-		snapshots.value = Snapshot(fileName, extension, text, immediate)
+		snapshots.value = Snapshot(path, extension, text, immediate)
 	}
 
 	fun onNoEditor() {
@@ -93,8 +103,8 @@ class OutlineViewModel(
 			_uiState.value = OutlineUiState.Unsupported(snapshot.fileName)
 			return
 		}
-		if (collapsedForFile != snapshot.fileName) {
-			collapsedForFile = snapshot.fileName
+		if (collapsedForPath != snapshot.path) {
+			collapsedForPath = snapshot.path
 			collapsedPaths = emptySet()
 			_uiState.value = OutlineUiState.Loading(snapshot.fileName)
 		}
diff --git a/app/src/test/java/com/itsaky/androidide/viewmodel/OutlineViewModelTest.kt b/app/src/test/java/com/itsaky/androidide/viewmodel/OutlineViewModelTest.kt
index aedf3b8d86..377af3353a 100644
--- a/app/src/test/java/com/itsaky/androidide/viewmodel/OutlineViewModelTest.kt
+++ b/app/src/test/java/com/itsaky/androidide/viewmodel/OutlineViewModelTest.kt
@@ -29,8 +29,15 @@ class OutlineViewModelTest {
 		var symbols: List<OutlineSymbol> = emptyList()
 		var callCount = 0
 		var gate: CompletableDeferred<Unit>? = null
+		var supportsFailsOnce = false
 
-		override fun supports(fileExtension: String) = fileExtension == "java"
+		override fun supports(fileExtension: String): Boolean {
+			if (supportsFailsOnce) {
+				supportsFailsOnce = false
+				throw IllegalStateException("grammar unavailable")
+			}
+			return fileExtension == "java"
+		}
 
 		override suspend fun outlineOf(
 			fileExtension: String,
@@ -61,6 +68,41 @@ class OutlineViewModelTest {
 
 	private fun TestScope.viewModel(provider: FakeOutlineProvider) = OutlineViewModel(provider, UnconfinedTestDispatcher(testScheduler))
 
+	@Test
+	fun `collapse state is keyed by path, not basename`() =
+		runTest {
+			val provider = FakeOutlineProvider().apply { symbols = listOf(symbol("Main")) }
+			val vm = viewModel(provider)
+			vm.onSnapshot("/a/Main.java", "java", "class Main {}", immediate = true)
+			advanceTimeBy(1)
+			vm.onEvent(OutlineUiEvent.ToggleCollapsed("Main"))
+			assertThat((vm.uiState.value as OutlineUiState.Content).collapsedPaths).containsExactly("Main")
+
+			vm.onSnapshot("/b/Main.java", "java", "class Main {}", immediate = true)
+			advanceTimeBy(1)
+
+			assertThat((vm.uiState.value as OutlineUiState.Content).collapsedPaths).isEmpty()
+		}
+
+	@Test
+	fun `a failing supports check does not stop later snapshots from refreshing`() =
+		runTest {
+			val provider =
+				FakeOutlineProvider().apply {
+					symbols = listOf(symbol("Main"))
+					supportsFailsOnce = true
+				}
+			val vm = viewModel(provider)
+			vm.onSnapshot("/a/Broken.java", "java", "class Broken {}", immediate = true)
+			advanceTimeBy(1)
+
+			vm.onSnapshot("/a/Main.java", "java", "class Main {}", immediate = true)
+			advanceTimeBy(1)
+
+			assertThat(vm.uiState.value).isInstanceOf(OutlineUiState.Content::class.java)
+			assertThat((vm.uiState.value as OutlineUiState.Content).fileName).isEqualTo("Main.java")
+		}
+
 	@Test
 	fun `initial state is NoFileOpen`() =
 		runTest {
diff --git a/editor/src/androidTest/java/com/itsaky/androidide/editor/language/outline/TreeSitterOutlineProviderTest.kt b/editor/src/androidTest/java/com/itsaky/androidide/editor/language/outline/TreeSitterOutlineProviderTest.kt
index f9b355e9bf..607d1e4d0f 100644
--- a/editor/src/androidTest/java/com/itsaky/androidide/editor/language/outline/TreeSitterOutlineProviderTest.kt
+++ b/editor/src/androidTest/java/com/itsaky/androidide/editor/language/outline/TreeSitterOutlineProviderTest.kt
@@ -31,7 +31,7 @@ class TreeSitterOutlineProviderTest {
 
 	private val kotlinSource =
 		"""
-		class Repo(val name: String) {
+		class Repo(val name: String, tag: String) {
 			companion object {
 				val EMPTY = Repo("")
 			}
diff --git a/editor/src/androidTest/java/com/itsaky/androidide/editor/language/outline/TreeSitterOutlineQueryTest.kt b/editor/src/androidTest/java/com/itsaky/androidide/editor/language/outline/TreeSitterOutlineQueryTest.kt
index d8766c2948..2af6cf3252 100644
--- a/editor/src/androidTest/java/com/itsaky/androidide/editor/language/outline/TreeSitterOutlineQueryTest.kt
+++ b/editor/src/androidTest/java/com/itsaky/androidide/editor/language/outline/TreeSitterOutlineQueryTest.kt
@@ -45,7 +45,7 @@ class TreeSitterOutlineQueryTest {
 			context.assets
 				.open("editor/treesitter/$type/outline.scm")
 				.reader()
-				.readText()
+				.use { it.readText() }
 		val query = TSQuery.create(language, scm)
 		try {
 			assertThat(query.errorType).isEqualTo(TSQueryError.None)
diff --git a/editor/src/main/assets/editor/treesitter/kt/outline.scm b/editor/src/main/assets/editor/treesitter/kt/outline.scm
index c515a659f6..4fca0dc71d 100644
--- a/editor/src/main/assets/editor/treesitter/kt/outline.scm
+++ b/editor/src/main/assets/editor/treesitter/kt/outline.scm
@@ -24,4 +24,5 @@
     (simple_identifier) @name)) @symbol.property
 
 (class_parameter
+  ["val" "var"]
   (simple_identifier) @name) @symbol.property
diff --git a/editor/src/main/java/com/itsaky/androidide/editor/language/outline/TreeSitterOutlineProvider.kt b/editor/src/main/java/com/itsaky/androidide/editor/language/outline/TreeSitterOutlineProvider.kt
index 2dd0ea785b..902a3aa41d 100644
--- a/editor/src/main/java/com/itsaky/androidide/editor/language/outline/TreeSitterOutlineProvider.kt
+++ b/editor/src/main/java/com/itsaky/androidide/editor/language/outline/TreeSitterOutlineProvider.kt
@@ -89,7 +89,7 @@ class TreeSitterOutlineProvider(
 			appContext.assets
 				.open("$BASE_PATH/$type/outline.scm")
 				.reader()
-				.readText()
+				.use { it.readText() }
 		val language = languageFor(type)
 		val query = TSQuery.create(language, scm)
 		if (query.errorType != TSQueryError.None) {

From 0208cfcbf81e6eb14afc99e01580652eb71e73fd Mon Sep 17 00:00:00 2001
From: Daniel Alome <astrocoder007@gmail.com>
Date: Tue, 8 Sep 2026 15:26:41 +0100
Subject: [PATCH 17/20] ADFA-2448: Fix outline extraction gaps, collapse-state
 race and stale-file tracking

Review follow-ups from itsaky-adfa on #1804.

Extraction:
- Java: @symbol.field now sits on each variable_declarator, so `private int
  x, y;` lists both; dedup keys on the @name node instead of the symbol node.
- Kotlin: property_declaration is anchored to class_body, enum_class_body and
  source_file, so locals inside functions no longer show as properties.
  `interface` and `enum class` get INTERFACE/ENUM instead of CLASS; when two
  patterns capture the same name the earlier pattern wins, so the specific
  patterns are listed first.
- outlineOf runs on Dispatchers.Default inside the provider, so the guarantee
  no longer depends on the caller.

View model: collapse state lives in a StateFlow combined into uiState, so the
main-thread toggle and the compute thread never share a plain field.

Fragment: DocumentCloseEvent is dropped before it reaches EventBus, so closing
the last file left a stale outline. The panel now follows EditorViewModel's
current-file LiveData (fires on open, tab switch and last-close) and
onDocumentOpened has the same active-file guard as onDocumentChanged.

Panel: the expand/collapse chevron is a 48.dp IconButton; name and detail sit
in a column so a long name cannot squeeze the signature to zero width.

Rows: every path segment carries its sibling index, so a symbol literally
named `bind#2` cannot collide with a disambiguated sibling.

CI: the nightly instrumentation job assembles and runs the editor module's
test APK on Firebase Test Lab.

Comments on the two androidTest build workarounds name the failure each
avoids (duplicate kotlin.reflect.full classes from kt-android.jar; Sentry
auto-init crashing the test process).
---
 .github/workflows/instrumentation-test.yml    | 27 +++++++++-
 .../fragments/sidebar/OutlineFragment.kt      | 19 +++----
 .../androidide/ui/outline/OutlinePanel.kt     | 53 ++++++++++---------
 .../androidide/ui/outline/OutlineRows.kt      |  6 +--
 .../androidide/viewmodel/EditorViewModel.kt   |  2 +
 .../androidide/viewmodel/OutlineViewModel.kt  | 45 ++++++++--------
 .../androidide/ui/outline/OutlineRowsTest.kt  |  4 +-
 .../viewmodel/OutlineViewModelTest.kt         | 12 ++---
 editor/build.gradle.kts                       |  1 +
 editor/src/androidTest/AndroidManifest.xml    |  1 +
 .../outline/TreeSitterOutlineProviderTest.kt  | 35 +++++++++---
 .../assets/editor/treesitter/java/outline.scm |  2 +-
 .../assets/editor/treesitter/kt/outline.scm   | 25 +++++++--
 .../outline/TreeSitterOutlineProvider.kt      | 53 ++++++++++++-------
 14 files changed, 181 insertions(+), 104 deletions(-)

diff --git a/.github/workflows/instrumentation-test.yml b/.github/workflows/instrumentation-test.yml
index f1c077aabe..ff90341597 100644
--- a/.github/workflows/instrumentation-test.yml
+++ b/.github/workflows/instrumentation-test.yml
@@ -78,10 +78,11 @@ jobs:
         run: |
           ./gradlew :app:assembleV8DebugAndroidTest --no-daemon
           ./gradlew :app:assembleV8Debug --no-daemon
+          ./gradlew :editor:assembleV8DebugAndroidTest --no-daemon
 
       - name: Run Firebase Test Lab and Wait for Results
         run: |
-          mkdir -p test-results/kotlin test-results/groovy
+          mkdir -p test-results/kotlin test-results/groovy test-results/editor
           
           # Run Kotlin DSL tests
           echo "Running Kotlin DSL tests..."
@@ -141,6 +142,25 @@ jobs:
                             grep -o 'gs://[^[:space:]]*/video\.mp4' test-results/groovy/test_output.txt | sed 's|gs://|https://storage.cloud.google.com/|' | head -1 || echo "")
           echo "GROOVY_VIDEO_URL=$GROOVY_VIDEO_URL" >> $GITHUB_ENV
 
+          # Run editor module instrumentation tests (self-instrumenting library test APK)
+          echo "Running editor tests..."
+          EDITOR_TEST_APK=$(ls editor/build/outputs/apk/androidTest/v8/debug/*-androidTest.apk | head -1)
+          gcloud firebase test android run \
+            --type instrumentation \
+            --app "$EDITOR_TEST_APK" \
+            --test "$EDITOR_TEST_APK" \
+            --device model=oriole,version=33,locale=en,orientation=portrait \
+            --timeout 15m \
+            --num-flaky-test-attempts=1 \
+            --results-dir=test-results/editor \
+            --results-bucket=gs://firebase-test-results-${RANDOM} \
+            --project=codeonthego-64a92 > test-results/editor/test_output.txt 2>&1
+
+          EDITOR_EXIT_CODE=$?
+          echo "Editor tests exit code: $EDITOR_EXIT_CODE"
+          EDITOR_TEST_URL=$(grep -o 'https://console.firebase.google.com/project/[^[:space:]]*' test-results/editor/test_output.txt | head -1 || echo "")
+          echo "EDITOR_TEST_URL=$EDITOR_TEST_URL" >> $GITHUB_ENV
+
       - name: Notify Slack with parsed test results
         if: always()  # Run even if tests fail
         run: |
@@ -179,6 +199,7 @@ jobs:
           echo "Parsing test results..."
           KOTLIN_RESULTS=$(parse_results test-results/kotlin/test_output.txt "Kotlin DSL")
           GROOVY_RESULTS=$(parse_results test-results/groovy/test_output.txt "Groovy DSL")
+          EDITOR_RESULTS=$(parse_results test-results/editor/test_output.txt "Editor module")
           
           # Also capture the actual output for debugging
           echo "Kotlin output file contents:"
@@ -199,6 +220,7 @@ jobs:
           SLACK_MESSAGE="*🔥 Firebase Test Lab Results*\\n\\n"
           SLACK_MESSAGE="$SLACK_MESSAGE*${KOTLIN_RESULTS}*\\n"
           SLACK_MESSAGE="$SLACK_MESSAGE*${GROOVY_RESULTS}*\\n"
+          SLACK_MESSAGE="$SLACK_MESSAGE*${EDITOR_RESULTS}*\\n"
           
           # Add Kotlin URLs
           if [[ -n "$KOTLIN_TEST_URL" ]]; then
@@ -218,6 +240,9 @@ jobs:
             SLACK_MESSAGE="$SLACK_MESSAGE\\n🎥 Groovy Test Video: $GROOVY_VIDEO_URL"
           fi
           
+          if [[ -n "$EDITOR_TEST_URL" ]]; then
+            SLACK_MESSAGE="$SLACK_MESSAGE\\n\\n🔗 Editor Test Results: $EDITOR_TEST_URL"
+          fi
           # Add debugging info to see what URLs were found
           echo "Debug - Kotlin Video URL: '$KOTLIN_VIDEO_URL'"
           echo "Debug - Groovy Video URL: '$GROOVY_VIDEO_URL'"
diff --git a/app/src/main/java/com/itsaky/androidide/fragments/sidebar/OutlineFragment.kt b/app/src/main/java/com/itsaky/androidide/fragments/sidebar/OutlineFragment.kt
index f7c4cb62f4..e34676f4d6 100644
--- a/app/src/main/java/com/itsaky/androidide/fragments/sidebar/OutlineFragment.kt
+++ b/app/src/main/java/com/itsaky/androidide/fragments/sidebar/OutlineFragment.kt
@@ -9,18 +9,18 @@ import androidx.compose.ui.platform.ViewCompositionStrategy
 import androidx.core.view.GravityCompat
 import androidx.drawerlayout.widget.DrawerLayout
 import androidx.fragment.app.Fragment
+import androidx.fragment.app.activityViewModels
 import androidx.lifecycle.Lifecycle
 import androidx.lifecycle.lifecycleScope
 import androidx.lifecycle.repeatOnLifecycle
 import com.itsaky.androidide.activities.editor.EditorHandlerActivity
 import com.itsaky.androidide.common.compose.IdeTheme
 import com.itsaky.androidide.eventbus.events.editor.DocumentChangeEvent
-import com.itsaky.androidide.eventbus.events.editor.DocumentCloseEvent
 import com.itsaky.androidide.eventbus.events.editor.DocumentOpenEvent
-import com.itsaky.androidide.eventbus.events.editor.DocumentSelectedEvent
 import com.itsaky.androidide.models.Position
 import com.itsaky.androidide.ui.models.OutlineUiEffect
 import com.itsaky.androidide.ui.outline.OutlinePanel
+import com.itsaky.androidide.viewmodel.EditorViewModel
 import com.itsaky.androidide.viewmodel.OutlineViewModel
 import kotlinx.coroutines.launch
 import org.greenrobot.eventbus.EventBus
@@ -31,6 +31,7 @@ import java.nio.file.Path
 
 class OutlineFragment : Fragment() {
 	private val viewModel: OutlineViewModel by activityViewModel()
+	private val editorViewModel: EditorViewModel by activityViewModels()
 
 	override fun onCreateView(
 		inflater: LayoutInflater,
@@ -51,6 +52,7 @@ class OutlineFragment : Fragment() {
 		savedInstanceState: Bundle?,
 	) {
 		super.onViewCreated(view, savedInstanceState)
+		editorViewModel.currentFile.observe(viewLifecycleOwner) { view.post { seedFromCurrentEditor() } }
 		viewLifecycleOwner.lifecycleScope.launch {
 			viewLifecycleOwner.repeatOnLifecycle(Lifecycle.State.STARTED) {
 				viewModel.effects.collect { effect ->
@@ -67,7 +69,6 @@ class OutlineFragment : Fragment() {
 		if (!EventBus.getDefault().isRegistered(this)) {
 			EventBus.getDefault().register(this)
 		}
-		seedFromCurrentEditor()
 	}
 
 	override fun onStop() {
@@ -90,6 +91,8 @@ class OutlineFragment : Fragment() {
 
 	@Subscribe(threadMode = MAIN)
 	fun onDocumentOpened(event: DocumentOpenEvent) {
+		val file = currentEditor()?.file ?: return
+		if (normalized(file.toPath()) != normalized(event.openedFile)) return
 		viewModel.onSnapshot(
 			path = normalized(event.openedFile),
 			extension = extensionOf(event.openedFile),
@@ -98,16 +101,6 @@ class OutlineFragment : Fragment() {
 		)
 	}
 
-	@Subscribe(threadMode = MAIN)
-	fun onDocumentSelected(event: DocumentSelectedEvent) {
-		seedFromCurrentEditor()
-	}
-
-	@Subscribe(threadMode = MAIN)
-	fun onDocumentClosed(event: DocumentCloseEvent) {
-		seedFromCurrentEditor()
-	}
-
 	private fun seedFromCurrentEditor() {
 		val editor = currentEditor()
 		val file = editor?.file
diff --git a/app/src/main/java/com/itsaky/androidide/ui/outline/OutlinePanel.kt b/app/src/main/java/com/itsaky/androidide/ui/outline/OutlinePanel.kt
index fd2c2b6c25..5060d4859b 100644
--- a/app/src/main/java/com/itsaky/androidide/ui/outline/OutlinePanel.kt
+++ b/app/src/main/java/com/itsaky/androidide/ui/outline/OutlinePanel.kt
@@ -15,6 +15,7 @@ import androidx.compose.foundation.lazy.items
 import androidx.compose.material.icons.Icons
 import androidx.compose.material.icons.filled.ArrowDropDown
 import androidx.compose.material3.Icon
+import androidx.compose.material3.IconButton
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
@@ -42,6 +43,7 @@ import com.itsaky.androidide.viewmodel.OutlineViewModel
 
 private const val MAX_INDENT_DEPTH = 6
 private val INDENT_STEP = 14.dp
+private val TOGGLE_TARGET = 48.dp
 
 private val TYPE_BADGE_LIGHT = Color(0xFF6650C4)
 private val TYPE_BADGE_DARK = Color(0xFFB9A8FF)
@@ -158,7 +160,7 @@ private fun OutlineRow(
 	val indent = INDENT_STEP * cappedDepth
 	val guideColor = MaterialTheme.colorScheme.outlineVariant
 	Row(
-		verticalAlignment = Alignment.Top,
+		verticalAlignment = Alignment.CenterVertically,
 		modifier =
 			modifier
 				.fillMaxWidth()
@@ -176,7 +178,7 @@ private fun OutlineRow(
 							strokeWidth = stroke,
 						)
 					}
-				}.padding(start = 4.dp + indent, top = 5.dp, bottom = 5.dp, end = 12.dp)
+				}.padding(start = 4.dp + indent, end = 12.dp)
 				.semantics { contentDescription = rowDescription },
 	) {
 		if (row.hasChildren) {
@@ -184,17 +186,18 @@ private fun OutlineRow(
 				stringResource(
 					if (row.collapsed) R.string.cd_outline_expand else R.string.cd_outline_collapse,
 				)
-			Icon(
-				imageVector = Icons.Filled.ArrowDropDown,
-				contentDescription = toggleDescription,
-				modifier =
-					Modifier
-						.size(22.dp)
-						.rotate(if (row.collapsed) -90f else 0f)
-						.clickable { onEvent(OutlineUiEvent.ToggleCollapsed(row.path)) },
-			)
+			IconButton(
+				onClick = { onEvent(OutlineUiEvent.ToggleCollapsed(row.path)) },
+				modifier = Modifier.size(TOGGLE_TARGET),
+			) {
+				Icon(
+					imageVector = Icons.Filled.ArrowDropDown,
+					contentDescription = toggleDescription,
+					modifier = Modifier.rotate(if (row.collapsed) -90f else 0f),
+				)
+			}
 		} else {
-			Spacer(modifier = Modifier.size(22.dp))
+			Spacer(modifier = Modifier.size(TOGGLE_TARGET))
 		}
 		Text(
 			text = symbol.kind.badge,
@@ -204,22 +207,20 @@ private fun OutlineRow(
 			color = badgeColorFor(symbol.kind),
 			modifier = Modifier.padding(start = 2.dp, end = 8.dp),
 		)
-		Text(
-			text = symbol.name,
-			style = MaterialTheme.typography.bodyMedium,
-		)
-		symbol.detail?.let { detail ->
+		Column(modifier = Modifier.weight(1f).padding(vertical = 4.dp)) {
 			Text(
-				text = detail,
-				style = MaterialTheme.typography.bodySmall,
-				color = MaterialTheme.colorScheme.onSurfaceVariant,
-				maxLines = 1,
-				overflow = TextOverflow.Ellipsis,
-				modifier =
-					Modifier
-						.weight(1f, fill = false)
-						.padding(start = 8.dp, top = 2.dp),
+				text = symbol.name,
+				style = MaterialTheme.typography.bodyMedium,
 			)
+			symbol.detail?.let { detail ->
+				Text(
+					text = detail,
+					style = MaterialTheme.typography.bodySmall,
+					color = MaterialTheme.colorScheme.onSurfaceVariant,
+					maxLines = 1,
+					overflow = TextOverflow.Ellipsis,
+				)
+			}
 		}
 	}
 }
diff --git a/app/src/main/java/com/itsaky/androidide/ui/outline/OutlineRows.kt b/app/src/main/java/com/itsaky/androidide/ui/outline/OutlineRows.kt
index 1018b99a42..1e8e116d63 100644
--- a/app/src/main/java/com/itsaky/androidide/ui/outline/OutlineRows.kt
+++ b/app/src/main/java/com/itsaky/androidide/ui/outline/OutlineRows.kt
@@ -17,10 +17,8 @@ internal fun flattenOutline(
 	val rows = mutableListOf<OutlineRowModel>()
 
 	fun walk(siblings: List<OutlineSymbol>, parentPath: String, depth: Int) {
-		val occurrences = mutableMapOf<String, Int>()
-		siblings.forEach { symbol ->
-			val n = occurrences.merge(symbol.name, 1, Int::plus)!!
-			val segment = if (n == 1) symbol.name else "${symbol.name}#$n"
+		siblings.forEachIndexed { index, symbol ->
+			val segment = "${symbol.name}#$index"
 			val path = if (parentPath.isEmpty()) segment else "$parentPath/$segment"
 			val collapsed = path in collapsedPaths
 			rows.add(
diff --git a/app/src/main/java/com/itsaky/androidide/viewmodel/EditorViewModel.kt b/app/src/main/java/com/itsaky/androidide/viewmodel/EditorViewModel.kt
index 58ae01bb52..d7ce797641 100644
--- a/app/src/main/java/com/itsaky/androidide/viewmodel/EditorViewModel.kt
+++ b/app/src/main/java/com/itsaky/androidide/viewmodel/EditorViewModel.kt
@@ -18,6 +18,7 @@ package com.itsaky.androidide.viewmodel
 
 import android.view.Gravity.CENTER
 import androidx.lifecycle.LifecycleOwner
+import androidx.lifecycle.LiveData
 import androidx.lifecycle.MutableLiveData
 import androidx.lifecycle.Observer
 import androidx.lifecycle.ViewModel
@@ -108,6 +109,7 @@ class EditorViewModel : ViewModel() {
 	 * index of the editor opened. Second value is the file that is opened.
 	 */
 	private val mCurrentFile = MutableLiveData<Pair<Int, File?>?>(null)
+	val currentFile: LiveData<Pair<Int, File?>?> get() = mCurrentFile
 
 	var areFilesModified: Boolean
 		get() = _filesModified.value ?: false
diff --git a/app/src/main/java/com/itsaky/androidide/viewmodel/OutlineViewModel.kt b/app/src/main/java/com/itsaky/androidide/viewmodel/OutlineViewModel.kt
index f0759afa42..0c56ad2c75 100644
--- a/app/src/main/java/com/itsaky/androidide/viewmodel/OutlineViewModel.kt
+++ b/app/src/main/java/com/itsaky/androidide/viewmodel/OutlineViewModel.kt
@@ -12,10 +12,13 @@ import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.FlowPreview
 import kotlinx.coroutines.flow.MutableSharedFlow
 import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.SharingStarted
+import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.asSharedFlow
-import kotlinx.coroutines.flow.asStateFlow
 import kotlinx.coroutines.flow.collectLatest
+import kotlinx.coroutines.flow.combine
 import kotlinx.coroutines.flow.debounce
+import kotlinx.coroutines.flow.stateIn
 import kotlinx.coroutines.flow.update
 import kotlinx.coroutines.launch
 import org.slf4j.LoggerFactory
@@ -33,17 +36,23 @@ class OutlineViewModel(
 		val fileName: String get() = path.substringAfterLast('/')
 	}
 
+	private data class Collapsed(
+		val path: String?,
+		val paths: Set<String>,
+	)
+
 	private val snapshots = MutableStateFlow<Snapshot?>(null)
+	private val computed = MutableStateFlow<OutlineUiState>(OutlineUiState.NoFileOpen)
+	private val collapsed = MutableStateFlow(Collapsed(path = null, paths = emptySet()))
 
-	private val _uiState = MutableStateFlow<OutlineUiState>(OutlineUiState.NoFileOpen)
-	val uiState = _uiState.asStateFlow()
+	val uiState: StateFlow<OutlineUiState> =
+		combine(computed, collapsed) { state, collapse ->
+			if (state is OutlineUiState.Content) state.copy(collapsedPaths = collapse.paths) else state
+		}.stateIn(viewModelScope, SharingStarted.Eagerly, OutlineUiState.NoFileOpen)
 
 	private val _effects = MutableSharedFlow<OutlineUiEffect>()
 	val effects = _effects.asSharedFlow()
 
-	private var collapsedPaths = emptySet<String>()
-	private var collapsedForPath: String? = null
-
 	companion object {
 		private const val DEBOUNCE_MILLIS = 250L
 		private val log = LoggerFactory.getLogger(OutlineViewModel::class.java)
@@ -89,24 +98,23 @@ class OutlineViewModel(
 			}
 
 			is OutlineUiEvent.ToggleCollapsed -> {
-				toggleCollapsed(event.path)
+				collapsed.update { it.copy(paths = if (event.path in it.paths) it.paths - event.path else it.paths + event.path) }
 			}
 		}
 	}
 
 	private suspend fun compute(snapshot: Snapshot?) {
 		if (snapshot == null) {
-			_uiState.value = OutlineUiState.NoFileOpen
+			computed.value = OutlineUiState.NoFileOpen
 			return
 		}
 		if (!outlineProvider.supports(snapshot.extension)) {
-			_uiState.value = OutlineUiState.Unsupported(snapshot.fileName)
+			computed.value = OutlineUiState.Unsupported(snapshot.fileName)
 			return
 		}
-		if (collapsedForPath != snapshot.path) {
-			collapsedForPath = snapshot.path
-			collapsedPaths = emptySet()
-			_uiState.value = OutlineUiState.Loading(snapshot.fileName)
+		if (collapsed.value.path != snapshot.path) {
+			collapsed.value = Collapsed(snapshot.path, emptySet())
+			computed.value = OutlineUiState.Loading(snapshot.fileName)
 		}
 		val symbols =
 			try {
@@ -117,18 +125,11 @@ class OutlineViewModel(
 				log.error("Failed to compute outline for {}", snapshot.fileName, e)
 				emptyList()
 			}
-		_uiState.value =
+		computed.value =
 			if (symbols.isEmpty()) {
 				OutlineUiState.Empty(snapshot.fileName)
 			} else {
-				OutlineUiState.Content(snapshot.fileName, symbols, collapsedPaths)
+				OutlineUiState.Content(snapshot.fileName, symbols, emptySet())
 			}
 	}
-
-	private fun toggleCollapsed(path: String) {
-		collapsedPaths = if (path in collapsedPaths) collapsedPaths - path else collapsedPaths + path
-		_uiState.update { state ->
-			if (state is OutlineUiState.Content) state.copy(collapsedPaths = collapsedPaths) else state
-		}
-	}
 }
diff --git a/app/src/test/java/com/itsaky/androidide/ui/outline/OutlineRowsTest.kt b/app/src/test/java/com/itsaky/androidide/ui/outline/OutlineRowsTest.kt
index b49dfb4fa0..3832cdd367 100644
--- a/app/src/test/java/com/itsaky/androidide/ui/outline/OutlineRowsTest.kt
+++ b/app/src/test/java/com/itsaky/androidide/ui/outline/OutlineRowsTest.kt
@@ -31,7 +31,7 @@ class OutlineRowsTest {
 	@Test
 	fun `collapsed path hides descendants but keeps the row`() {
 		val tree = listOf(symbol("a", listOf(symbol("b", listOf(symbol("c"))))))
-		val rows = flattenOutline(tree, setOf("a/b"))
+		val rows = flattenOutline(tree, setOf("a#0/b#0"))
 		assertThat(rows.map { it.symbol.name }).containsExactly("a", "b").inOrder()
 		assertThat(rows[1].collapsed).isTrue()
 		assertThat(rows[1].hasChildren).isTrue()
@@ -42,7 +42,7 @@ class OutlineRowsTest {
 		val tree = listOf(symbol("cls", listOf(symbol("bind"), symbol("bind"), symbol("other"))))
 		val rows = flattenOutline(tree, emptySet())
 		assertThat(rows.map { it.path })
-			.containsExactly("cls", "cls/bind", "cls/bind#2", "cls/other")
+			.containsExactly("cls#0", "cls#0/bind#0", "cls#0/bind#1", "cls#0/other#2")
 			.inOrder()
 	}
 
diff --git a/app/src/test/java/com/itsaky/androidide/viewmodel/OutlineViewModelTest.kt b/app/src/test/java/com/itsaky/androidide/viewmodel/OutlineViewModelTest.kt
index 377af3353a..c0c1bfccf8 100644
--- a/app/src/test/java/com/itsaky/androidide/viewmodel/OutlineViewModelTest.kt
+++ b/app/src/test/java/com/itsaky/androidide/viewmodel/OutlineViewModelTest.kt
@@ -75,8 +75,8 @@ class OutlineViewModelTest {
 			val vm = viewModel(provider)
 			vm.onSnapshot("/a/Main.java", "java", "class Main {}", immediate = true)
 			advanceTimeBy(1)
-			vm.onEvent(OutlineUiEvent.ToggleCollapsed("Main"))
-			assertThat((vm.uiState.value as OutlineUiState.Content).collapsedPaths).containsExactly("Main")
+			vm.onEvent(OutlineUiEvent.ToggleCollapsed("Main#0"))
+			assertThat((vm.uiState.value as OutlineUiState.Content).collapsedPaths).containsExactly("Main#0")
 
 			vm.onSnapshot("/b/Main.java", "java", "class Main {}", immediate = true)
 			advanceTimeBy(1)
@@ -165,13 +165,13 @@ class OutlineViewModelTest {
 			val vm = viewModel(provider)
 			vm.onSnapshot("Main.java", "java", "v1", immediate = true)
 			advanceUntilIdle()
-			vm.onEvent(OutlineUiEvent.ToggleCollapsed("Main"))
+			vm.onEvent(OutlineUiEvent.ToggleCollapsed("Main#0"))
 			assertThat((vm.uiState.value as OutlineUiState.Content).collapsedPaths)
-				.containsExactly("Main")
+				.containsExactly("Main#0")
 			vm.onSnapshot("Main.java", "java", "v2", immediate = false)
 			advanceUntilIdle()
 			assertThat((vm.uiState.value as OutlineUiState.Content).collapsedPaths)
-				.containsExactly("Main")
+				.containsExactly("Main#0")
 		}
 
 	@Test
@@ -181,7 +181,7 @@ class OutlineViewModelTest {
 			val vm = viewModel(provider)
 			vm.onSnapshot("Main.java", "java", "v1", immediate = true)
 			advanceUntilIdle()
-			vm.onEvent(OutlineUiEvent.ToggleCollapsed("Main"))
+			vm.onEvent(OutlineUiEvent.ToggleCollapsed("Main#0"))
 			provider.gate = CompletableDeferred()
 			vm.onSnapshot("Other.java", "java", "v1", immediate = true)
 			advanceUntilIdle()
diff --git a/editor/build.gradle.kts b/editor/build.gradle.kts
index 04d67a8d9d..6109bbedf6 100644
--- a/editor/build.gradle.kts
+++ b/editor/build.gradle.kts
@@ -60,6 +60,7 @@ dependencies {
 
 	testImplementation(projects.testing.unit)
 	androidTestImplementation(projects.testing.android) {
+		// kt-android.jar (kotlin-analysis-api) bundles kotlin.reflect.full; a second copy fails packaging with duplicate classes
 		exclude(group = "org.jetbrains.kotlin", module = "kotlin-reflect")
 	}
 }
diff --git a/editor/src/androidTest/AndroidManifest.xml b/editor/src/androidTest/AndroidManifest.xml
index a0720473d9..c0cac8d32f 100644
--- a/editor/src/androidTest/AndroidManifest.xml
+++ b/editor/src/androidTest/AndroidManifest.xml
@@ -2,6 +2,7 @@
 <manifest xmlns:android="http://schemas.android.com/apk/res/android">
 
 	<application>
+		<!-- Sentry auto-init crashes the instrumentation process: "DSN is required" -->
 		<meta-data
 			android:name="io.sentry.auto-init"
 			android:value="false" />
diff --git a/editor/src/androidTest/java/com/itsaky/androidide/editor/language/outline/TreeSitterOutlineProviderTest.kt b/editor/src/androidTest/java/com/itsaky/androidide/editor/language/outline/TreeSitterOutlineProviderTest.kt
index 607d1e4d0f..4f4f4a1bdd 100644
--- a/editor/src/androidTest/java/com/itsaky/androidide/editor/language/outline/TreeSitterOutlineProviderTest.kt
+++ b/editor/src/androidTest/java/com/itsaky/androidide/editor/language/outline/TreeSitterOutlineProviderTest.kt
@@ -16,6 +16,7 @@ class TreeSitterOutlineProviderTest {
 		"""
 		public class Main {
 			private int count;
+			private int x, y;
 			public Main() {
 			}
 			public void run(String[] args) {
@@ -37,13 +38,23 @@ class TreeSitterOutlineProviderTest {
 			}
 			var count = 0
 			fun add(item: String): Boolean {
-				return true
+				val tmp = item.length
+				return tmp > 0
 			}
 			constructor(name: String, count: Int) : this(name) {
 				this.count = count
 			}
 		}
+
+		interface Greeter {
+			fun greet()
+		}
+
+		enum class Kind {
+			LOCAL, REMOTE
+		}
 		fun topLevel() {
+			val local = 1
 		}
 		""".trimIndent()
 
@@ -87,21 +98,23 @@ class TreeSitterOutlineProviderTest {
 			assertThat(main.name).isEqualTo("Main")
 			assertThat(main.kind).isEqualTo(OutlineSymbolKind.CLASS)
 			assertThat(main.children.map { it.name })
-				.containsExactly("count", "Main", "run", "Inner", "Kind")
+				.containsExactly("count", "x", "y", "Main", "run", "Inner", "Kind")
 				.inOrder()
 			assertThat(main.children.map { it.kind })
 				.containsExactly(
+					OutlineSymbolKind.FIELD,
+					OutlineSymbolKind.FIELD,
 					OutlineSymbolKind.FIELD,
 					OutlineSymbolKind.CONSTRUCTOR,
 					OutlineSymbolKind.METHOD,
 					OutlineSymbolKind.INTERFACE,
 					OutlineSymbolKind.ENUM,
 				).inOrder()
-			val run = main.children[2]
+			val run = main.children[4]
 			assertThat(run.detail).isEqualTo("(String[] args)")
-			val inner = main.children[3]
+			val inner = main.children[5]
 			assertThat(inner.children.map { it.name }).containsExactly("call")
-			val kind = main.children[4]
+			val kind = main.children[6]
 			assertThat(kind.children.map { it.name }).containsExactly("LOCAL", "REMOTE").inOrder()
 			assertThat(kind.children.map { it.kind }.toSet())
 				.containsExactly(OutlineSymbolKind.ENUM_MEMBER)
@@ -112,7 +125,7 @@ class TreeSitterOutlineProviderTest {
 		runBlocking<Unit> {
 			val roots = provider.outlineOf("java", javaSource)
 			val run = roots[0].children.first { it.name == "run" }
-			assertThat(run.selectionRange.start.line).isEqualTo(4)
+			assertThat(run.selectionRange.start.line).isEqualTo(5)
 			assertThat(run.selectionRange.start.column).isEqualTo(13)
 		}
 
@@ -120,7 +133,7 @@ class TreeSitterOutlineProviderTest {
 	fun kotlinOutlineHasExpectedStructure() =
 		runBlocking<Unit> {
 			val roots = provider.outlineOf("kt", kotlinSource)
-			assertThat(roots.map { it.name }).containsExactly("Repo", "topLevel").inOrder()
+			assertThat(roots.map { it.name }).containsExactly("Repo", "Greeter", "Kind", "topLevel").inOrder()
 			val repo = roots[0]
 			assertThat(repo.kind).isEqualTo(OutlineSymbolKind.CLASS)
 			val childNames = repo.children.map { it.name }
@@ -135,6 +148,14 @@ class TreeSitterOutlineProviderTest {
 			assertThat(add.detail).isEqualTo("(item: String)")
 			val ctor = repo.children[4]
 			assertThat(ctor.kind).isEqualTo(OutlineSymbolKind.CONSTRUCTOR)
+			assertThat(add.children).isEmpty()
+			val greeter = roots[1]
+			assertThat(greeter.kind).isEqualTo(OutlineSymbolKind.INTERFACE)
+			assertThat(greeter.children.map { it.name }).containsExactly("greet")
+			val kind = roots[2]
+			assertThat(kind.kind).isEqualTo(OutlineSymbolKind.ENUM)
+			assertThat(kind.children.map { it.name }).containsExactly("LOCAL", "REMOTE").inOrder()
+			assertThat(roots[3].children).isEmpty()
 		}
 
 	@Test
diff --git a/editor/src/main/assets/editor/treesitter/java/outline.scm b/editor/src/main/assets/editor/treesitter/java/outline.scm
index 913408e580..60e643b4c9 100644
--- a/editor/src/main/assets/editor/treesitter/java/outline.scm
+++ b/editor/src/main/assets/editor/treesitter/java/outline.scm
@@ -26,4 +26,4 @@
 
 (field_declaration
   declarator: (variable_declarator
-    name: (identifier) @name)) @symbol.field
+    name: (identifier) @name) @symbol.field)
diff --git a/editor/src/main/assets/editor/treesitter/kt/outline.scm b/editor/src/main/assets/editor/treesitter/kt/outline.scm
index 4fca0dc71d..c5b533ce46 100644
--- a/editor/src/main/assets/editor/treesitter/kt/outline.scm
+++ b/editor/src/main/assets/editor/treesitter/kt/outline.scm
@@ -1,3 +1,11 @@
+(class_declaration
+  "interface"
+  (type_identifier) @name) @symbol.interface
+
+(class_declaration
+  (type_identifier) @name
+  (enum_class_body)) @symbol.enum
+
 (class_declaration
   (type_identifier) @name) @symbol.class
 
@@ -19,9 +27,20 @@
 (secondary_constructor
   (function_value_parameters) @detail) @symbol.constructor
 
-(property_declaration
-  (variable_declaration
-    (simple_identifier) @name)) @symbol.property
+(class_body
+  (property_declaration
+    (variable_declaration
+      (simple_identifier) @name)) @symbol.property)
+
+(enum_class_body
+  (property_declaration
+    (variable_declaration
+      (simple_identifier) @name)) @symbol.property)
+
+(source_file
+  (property_declaration
+    (variable_declaration
+      (simple_identifier) @name)) @symbol.property)
 
 (class_parameter
   ["val" "var"]
diff --git a/editor/src/main/java/com/itsaky/androidide/editor/language/outline/TreeSitterOutlineProvider.kt b/editor/src/main/java/com/itsaky/androidide/editor/language/outline/TreeSitterOutlineProvider.kt
index 902a3aa41d..3f1a5341c7 100644
--- a/editor/src/main/java/com/itsaky/androidide/editor/language/outline/TreeSitterOutlineProvider.kt
+++ b/editor/src/main/java/com/itsaky/androidide/editor/language/outline/TreeSitterOutlineProvider.kt
@@ -21,6 +21,8 @@ import com.itsaky.androidide.treesitter.java.TSLanguageJava
 import com.itsaky.androidide.treesitter.kotlin.TSLanguageKotlin
 import com.itsaky.androidide.treesitter.xml.TSLanguageXml
 import io.github.rosemoe.sora.editor.ts.predicate.Predicator
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
 import java.util.concurrent.ConcurrentHashMap
 
 class TreeSitterOutlineProvider(
@@ -70,19 +72,20 @@ class TreeSitterOutlineProvider(
 	override suspend fun outlineOf(
 		fileExtension: String,
 		text: CharSequence,
-	): List<OutlineSymbol> {
-		val type =
-			TYPE_BY_EXTENSION[fileExtension.lowercase()]
-				?: throw IllegalArgumentException("No outline support for file extension '$fileExtension'")
-		val queries = queriesByType.computeIfAbsent(type) { loadQueries(it) }
-		val source = text.toString()
-		return TSParser.create().use { parser ->
-			parser.language = queries.language
-			parser.parseString(source).use { tree ->
-				extract(queries, tree, source)
+	): List<OutlineSymbol> =
+		withContext(Dispatchers.Default) {
+			val type =
+				TYPE_BY_EXTENSION[fileExtension.lowercase()]
+					?: throw IllegalArgumentException("No outline support for file extension '$fileExtension'")
+			val queries = queriesByType.computeIfAbsent(type) { loadQueries(it) }
+			val source = text.toString()
+			TSParser.create().use { parser ->
+				parser.language = queries.language
+				parser.parseString(source).use { tree ->
+					extract(queries, tree, source)
+				}
 			}
 		}
-	}
 
 	private fun loadQueries(type: String): LanguageQueries {
 		val scm =
@@ -113,7 +116,8 @@ class TreeSitterOutlineProvider(
 		tree: TSTree,
 		source: String,
 	): List<OutlineSymbol> {
-		val rawByNode = LinkedHashMap<Pair<Int, Int>, RawOutlineSymbol>()
+		val rawByName = LinkedHashMap<Pair<Int, Int>, RawOutlineSymbol>()
+		val patternByName = HashMap<Pair<Int, Int>, Int>()
 		TSQueryCursor.create().use { cursor ->
 			cursor.safeExecQueryCursor(
 				query = queries.query,
@@ -126,9 +130,10 @@ class TreeSitterOutlineProvider(
 				}
 				var kind: OutlineSymbolKind? = null
 				var symbolStartByte = 0
-				var symbolEndByte = 0
 				var symbolRange: Range? = null
 				var name: String? = null
+				var nameStartByte = -1
+				var nameEndByte = -1
 				var selectionRange: Range? = null
 				var detail: String? = null
 				match.captures.forEach { capture ->
@@ -138,12 +143,13 @@ class TreeSitterOutlineProvider(
 						captureName.startsWith(SYMBOL_CAPTURE_PREFIX) -> {
 							kind = kindOf(captureName.removePrefix(SYMBOL_CAPTURE_PREFIX))
 							symbolStartByte = node.startByte
-							symbolEndByte = node.endByte
 							symbolRange = rangeOf(node)
 						}
 
 						captureName == NAME_CAPTURE -> {
 							name = textOf(node, source)
+							nameStartByte = node.startByte
+							nameEndByte = node.endByte
 							selectionRange = rangeOf(node)
 						}
 
@@ -163,14 +169,23 @@ class TreeSitterOutlineProvider(
 						range = range,
 						selectionRange = selectionRange ?: Range(range.start, range.start),
 					)
-				val key = symbolStartByte to symbolEndByte
-				val existing = rawByNode[key]
-				if (existing == null || (existing.detail == null && raw.detail != null)) {
-					rawByNode[key] = raw
+				val key = if (nameStartByte >= 0) nameStartByte to nameEndByte else symbolStartByte to symbolStartByte
+				val existing = rawByName[key]
+				val existingPattern = patternByName[key]
+				val preferred =
+					when {
+						existing == null -> true
+						existing.detail == null && raw.detail != null -> true
+						existing.detail != null && raw.detail == null -> false
+						else -> match.patternIndex < existingPattern!!
+					}
+				if (preferred) {
+					rawByName[key] = raw
+					patternByName[key] = match.patternIndex
 				}
 			}
 		}
-		return OutlineTreeBuilder.build(rawByNode.values.toList())
+		return OutlineTreeBuilder.build(rawByName.values.toList())
 	}
 
 	private fun kindOf(suffix: String): OutlineSymbolKind {

From 01a4300eb457fedc748084a02c1e57d0e5d46358 Mon Sep 17 00:00:00 2001
From: Daniel Alome <astrocoder007@gmail.com>
Date: Wed, 9 Sep 2026 22:31:18 +0100
Subject: [PATCH 18/20] ADFA-2448: Stop parsing for a hidden panel, scope
 Kotlin functions, run the editor suite on red nights

Round-3 review follow-ups from itsaky-adfa.

Blocking three:

- OutlineFragment holds the DrawerLayout it registers on and gates every
  snapshot on the drawer being open, so a closed panel stops re-parsing the
  file on each typing pause. A DrawerListener re-seeds on open, which is what
  keeps a file switch made while the drawer was closed from going unnoticed.
- kt/outline.scm anchors function_declaration to class_body, enum_class_body
  and source_file like the property patterns, so a local fun no longer shows
  up in an outline that already drops local vals. The instrumented fixture
  gained `fun helper()` inside add().
- instrumentation-test.yml captures each suite's exit code with
  `|| SUITE_EXIT_CODE=$?` instead of letting bash -e abort the step, so the
  editor suite runs even when the Kotlin or Groovy one fails, and a trailing
  check re-fails the step if any suite failed. Plain `|| true` would have
  turned a failing nightly green.

Also:

- centerPositionInView re-checks isValidPosition inside onDrawerClosed; the
  earlier check was several hundred milliseconds stale by then.
- A named companion keeps its name: one pattern with an optional capture,
  `(companion_object (type_identifier)? @name)`, covers named and anonymous
  companions without two patterns fighting over the same node.
- Dedup compares patternIndex first and uses detail only within one pattern.
  That required reordering xml/outline.scm so its two detail-bearing patterns
  precede the plain ones; otherwise the id detail on an XML element would have
  been dropped by the new precedence.
- OutlineSymbolKind.fromCaptureSuffix owns the capture-to-kind mapping, and a
  new JVM test (OutlineQueryCapturesTest) asserts every @symbol.* capture in
  all three .scm files resolves to a kind, so a typo fails the gating suite
  rather than showing an empty outline.
- The kotlin-reflect exclude records that MockK is unusable in editor
  androidTest as a consequence.
- extract() takes the coroutine context and calls ensureActive() per match, so
  a superseded parse stops at the next match instead of running to completion.
- OutlineFragment.onDestroyView calls onNoEditor(), releasing the document copy
  the activity-scoped view model would otherwise hold after the panel is gone.
- Content no longer carries an always-empty collapsedPaths; the panel collects
  collapsedPaths from its own StateFlow, which also removes the combine.
- compute() resets the collapse set with a single getAndUpdate, so both writers
  now go through one atomic operation.
- OutlineTreeBuilder pops until the stack top strictly contains the candidate,
  so a partial overlap or an identical range makes a sibling, not a child.
---
 .github/workflows/instrumentation-test.yml    | 18 ++++---
 .../fragments/sidebar/OutlineFragment.kt      | 33 +++++++++++--
 .../androidide/ui/models/OutlineUiState.kt    |  1 -
 .../androidide/ui/outline/OutlinePanel.kt     | 11 +++--
 .../androidide/viewmodel/OutlineViewModel.kt  | 28 ++++++-----
 .../viewmodel/OutlineViewModelTest.kt         | 10 ++--
 editor/build.gradle.kts                       |  4 +-
 .../outline/TreeSitterOutlineProviderTest.kt  |  7 +--
 .../assets/editor/treesitter/kt/outline.scm   | 20 ++++++--
 .../assets/editor/treesitter/xml/outline.scm  | 14 +++---
 .../editor/language/outline/OutlineSymbol.kt  | 10 ++++
 .../language/outline/OutlineTreeBuilder.kt    | 15 ++++--
 .../outline/TreeSitterOutlineProvider.kt      | 19 ++++----
 .../outline/OutlineQueryCapturesTest.kt       | 48 +++++++++++++++++++
 14 files changed, 178 insertions(+), 60 deletions(-)
 create mode 100644 editor/src/test/java/com/itsaky/androidide/editor/language/outline/OutlineQueryCapturesTest.kt

diff --git a/.github/workflows/instrumentation-test.yml b/.github/workflows/instrumentation-test.yml
index ff90341597..ee53cff3d2 100644
--- a/.github/workflows/instrumentation-test.yml
+++ b/.github/workflows/instrumentation-test.yml
@@ -83,6 +83,9 @@ jobs:
       - name: Run Firebase Test Lab and Wait for Results
         run: |
           mkdir -p test-results/kotlin test-results/groovy test-results/editor
+          KOTLIN_EXIT_CODE=0
+          GROOVY_EXIT_CODE=0
+          EDITOR_EXIT_CODE=0
           
           # Run Kotlin DSL tests
           echo "Running Kotlin DSL tests..."
@@ -98,9 +101,8 @@ jobs:
             --results-dir=test-results/kotlin \
             --results-bucket=gs://firebase-test-results-${RANDOM} \
             --project=codeonthego-64a92 \
-            --test-targets "class com.itsaky.androidide.ProjectBuildTestWithKtsGradle" > test-results/kotlin/test_output.txt 2>&1
+            --test-targets "class com.itsaky.androidide.ProjectBuildTestWithKtsGradle" > test-results/kotlin/test_output.txt 2>&1 || KOTLIN_EXIT_CODE=$?
           
-          KOTLIN_EXIT_CODE=$?
           echo "Kotlin tests exit code: $KOTLIN_EXIT_CODE"
           
           # Extract Firebase Test Lab URL for Kotlin tests
@@ -127,9 +129,8 @@ jobs:
             --results-dir=test-results/groovy \
             --results-bucket=gs://firebase-test-results-${RANDOM} \
             --project=codeonthego-64a92 \
-            --test-targets "class com.itsaky.androidide.ProjectBuildTestWithGroovyGradle" > test-results/groovy/test_output.txt 2>&1
+            --test-targets "class com.itsaky.androidide.ProjectBuildTestWithGroovyGradle" > test-results/groovy/test_output.txt 2>&1 || GROOVY_EXIT_CODE=$?
           
-          GROOVY_EXIT_CODE=$?
           echo "Groovy tests exit code: $GROOVY_EXIT_CODE"
           
           # Extract Firebase Test Lab URL for Groovy tests
@@ -154,13 +155,18 @@ jobs:
             --num-flaky-test-attempts=1 \
             --results-dir=test-results/editor \
             --results-bucket=gs://firebase-test-results-${RANDOM} \
-            --project=codeonthego-64a92 > test-results/editor/test_output.txt 2>&1
+            --project=codeonthego-64a92 > test-results/editor/test_output.txt 2>&1 || EDITOR_EXIT_CODE=$?
 
-          EDITOR_EXIT_CODE=$?
           echo "Editor tests exit code: $EDITOR_EXIT_CODE"
           EDITOR_TEST_URL=$(grep -o 'https://console.firebase.google.com/project/[^[:space:]]*' test-results/editor/test_output.txt | head -1 || echo "")
           echo "EDITOR_TEST_URL=$EDITOR_TEST_URL" >> $GITHUB_ENV
 
+          # Every suite runs even when an earlier one fails, but a failure still fails the step.
+          if [ "$KOTLIN_EXIT_CODE" -ne 0 ] || [ "$GROOVY_EXIT_CODE" -ne 0 ] || [ "$EDITOR_EXIT_CODE" -ne 0 ]; then
+            echo "Instrumentation suites failed (kotlin=$KOTLIN_EXIT_CODE groovy=$GROOVY_EXIT_CODE editor=$EDITOR_EXIT_CODE)"
+            exit 1
+          fi
+
       - name: Notify Slack with parsed test results
         if: always()  # Run even if tests fail
         run: |
diff --git a/app/src/main/java/com/itsaky/androidide/fragments/sidebar/OutlineFragment.kt b/app/src/main/java/com/itsaky/androidide/fragments/sidebar/OutlineFragment.kt
index e34676f4d6..9488421870 100644
--- a/app/src/main/java/com/itsaky/androidide/fragments/sidebar/OutlineFragment.kt
+++ b/app/src/main/java/com/itsaky/androidide/fragments/sidebar/OutlineFragment.kt
@@ -32,6 +32,14 @@ import java.nio.file.Path
 class OutlineFragment : Fragment() {
 	private val viewModel: OutlineViewModel by activityViewModel()
 	private val editorViewModel: EditorViewModel by activityViewModels()
+	private var drawer: DrawerLayout? = null
+
+	private val drawerListener =
+		object : DrawerLayout.SimpleDrawerListener() {
+			override fun onDrawerOpened(drawerView: View) {
+				seedFromCurrentEditor()
+			}
+		}
 
 	override fun onCreateView(
 		inflater: LayoutInflater,
@@ -52,6 +60,10 @@ class OutlineFragment : Fragment() {
 		savedInstanceState: Bundle?,
 	) {
 		super.onViewCreated(view, savedInstanceState)
+		drawer =
+			(activity as? EditorHandlerActivity)?.binding?.editorDrawerLayout?.also {
+				it.addDrawerListener(drawerListener)
+			}
 		editorViewModel.currentFile.observe(viewLifecycleOwner) { view.post { seedFromCurrentEditor() } }
 		viewLifecycleOwner.lifecycleScope.launch {
 			viewLifecycleOwner.repeatOnLifecycle(Lifecycle.State.STARTED) {
@@ -64,6 +76,13 @@ class OutlineFragment : Fragment() {
 		}
 	}
 
+	override fun onDestroyView() {
+		drawer?.removeDrawerListener(drawerListener)
+		drawer = null
+		viewModel.onNoEditor()
+		super.onDestroyView()
+	}
+
 	override fun onStart() {
 		super.onStart()
 		if (!EventBus.getDefault().isRegistered(this)) {
@@ -78,6 +97,7 @@ class OutlineFragment : Fragment() {
 
 	@Subscribe(threadMode = MAIN)
 	fun onDocumentChanged(event: DocumentChangeEvent) {
+		if (!isPanelVisible()) return
 		val editor = currentEditor() ?: return
 		val file = editor.file ?: return
 		if (normalized(file.toPath()) != normalized(event.changedFile)) return
@@ -91,6 +111,7 @@ class OutlineFragment : Fragment() {
 
 	@Subscribe(threadMode = MAIN)
 	fun onDocumentOpened(event: DocumentOpenEvent) {
+		if (!isPanelVisible()) return
 		val file = currentEditor()?.file ?: return
 		if (normalized(file.toPath()) != normalized(event.openedFile)) return
 		viewModel.onSnapshot(
@@ -102,6 +123,7 @@ class OutlineFragment : Fragment() {
 	}
 
 	private fun seedFromCurrentEditor() {
+		if (!isPanelVisible()) return
 		val editor = currentEditor()
 		val file = editor?.file
 		if (editor == null || file == null) {
@@ -118,12 +140,13 @@ class OutlineFragment : Fragment() {
 
 	private fun currentEditor() = (activity as? EditorHandlerActivity)?.getCurrentEditor()?.editor
 
+	private fun isPanelVisible(): Boolean = drawer?.isDrawerOpen(GravityCompat.START) == true
+
 	private fun normalized(path: Path): String = path.toAbsolutePath().normalize().toString()
 
 	private fun navigateTo(position: Position) {
-		val editorActivity = activity as? EditorHandlerActivity ?: return
-		val drawer = editorActivity.binding.editorDrawerLayout
-		val editor = editorActivity.getCurrentEditor()?.editor
+		val drawer = drawer ?: return
+		val editor = currentEditor()
 		if (editor == null || !editor.isValidPosition(position, true)) {
 			drawer.closeDrawer(GravityCompat.START)
 			return
@@ -137,7 +160,9 @@ class OutlineFragment : Fragment() {
 			object : DrawerLayout.SimpleDrawerListener() {
 				override fun onDrawerClosed(drawerView: View) {
 					drawer.removeDrawerListener(this)
-					centerPositionInView(editor, position)
+					if (editor.isValidPosition(position, true)) {
+						centerPositionInView(editor, position)
+					}
 				}
 			},
 		)
diff --git a/app/src/main/java/com/itsaky/androidide/ui/models/OutlineUiState.kt b/app/src/main/java/com/itsaky/androidide/ui/models/OutlineUiState.kt
index d1cc18e5a5..b08f2961d3 100644
--- a/app/src/main/java/com/itsaky/androidide/ui/models/OutlineUiState.kt
+++ b/app/src/main/java/com/itsaky/androidide/ui/models/OutlineUiState.kt
@@ -21,7 +21,6 @@ sealed interface OutlineUiState {
 	data class Content(
 		val fileName: String,
 		val symbols: List<OutlineSymbol>,
-		val collapsedPaths: Set<String>,
 	) : OutlineUiState
 }
 
diff --git a/app/src/main/java/com/itsaky/androidide/ui/outline/OutlinePanel.kt b/app/src/main/java/com/itsaky/androidide/ui/outline/OutlinePanel.kt
index 5060d4859b..26438c68f9 100644
--- a/app/src/main/java/com/itsaky/androidide/ui/outline/OutlinePanel.kt
+++ b/app/src/main/java/com/itsaky/androidide/ui/outline/OutlinePanel.kt
@@ -75,12 +75,14 @@ fun OutlinePanel(
 	modifier: Modifier = Modifier,
 ) {
 	val state by viewModel.uiState.collectAsStateWithLifecycle()
-	OutlinePanelContent(state = state, onEvent = viewModel::onEvent, modifier = modifier)
+	val collapsedPaths by viewModel.collapsedPaths.collectAsStateWithLifecycle()
+	OutlinePanelContent(state = state, collapsedPaths = collapsedPaths, onEvent = viewModel::onEvent, modifier = modifier)
 }
 
 @Composable
 internal fun OutlinePanelContent(
 	state: OutlineUiState,
+	collapsedPaths: Set<String>,
 	onEvent: (OutlineUiEvent) -> Unit,
 	modifier: Modifier = Modifier,
 ) {
@@ -102,7 +104,7 @@ internal fun OutlinePanelContent(
 		}
 
 		is OutlineUiState.Content -> {
-			OutlineTree(state, onEvent, modifier)
+			OutlineTree(state, collapsedPaths, onEvent, modifier)
 		}
 	}
 }
@@ -130,12 +132,13 @@ private fun CenteredMessage(
 @Composable
 private fun OutlineTree(
 	state: OutlineUiState.Content,
+	collapsedPaths: Set<String>,
 	onEvent: (OutlineUiEvent) -> Unit,
 	modifier: Modifier = Modifier,
 ) {
 	val rows =
-		remember(state.symbols, state.collapsedPaths) {
-			flattenOutline(state.symbols, state.collapsedPaths)
+		remember(state.symbols, collapsedPaths) {
+			flattenOutline(state.symbols, collapsedPaths)
 		}
 	LazyColumn(modifier = modifier.fillMaxSize()) {
 		items(rows, key = { it.path }) { row ->
diff --git a/app/src/main/java/com/itsaky/androidide/viewmodel/OutlineViewModel.kt b/app/src/main/java/com/itsaky/androidide/viewmodel/OutlineViewModel.kt
index 0c56ad2c75..31d19096d4 100644
--- a/app/src/main/java/com/itsaky/androidide/viewmodel/OutlineViewModel.kt
+++ b/app/src/main/java/com/itsaky/androidide/viewmodel/OutlineViewModel.kt
@@ -15,9 +15,11 @@ import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.SharingStarted
 import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.asSharedFlow
+import kotlinx.coroutines.flow.asStateFlow
 import kotlinx.coroutines.flow.collectLatest
-import kotlinx.coroutines.flow.combine
 import kotlinx.coroutines.flow.debounce
+import kotlinx.coroutines.flow.getAndUpdate
+import kotlinx.coroutines.flow.map
 import kotlinx.coroutines.flow.stateIn
 import kotlinx.coroutines.flow.update
 import kotlinx.coroutines.launch
@@ -42,13 +44,12 @@ class OutlineViewModel(
 	)
 
 	private val snapshots = MutableStateFlow<Snapshot?>(null)
-	private val computed = MutableStateFlow<OutlineUiState>(OutlineUiState.NoFileOpen)
+	private val _uiState = MutableStateFlow<OutlineUiState>(OutlineUiState.NoFileOpen)
 	private val collapsed = MutableStateFlow(Collapsed(path = null, paths = emptySet()))
 
-	val uiState: StateFlow<OutlineUiState> =
-		combine(computed, collapsed) { state, collapse ->
-			if (state is OutlineUiState.Content) state.copy(collapsedPaths = collapse.paths) else state
-		}.stateIn(viewModelScope, SharingStarted.Eagerly, OutlineUiState.NoFileOpen)
+	val uiState: StateFlow<OutlineUiState> = _uiState.asStateFlow()
+	val collapsedPaths: StateFlow<Set<String>> =
+		collapsed.map { it.paths }.stateIn(viewModelScope, SharingStarted.Eagerly, emptySet())
 
 	private val _effects = MutableSharedFlow<OutlineUiEffect>()
 	val effects = _effects.asSharedFlow()
@@ -105,16 +106,17 @@ class OutlineViewModel(
 
 	private suspend fun compute(snapshot: Snapshot?) {
 		if (snapshot == null) {
-			computed.value = OutlineUiState.NoFileOpen
+			_uiState.value = OutlineUiState.NoFileOpen
 			return
 		}
 		if (!outlineProvider.supports(snapshot.extension)) {
-			computed.value = OutlineUiState.Unsupported(snapshot.fileName)
+			_uiState.value = OutlineUiState.Unsupported(snapshot.fileName)
 			return
 		}
-		if (collapsed.value.path != snapshot.path) {
-			collapsed.value = Collapsed(snapshot.path, emptySet())
-			computed.value = OutlineUiState.Loading(snapshot.fileName)
+		val switchedFile =
+			collapsed.getAndUpdate { if (it.path == snapshot.path) it else Collapsed(snapshot.path, emptySet()) }.path != snapshot.path
+		if (switchedFile) {
+			_uiState.value = OutlineUiState.Loading(snapshot.fileName)
 		}
 		val symbols =
 			try {
@@ -125,11 +127,11 @@ class OutlineViewModel(
 				log.error("Failed to compute outline for {}", snapshot.fileName, e)
 				emptyList()
 			}
-		computed.value =
+		_uiState.value =
 			if (symbols.isEmpty()) {
 				OutlineUiState.Empty(snapshot.fileName)
 			} else {
-				OutlineUiState.Content(snapshot.fileName, symbols, emptySet())
+				OutlineUiState.Content(snapshot.fileName, symbols)
 			}
 	}
 }
diff --git a/app/src/test/java/com/itsaky/androidide/viewmodel/OutlineViewModelTest.kt b/app/src/test/java/com/itsaky/androidide/viewmodel/OutlineViewModelTest.kt
index c0c1bfccf8..9d724f8e5e 100644
--- a/app/src/test/java/com/itsaky/androidide/viewmodel/OutlineViewModelTest.kt
+++ b/app/src/test/java/com/itsaky/androidide/viewmodel/OutlineViewModelTest.kt
@@ -76,12 +76,12 @@ class OutlineViewModelTest {
 			vm.onSnapshot("/a/Main.java", "java", "class Main {}", immediate = true)
 			advanceTimeBy(1)
 			vm.onEvent(OutlineUiEvent.ToggleCollapsed("Main#0"))
-			assertThat((vm.uiState.value as OutlineUiState.Content).collapsedPaths).containsExactly("Main#0")
+			assertThat(vm.collapsedPaths.value).containsExactly("Main#0")
 
 			vm.onSnapshot("/b/Main.java", "java", "class Main {}", immediate = true)
 			advanceTimeBy(1)
 
-			assertThat((vm.uiState.value as OutlineUiState.Content).collapsedPaths).isEmpty()
+			assertThat(vm.collapsedPaths.value).isEmpty()
 		}
 
 	@Test
@@ -166,11 +166,11 @@ class OutlineViewModelTest {
 			vm.onSnapshot("Main.java", "java", "v1", immediate = true)
 			advanceUntilIdle()
 			vm.onEvent(OutlineUiEvent.ToggleCollapsed("Main#0"))
-			assertThat((vm.uiState.value as OutlineUiState.Content).collapsedPaths)
+			assertThat(vm.collapsedPaths.value)
 				.containsExactly("Main#0")
 			vm.onSnapshot("Main.java", "java", "v2", immediate = false)
 			advanceUntilIdle()
-			assertThat((vm.uiState.value as OutlineUiState.Content).collapsedPaths)
+			assertThat(vm.collapsedPaths.value)
 				.containsExactly("Main#0")
 		}
 
@@ -188,7 +188,7 @@ class OutlineViewModelTest {
 			assertThat(vm.uiState.value).isEqualTo(OutlineUiState.Loading("Other.java"))
 			provider.gate!!.complete(Unit)
 			advanceUntilIdle()
-			assertThat((vm.uiState.value as OutlineUiState.Content).collapsedPaths).isEmpty()
+			assertThat(vm.collapsedPaths.value).isEmpty()
 		}
 
 	@Test
diff --git a/editor/build.gradle.kts b/editor/build.gradle.kts
index 6109bbedf6..33a84d1d7b 100644
--- a/editor/build.gradle.kts
+++ b/editor/build.gradle.kts
@@ -60,7 +60,9 @@ dependencies {
 
 	testImplementation(projects.testing.unit)
 	androidTestImplementation(projects.testing.android) {
-		// kt-android.jar (kotlin-analysis-api) bundles kotlin.reflect.full; a second copy fails packaging with duplicate classes
+		// kt-android.jar (kotlin-analysis-api) bundles kotlin.reflect.full; a second copy fails packaging with
+		// duplicate classes. Consequence: MockK, which testing:android exposes, cannot be used in this source
+		// set - it needs kotlin-reflect at runtime and will fail on device with NoClassDefFoundError.
 		exclude(group = "org.jetbrains.kotlin", module = "kotlin-reflect")
 	}
 }
diff --git a/editor/src/androidTest/java/com/itsaky/androidide/editor/language/outline/TreeSitterOutlineProviderTest.kt b/editor/src/androidTest/java/com/itsaky/androidide/editor/language/outline/TreeSitterOutlineProviderTest.kt
index 4f4f4a1bdd..a68deb3033 100644
--- a/editor/src/androidTest/java/com/itsaky/androidide/editor/language/outline/TreeSitterOutlineProviderTest.kt
+++ b/editor/src/androidTest/java/com/itsaky/androidide/editor/language/outline/TreeSitterOutlineProviderTest.kt
@@ -33,13 +33,14 @@ class TreeSitterOutlineProviderTest {
 	private val kotlinSource =
 		"""
 		class Repo(val name: String, tag: String) {
-			companion object {
+			companion object Factory {
 				val EMPTY = Repo("")
 			}
 			var count = 0
 			fun add(item: String): Boolean {
 				val tmp = item.length
-				return tmp > 0
+				fun helper() = tmp
+				return helper() > 0
 			}
 			constructor(name: String, count: Int) : this(name) {
 				this.count = count
@@ -138,7 +139,7 @@ class TreeSitterOutlineProviderTest {
 			assertThat(repo.kind).isEqualTo(OutlineSymbolKind.CLASS)
 			val childNames = repo.children.map { it.name }
 			assertThat(childNames)
-				.containsExactly("name", "companion object", "count", "add", "constructor")
+				.containsExactly("name", "Factory", "count", "add", "constructor")
 				.inOrder()
 			val companion = repo.children[1]
 			assertThat(companion.kind).isEqualTo(OutlineSymbolKind.COMPANION)
diff --git a/editor/src/main/assets/editor/treesitter/kt/outline.scm b/editor/src/main/assets/editor/treesitter/kt/outline.scm
index c5b533ce46..978065c652 100644
--- a/editor/src/main/assets/editor/treesitter/kt/outline.scm
+++ b/editor/src/main/assets/editor/treesitter/kt/outline.scm
@@ -12,7 +12,8 @@
 (object_declaration
   (type_identifier) @name) @symbol.object
 
-(companion_object) @symbol.companion
+(companion_object
+  (type_identifier)? @name) @symbol.companion
 
 (type_alias
   (type_identifier) @name) @symbol.typeAlias
@@ -20,9 +21,20 @@
 (enum_entry
   (simple_identifier) @name) @symbol.enumMember
 
-(function_declaration
-  (simple_identifier) @name
-  (function_value_parameters) @detail) @symbol.method
+(class_body
+  (function_declaration
+    (simple_identifier) @name
+    (function_value_parameters) @detail) @symbol.method)
+
+(enum_class_body
+  (function_declaration
+    (simple_identifier) @name
+    (function_value_parameters) @detail) @symbol.method)
+
+(source_file
+  (function_declaration
+    (simple_identifier) @name
+    (function_value_parameters) @detail) @symbol.method)
 
 (secondary_constructor
   (function_value_parameters) @detail) @symbol.constructor
diff --git a/editor/src/main/assets/editor/treesitter/xml/outline.scm b/editor/src/main/assets/editor/treesitter/xml/outline.scm
index 9404840341..8928feaca8 100644
--- a/editor/src/main/assets/editor/treesitter/xml/outline.scm
+++ b/editor/src/main/assets/editor/treesitter/xml/outline.scm
@@ -1,10 +1,3 @@
-(end_tag_element
-  (tag_start
-    tag_name: (name) @name)) @symbol.element
-
-(empty_element
-  tag_name: (name) @name) @symbol.element
-
 (empty_element
   tag_name: (name) @name
   (attribute
@@ -21,3 +14,10 @@
         attr_name: (name) @_a
         (attr_value) @detail)))
   (#match? @_a "^id$")) @symbol.element
+
+(empty_element
+  tag_name: (name) @name) @symbol.element
+
+(end_tag_element
+  (tag_start
+    tag_name: (name) @name)) @symbol.element
diff --git a/editor/src/main/java/com/itsaky/androidide/editor/language/outline/OutlineSymbol.kt b/editor/src/main/java/com/itsaky/androidide/editor/language/outline/OutlineSymbol.kt
index 7b504cc073..e8bc368422 100644
--- a/editor/src/main/java/com/itsaky/androidide/editor/language/outline/OutlineSymbol.kt
+++ b/editor/src/main/java/com/itsaky/androidide/editor/language/outline/OutlineSymbol.kt
@@ -19,6 +19,16 @@ enum class OutlineSymbolKind(
 	FIELD("Fd"),
 	PROPERTY("Pr"),
 	ELEMENT("El"),
+	;
+
+	companion object {
+		private val CAMEL_BOUNDARY = Regex("([a-z])([A-Z])")
+
+		fun fromCaptureSuffix(suffix: String): OutlineSymbolKind? {
+			val constantName = suffix.replace(CAMEL_BOUNDARY, "$1_$2").uppercase()
+			return entries.find { it.name == constantName }
+		}
+	}
 }
 
 data class OutlineSymbol(
diff --git a/editor/src/main/java/com/itsaky/androidide/editor/language/outline/OutlineTreeBuilder.kt b/editor/src/main/java/com/itsaky/androidide/editor/language/outline/OutlineTreeBuilder.kt
index 1bc0e96237..c6eef11985 100644
--- a/editor/src/main/java/com/itsaky/androidide/editor/language/outline/OutlineTreeBuilder.kt
+++ b/editor/src/main/java/com/itsaky/androidide/editor/language/outline/OutlineTreeBuilder.kt
@@ -19,10 +19,7 @@ internal object OutlineTreeBuilder {
 		val roots = mutableListOf<MutableNode>()
 		val stack = ArrayDeque<MutableNode>()
 		for (symbol in sorted) {
-			while (stack.isNotEmpty() && stack
-					.last()
-					.raw.range.end.index <= symbol.range.start.index
-			) {
+			while (stack.isNotEmpty() && !stack.last().raw.strictlyContains(symbol)) {
 				stack.removeLast()
 			}
 			val node = MutableNode(symbol)
@@ -36,6 +33,16 @@ internal object OutlineTreeBuilder {
 		return roots.map { it.freeze() }
 	}
 
+	private fun RawOutlineSymbol.strictlyContains(other: RawOutlineSymbol): Boolean {
+		val encloses =
+			range.start.index <= other.range.start.index &&
+				other.range.end.index <= range.end.index
+		val sameRange =
+			range.start.index == other.range.start.index &&
+				range.end.index == other.range.end.index
+		return encloses && !sameRange
+	}
+
 	private class MutableNode(
 		val raw: RawOutlineSymbol,
 	) {
diff --git a/editor/src/main/java/com/itsaky/androidide/editor/language/outline/TreeSitterOutlineProvider.kt b/editor/src/main/java/com/itsaky/androidide/editor/language/outline/TreeSitterOutlineProvider.kt
index 3f1a5341c7..8e1c08ddf8 100644
--- a/editor/src/main/java/com/itsaky/androidide/editor/language/outline/TreeSitterOutlineProvider.kt
+++ b/editor/src/main/java/com/itsaky/androidide/editor/language/outline/TreeSitterOutlineProvider.kt
@@ -22,8 +22,11 @@ import com.itsaky.androidide.treesitter.kotlin.TSLanguageKotlin
 import com.itsaky.androidide.treesitter.xml.TSLanguageXml
 import io.github.rosemoe.sora.editor.ts.predicate.Predicator
 import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.currentCoroutineContext
+import kotlinx.coroutines.ensureActive
 import kotlinx.coroutines.withContext
 import java.util.concurrent.ConcurrentHashMap
+import kotlin.coroutines.CoroutineContext
 
 class TreeSitterOutlineProvider(
 	context: Context,
@@ -79,10 +82,11 @@ class TreeSitterOutlineProvider(
 					?: throw IllegalArgumentException("No outline support for file extension '$fileExtension'")
 			val queries = queriesByType.computeIfAbsent(type) { loadQueries(it) }
 			val source = text.toString()
+			val cancellation = currentCoroutineContext()
 			TSParser.create().use { parser ->
 				parser.language = queries.language
 				parser.parseString(source).use { tree ->
-					extract(queries, tree, source)
+					extract(queries, tree, source, cancellation)
 				}
 			}
 		}
@@ -115,6 +119,7 @@ class TreeSitterOutlineProvider(
 		queries: LanguageQueries,
 		tree: TSTree,
 		source: String,
+		cancellation: CoroutineContext,
 	): List<OutlineSymbol> {
 		val rawByName = LinkedHashMap<Pair<Int, Int>, RawOutlineSymbol>()
 		val patternByName = HashMap<Pair<Int, Int>, Int>()
@@ -125,6 +130,7 @@ class TreeSitterOutlineProvider(
 				recycleNodeAfterUse = true,
 				debugName = "TreeSitterOutlineProvider.extract()",
 			) { match ->
+				cancellation.ensureActive()
 				if (!queries.predicator.doPredicate(predicates, source, match)) {
 					return@safeExecQueryCursor
 				}
@@ -175,9 +181,8 @@ class TreeSitterOutlineProvider(
 				val preferred =
 					when {
 						existing == null -> true
-						existing.detail == null && raw.detail != null -> true
-						existing.detail != null && raw.detail == null -> false
-						else -> match.patternIndex < existingPattern!!
+						match.patternIndex != existingPattern -> match.patternIndex < existingPattern!!
+						else -> existing.detail == null && raw.detail != null
 					}
 				if (preferred) {
 					rawByName[key] = raw
@@ -188,11 +193,9 @@ class TreeSitterOutlineProvider(
 		return OutlineTreeBuilder.build(rawByName.values.toList())
 	}
 
-	private fun kindOf(suffix: String): OutlineSymbolKind {
-		val constantName = suffix.replace(Regex("([a-z])([A-Z])"), "$1_$2").uppercase()
-		return OutlineSymbolKind.entries.find { it.name == constantName }
+	private fun kindOf(suffix: String): OutlineSymbolKind =
+		OutlineSymbolKind.fromCaptureSuffix(suffix)
 			?: throw IllegalArgumentException("Unknown outline symbol kind capture '@symbol.$suffix'")
-	}
 
 	private fun defaultNameFor(kind: OutlineSymbolKind): String? =
 		when (kind) {
diff --git a/editor/src/test/java/com/itsaky/androidide/editor/language/outline/OutlineQueryCapturesTest.kt b/editor/src/test/java/com/itsaky/androidide/editor/language/outline/OutlineQueryCapturesTest.kt
new file mode 100644
index 0000000000..ded8a4fcc1
--- /dev/null
+++ b/editor/src/test/java/com/itsaky/androidide/editor/language/outline/OutlineQueryCapturesTest.kt
@@ -0,0 +1,48 @@
+package com.itsaky.androidide.editor.language.outline
+
+import com.google.common.truth.Truth.assertThat
+import com.itsaky.androidide.utils.FileProvider
+import org.junit.Test
+
+class OutlineQueryCapturesTest {
+	private val symbolCapture = Regex("@symbol\\.(\\w+)")
+
+	private val queryDir =
+		FileProvider
+			.projectRoot()
+			.resolve("editor/src/main/assets/editor/treesitter")
+
+	@Test
+	fun `every shipped language has an outline query`() {
+		val found = listOf("java", "kt", "xml").filter { queryDir.resolve("$it/outline.scm").toFile().isFile }
+
+		assertThat(found).containsExactly("java", "kt", "xml")
+	}
+
+	@Test
+	fun `every symbol capture in every query maps to an OutlineSymbolKind`() {
+		val unknown = mutableListOf<String>()
+		var captures = 0
+		for (language in listOf("java", "kt", "xml")) {
+			val text = queryDir.resolve("$language/outline.scm").toFile().readText()
+			for (match in symbolCapture.findAll(text)) {
+				val suffix = match.groupValues[1]
+				captures++
+				if (OutlineSymbolKind.fromCaptureSuffix(suffix) == null) {
+					unknown += "$language/outline.scm: @symbol.$suffix"
+				}
+			}
+		}
+
+		assertThat(unknown).isEmpty()
+		assertThat(captures).isAtLeast(20)
+	}
+
+	@Test
+	fun `capture suffixes are matched case-insensitively across the camel boundary`() {
+		assertThat(OutlineSymbolKind.fromCaptureSuffix("enumMember")).isEqualTo(OutlineSymbolKind.ENUM_MEMBER)
+		assertThat(OutlineSymbolKind.fromCaptureSuffix("typeAlias")).isEqualTo(OutlineSymbolKind.TYPE_ALIAS)
+		assertThat(OutlineSymbolKind.fromCaptureSuffix("class")).isEqualTo(OutlineSymbolKind.CLASS)
+		assertThat(OutlineSymbolKind.fromCaptureSuffix("nonsense")).isNull()
+	}
+}

From 44bbe8da2eccd77ecb7f2cc4462f343687e55018 Mon Sep 17 00:00:00 2001
From: Daniel Alome <astrocoder007@gmail.com>
Date: Wed, 9 Sep 2026 22:37:10 +0100
Subject: [PATCH 19/20] ADFA-2448: Keep the signature beside the name when it
 fits

The Column introduced for the round-3 review put every signature on its own
line, so `onDestroy` showed `()` underneath it with most of the row empty.
FlowRow keeps name and detail on one line while there is room and wraps the
detail only when there is not, which still prevents a long name from
squeezing the signature to zero width.
---
 .../com/itsaky/androidide/ui/outline/OutlinePanel.kt | 12 +++++++++++-
 1 file changed, 11 insertions(+), 1 deletion(-)

diff --git a/app/src/main/java/com/itsaky/androidide/ui/outline/OutlinePanel.kt b/app/src/main/java/com/itsaky/androidide/ui/outline/OutlinePanel.kt
index 26438c68f9..2ac0501fac 100644
--- a/app/src/main/java/com/itsaky/androidide/ui/outline/OutlinePanel.kt
+++ b/app/src/main/java/com/itsaky/androidide/ui/outline/OutlinePanel.kt
@@ -2,8 +2,11 @@ package com.itsaky.androidide.ui.outline
 
 import androidx.compose.foundation.clickable
 import androidx.compose.foundation.isSystemInDarkTheme
+import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.ExperimentalLayoutApi
+import androidx.compose.foundation.layout.FlowRow
 import androidx.compose.foundation.layout.Row
 import androidx.compose.foundation.layout.Spacer
 import androidx.compose.foundation.layout.fillMaxSize
@@ -147,6 +150,7 @@ private fun OutlineTree(
 	}
 }
 
+@OptIn(ExperimentalLayoutApi::class)
 @Composable
 private fun OutlineRow(
 	row: OutlineRowModel,
@@ -210,7 +214,13 @@ private fun OutlineRow(
 			color = badgeColorFor(symbol.kind),
 			modifier = Modifier.padding(start = 2.dp, end = 8.dp),
 		)
-		Column(modifier = Modifier.weight(1f).padding(vertical = 4.dp)) {
+		FlowRow(
+			horizontalArrangement = Arrangement.spacedBy(6.dp),
+			modifier =
+				Modifier
+					.weight(1f)
+					.padding(vertical = 4.dp),
+		) {
 			Text(
 				text = symbol.name,
 				style = MaterialTheme.typography.bodyMedium,

From 0ce2bd3c8d2f3f731c3c70d904108b67209d6c34 Mon Sep 17 00:00:00 2001
From: Daniel Alome <astrocoder007@gmail.com>
Date: Thu, 10 Sep 2026 13:51:49 +0100
Subject: [PATCH 20/20] ADFA-2448: Hold the deferred scroll as state and
 translate the row description

Round-4 review follow-ups from itsaky-adfa.

Blocking: navigateTo registered a second, anonymous DrawerLayout listener that
removed itself only from its own onDrawerClosed. Swiping the drawer back open
inside the close animation left it registered, holding an IDEEditor and a
Position past the fragment's life, so the next close for any reason scrolled
to an abandoned symbol. The deferred scroll is now state on the one long-lived
listener: onDrawerClosed consumes it, onDrawerOpened discards it, and
onDestroyView clears it alongside the listener it already removed.

Also:

- OutlineViewModel tracks the last computed path in its own field instead of
  reading it off collapsed.path, which both early returns leave untouched. A
  detour through an unsupported file no longer leaves that file's message on
  screen while the previous file recomputes, and collapse still survives the
  detour.
- EditorViewModel.currentFile gets @get:JvmName("currentFileLiveData"); its
  default JVM getter collided by name with the existing getCurrentFile(): File?
  and no Java caller could have resolved either.
- The row content description builds its kind word from :resources strings
  (cd_outline_kind_*, 14 entries) instead of the enum constant name, so
  TalkBack no longer announces English in a translated UI. The mapping is a
  when in the panel, next to badgeColorFor, rather than resource ids on the
  model enum.
- xml/outline.scm matches "^(id|name)$", so res/values files show the element
  name as the detail. Before this, strings.xml and colors.xml listed N rows
  reading only "string" or "color".
- loadQueries closes the TSQuery before throwing on a query that fails to
  compile.
- The editor test APK glob is asserted to resolve to exactly one existing file,
  so a missing APK fails with that message rather than a gcloud usage error.
- OutlineTreeBuilderTest gains the partial-overlap and identical-range cases.
  Both fail against the pre-fix disjointness-only pop condition, and the other
  seven cases pass either way, which is what the reviewer measured.
---
 .github/workflows/instrumentation-test.yml    |  7 ++++-
 .../fragments/sidebar/OutlineFragment.kt      | 26 +++++++++++--------
 .../androidide/ui/outline/OutlinePanel.kt     | 25 +++++++++++++++---
 .../androidide/viewmodel/EditorViewModel.kt   |  2 ++
 .../androidide/viewmodel/OutlineViewModel.kt  | 10 ++++---
 .../assets/editor/treesitter/xml/outline.scm  |  4 +--
 .../outline/TreeSitterOutlineProvider.kt      |  6 ++---
 .../outline/OutlineTreeBuilderTest.kt         | 16 ++++++++++++
 resources/src/main/res/values/strings.xml     | 14 ++++++++++
 9 files changed, 85 insertions(+), 25 deletions(-)

diff --git a/.github/workflows/instrumentation-test.yml b/.github/workflows/instrumentation-test.yml
index ee53cff3d2..ac07df9f54 100644
--- a/.github/workflows/instrumentation-test.yml
+++ b/.github/workflows/instrumentation-test.yml
@@ -145,7 +145,12 @@ jobs:
 
           # Run editor module instrumentation tests (self-instrumenting library test APK)
           echo "Running editor tests..."
-          EDITOR_TEST_APK=$(ls editor/build/outputs/apk/androidTest/v8/debug/*-androidTest.apk | head -1)
+          EDITOR_TEST_APK=(editor/build/outputs/apk/androidTest/v8/debug/*-androidTest.apk)
+          if [ ${#EDITOR_TEST_APK[@]} -ne 1 ] || [ ! -f "${EDITOR_TEST_APK[0]}" ]; then
+            echo "Expected exactly one editor androidTest APK, found: ${EDITOR_TEST_APK[*]}"
+            exit 1
+          fi
+          EDITOR_TEST_APK="${EDITOR_TEST_APK[0]}"
           gcloud firebase test android run \
             --type instrumentation \
             --app "$EDITOR_TEST_APK" \
diff --git a/app/src/main/java/com/itsaky/androidide/fragments/sidebar/OutlineFragment.kt b/app/src/main/java/com/itsaky/androidide/fragments/sidebar/OutlineFragment.kt
index 9488421870..8d5094cb4a 100644
--- a/app/src/main/java/com/itsaky/androidide/fragments/sidebar/OutlineFragment.kt
+++ b/app/src/main/java/com/itsaky/androidide/fragments/sidebar/OutlineFragment.kt
@@ -15,6 +15,7 @@ import androidx.lifecycle.lifecycleScope
 import androidx.lifecycle.repeatOnLifecycle
 import com.itsaky.androidide.activities.editor.EditorHandlerActivity
 import com.itsaky.androidide.common.compose.IdeTheme
+import com.itsaky.androidide.editor.ui.IDEEditor
 import com.itsaky.androidide.eventbus.events.editor.DocumentChangeEvent
 import com.itsaky.androidide.eventbus.events.editor.DocumentOpenEvent
 import com.itsaky.androidide.models.Position
@@ -34,11 +35,22 @@ class OutlineFragment : Fragment() {
 	private val editorViewModel: EditorViewModel by activityViewModels()
 	private var drawer: DrawerLayout? = null
 
+	private var pendingScroll: Pair<IDEEditor, Position>? = null
+
 	private val drawerListener =
 		object : DrawerLayout.SimpleDrawerListener() {
 			override fun onDrawerOpened(drawerView: View) {
+				pendingScroll = null
 				seedFromCurrentEditor()
 			}
+
+			override fun onDrawerClosed(drawerView: View) {
+				val (editor, position) = pendingScroll ?: return
+				pendingScroll = null
+				if (editor.isValidPosition(position, true)) {
+					centerPositionInView(editor, position)
+				}
+			}
 		}
 
 	override fun onCreateView(
@@ -79,6 +91,7 @@ class OutlineFragment : Fragment() {
 	override fun onDestroyView() {
 		drawer?.removeDrawerListener(drawerListener)
 		drawer = null
+		pendingScroll = null
 		viewModel.onNoEditor()
 		super.onDestroyView()
 	}
@@ -156,21 +169,12 @@ class OutlineFragment : Fragment() {
 			centerPositionInView(editor, position)
 			return
 		}
-		drawer.addDrawerListener(
-			object : DrawerLayout.SimpleDrawerListener() {
-				override fun onDrawerClosed(drawerView: View) {
-					drawer.removeDrawerListener(this)
-					if (editor.isValidPosition(position, true)) {
-						centerPositionInView(editor, position)
-					}
-				}
-			},
-		)
+		pendingScroll = editor to position
 		drawer.closeDrawer(GravityCompat.START)
 	}
 
 	private fun centerPositionInView(
-		editor: com.itsaky.androidide.editor.ui.IDEEditor,
+		editor: IDEEditor,
 		position: Position,
 	) {
 		val rowY = editor.layout.getCharLayoutOffset(position.line, position.column)[0]
diff --git a/app/src/main/java/com/itsaky/androidide/ui/outline/OutlinePanel.kt b/app/src/main/java/com/itsaky/androidide/ui/outline/OutlinePanel.kt
index 2ac0501fac..d9d3bc3c08 100644
--- a/app/src/main/java/com/itsaky/androidide/ui/outline/OutlinePanel.kt
+++ b/app/src/main/java/com/itsaky/androidide/ui/outline/OutlinePanel.kt
@@ -1,5 +1,6 @@
 package com.itsaky.androidide.ui.outline
 
+import androidx.annotation.StringRes
 import androidx.compose.foundation.clickable
 import androidx.compose.foundation.isSystemInDarkTheme
 import androidx.compose.foundation.layout.Arrangement
@@ -55,6 +56,25 @@ private val CALLABLE_BADGE_DARK = Color(0xFF7FD8DF)
 private val DATA_BADGE_LIGHT = Color(0xFFA05A00)
 private val DATA_BADGE_DARK = Color(0xFFF0B45C)
 
+@StringRes
+private fun kindLabelRes(kind: OutlineSymbolKind): Int =
+	when (kind) {
+		OutlineSymbolKind.CLASS -> R.string.cd_outline_kind_class
+		OutlineSymbolKind.INTERFACE -> R.string.cd_outline_kind_interface
+		OutlineSymbolKind.ENUM -> R.string.cd_outline_kind_enum
+		OutlineSymbolKind.ENUM_MEMBER -> R.string.cd_outline_kind_enum_member
+		OutlineSymbolKind.RECORD -> R.string.cd_outline_kind_record
+		OutlineSymbolKind.ANNOTATION -> R.string.cd_outline_kind_annotation
+		OutlineSymbolKind.OBJECT -> R.string.cd_outline_kind_object
+		OutlineSymbolKind.COMPANION -> R.string.cd_outline_kind_companion
+		OutlineSymbolKind.TYPE_ALIAS -> R.string.cd_outline_kind_type_alias
+		OutlineSymbolKind.CONSTRUCTOR -> R.string.cd_outline_kind_constructor
+		OutlineSymbolKind.METHOD -> R.string.cd_outline_kind_method
+		OutlineSymbolKind.FIELD -> R.string.cd_outline_kind_field
+		OutlineSymbolKind.PROPERTY -> R.string.cd_outline_kind_property
+		OutlineSymbolKind.ELEMENT -> R.string.cd_outline_kind_element
+	}
+
 @Composable
 private fun badgeColorFor(kind: OutlineSymbolKind): Color {
 	val dark = isSystemInDarkTheme()
@@ -158,10 +178,7 @@ private fun OutlineRow(
 	modifier: Modifier = Modifier,
 ) {
 	val symbol = row.symbol
-	val kindLabel =
-		symbol.kind.name
-			.lowercase()
-			.replace('_', ' ')
+	val kindLabel = stringResource(kindLabelRes(symbol.kind))
 	val rowDescription = listOfNotNull(kindLabel, symbol.name, symbol.detail).joinToString(", ")
 	val cappedDepth = minOf(row.depth, MAX_INDENT_DEPTH)
 	val indent = INDENT_STEP * cappedDepth
diff --git a/app/src/main/java/com/itsaky/androidide/viewmodel/EditorViewModel.kt b/app/src/main/java/com/itsaky/androidide/viewmodel/EditorViewModel.kt
index d7ce797641..c4c2f0cd98 100644
--- a/app/src/main/java/com/itsaky/androidide/viewmodel/EditorViewModel.kt
+++ b/app/src/main/java/com/itsaky/androidide/viewmodel/EditorViewModel.kt
@@ -109,6 +109,8 @@ class EditorViewModel : ViewModel() {
 	 * index of the editor opened. Second value is the file that is opened.
 	 */
 	private val mCurrentFile = MutableLiveData<Pair<Int, File?>?>(null)
+
+	@get:JvmName("currentFileLiveData")
 	val currentFile: LiveData<Pair<Int, File?>?> get() = mCurrentFile
 
 	var areFilesModified: Boolean
diff --git a/app/src/main/java/com/itsaky/androidide/viewmodel/OutlineViewModel.kt b/app/src/main/java/com/itsaky/androidide/viewmodel/OutlineViewModel.kt
index 31d19096d4..f26977b296 100644
--- a/app/src/main/java/com/itsaky/androidide/viewmodel/OutlineViewModel.kt
+++ b/app/src/main/java/com/itsaky/androidide/viewmodel/OutlineViewModel.kt
@@ -18,7 +18,6 @@ import kotlinx.coroutines.flow.asSharedFlow
 import kotlinx.coroutines.flow.asStateFlow
 import kotlinx.coroutines.flow.collectLatest
 import kotlinx.coroutines.flow.debounce
-import kotlinx.coroutines.flow.getAndUpdate
 import kotlinx.coroutines.flow.map
 import kotlinx.coroutines.flow.stateIn
 import kotlinx.coroutines.flow.update
@@ -46,6 +45,7 @@ class OutlineViewModel(
 	private val snapshots = MutableStateFlow<Snapshot?>(null)
 	private val _uiState = MutableStateFlow<OutlineUiState>(OutlineUiState.NoFileOpen)
 	private val collapsed = MutableStateFlow(Collapsed(path = null, paths = emptySet()))
+	private var lastComputedPath: String? = null
 
 	val uiState: StateFlow<OutlineUiState> = _uiState.asStateFlow()
 	val collapsedPaths: StateFlow<Set<String>> =
@@ -106,16 +106,17 @@ class OutlineViewModel(
 
 	private suspend fun compute(snapshot: Snapshot?) {
 		if (snapshot == null) {
+			lastComputedPath = null
 			_uiState.value = OutlineUiState.NoFileOpen
 			return
 		}
 		if (!outlineProvider.supports(snapshot.extension)) {
+			lastComputedPath = snapshot.path
 			_uiState.value = OutlineUiState.Unsupported(snapshot.fileName)
 			return
 		}
-		val switchedFile =
-			collapsed.getAndUpdate { if (it.path == snapshot.path) it else Collapsed(snapshot.path, emptySet()) }.path != snapshot.path
-		if (switchedFile) {
+		collapsed.update { if (it.path == snapshot.path) it else Collapsed(snapshot.path, emptySet()) }
+		if (lastComputedPath != snapshot.path) {
 			_uiState.value = OutlineUiState.Loading(snapshot.fileName)
 		}
 		val symbols =
@@ -127,6 +128,7 @@ class OutlineViewModel(
 				log.error("Failed to compute outline for {}", snapshot.fileName, e)
 				emptyList()
 			}
+		lastComputedPath = snapshot.path
 		_uiState.value =
 			if (symbols.isEmpty()) {
 				OutlineUiState.Empty(snapshot.fileName)
diff --git a/editor/src/main/assets/editor/treesitter/xml/outline.scm b/editor/src/main/assets/editor/treesitter/xml/outline.scm
index 8928feaca8..d1f006c790 100644
--- a/editor/src/main/assets/editor/treesitter/xml/outline.scm
+++ b/editor/src/main/assets/editor/treesitter/xml/outline.scm
@@ -4,7 +4,7 @@
     (xml_attr
       attr_name: (name) @_a
       (attr_value) @detail))
-  (#match? @_a "^id$")) @symbol.element
+  (#match? @_a "^(id|name)$")) @symbol.element
 
 (end_tag_element
   (tag_start
@@ -13,7 +13,7 @@
       (xml_attr
         attr_name: (name) @_a
         (attr_value) @detail)))
-  (#match? @_a "^id$")) @symbol.element
+  (#match? @_a "^(id|name)$")) @symbol.element
 
 (empty_element
   tag_name: (name) @name) @symbol.element
diff --git a/editor/src/main/java/com/itsaky/androidide/editor/language/outline/TreeSitterOutlineProvider.kt b/editor/src/main/java/com/itsaky/androidide/editor/language/outline/TreeSitterOutlineProvider.kt
index 8e1c08ddf8..8fe7c91baa 100644
--- a/editor/src/main/java/com/itsaky/androidide/editor/language/outline/TreeSitterOutlineProvider.kt
+++ b/editor/src/main/java/com/itsaky/androidide/editor/language/outline/TreeSitterOutlineProvider.kt
@@ -100,9 +100,9 @@ class TreeSitterOutlineProvider(
 		val language = languageFor(type)
 		val query = TSQuery.create(language, scm)
 		if (query.errorType != TSQueryError.None) {
-			throw IllegalArgumentException(
-				"outline.scm for '$type' failed to parse: ${query.errorType.name} at byte offset ${query.errorOffset}",
-			)
+			val error = "outline.scm for '$type' failed to parse: ${query.errorType.name} at byte offset ${query.errorOffset}"
+			query.close()
+			throw IllegalArgumentException(error)
 		}
 		return LanguageQueries(language, query, Predicator(query))
 	}
diff --git a/editor/src/test/java/com/itsaky/androidide/editor/language/outline/OutlineTreeBuilderTest.kt b/editor/src/test/java/com/itsaky/androidide/editor/language/outline/OutlineTreeBuilderTest.kt
index 2ead91780a..93953f932a 100644
--- a/editor/src/test/java/com/itsaky/androidide/editor/language/outline/OutlineTreeBuilderTest.kt
+++ b/editor/src/test/java/com/itsaky/androidide/editor/language/outline/OutlineTreeBuilderTest.kt
@@ -74,6 +74,22 @@ class OutlineTreeBuilderTest {
 		assertThat(result[0].children.map { it.name }).containsExactly("short")
 	}
 
+	@Test
+	fun `a partially overlapping symbol becomes a sibling, not a child`() {
+		val tree = OutlineTreeBuilder.build(listOf(raw("a", 0, 50), raw("b", 40, 100)))
+
+		assertThat(tree.map { it.name }).containsExactly("a", "b").inOrder()
+		assertThat(tree[0].children).isEmpty()
+	}
+
+	@Test
+	fun `two symbols with an identical range become siblings`() {
+		val tree = OutlineTreeBuilder.build(listOf(raw("a", 0, 50), raw("b", 0, 50)))
+
+		assertThat(tree.map { it.name }).containsExactly("a", "b").inOrder()
+		assertThat(tree[0].children).isEmpty()
+	}
+
 	@Test
 	fun `deep nesting chains through the stack`() {
 		val result =
diff --git a/resources/src/main/res/values/strings.xml b/resources/src/main/res/values/strings.xml
index 0d24d7f6d5..65957d84ea 100644
--- a/resources/src/main/res/values/strings.xml
+++ b/resources/src/main/res/values/strings.xml
@@ -1680,4 +1680,18 @@
   <string name="outline_loading">Building outline...</string>
   <string name="cd_outline_expand">Expand</string>
   <string name="cd_outline_collapse">Collapse</string>
+  <string name="cd_outline_kind_class">Class</string>
+  <string name="cd_outline_kind_interface">Interface</string>
+  <string name="cd_outline_kind_enum">Enum</string>
+  <string name="cd_outline_kind_enum_member">Enum member</string>
+  <string name="cd_outline_kind_record">Record</string>
+  <string name="cd_outline_kind_annotation">Annotation</string>
+  <string name="cd_outline_kind_object">Object</string>
+  <string name="cd_outline_kind_companion">Companion object</string>
+  <string name="cd_outline_kind_type_alias">Type alias</string>
+  <string name="cd_outline_kind_constructor">Constructor</string>
+  <string name="cd_outline_kind_method">Method</string>
+  <string name="cd_outline_kind_field">Field</string>
+  <string name="cd_outline_kind_property">Property</string>
+  <string name="cd_outline_kind_element">Element</string>
 </resources>