From 0cdfaa1e423ee491cd3303d03eddda18a98bf89f Mon Sep 17 00:00:00 2001
From: Sebastiano Poggi <rock3r@users.noreply.github.com>
Date: Fri, 15 Sep 2023 16:33:02 +0200
Subject: [PATCH] Fix icon loading in IDE (#112)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* Fix icon loading in IDE

* Fix icon loading in standalone modules

* Fix static analysis

* SwingBridgeService will now wait 20 milliseconds before reading the theme and then will retry due to Swing possible race conditions.

* Fixed SLC focus system, added right color for unfocused selected items in the LazyTree.

* Partially fix icon mapping

Something still isn't working well — icon states may need to be applied
_after_ mapping, need to check as it breaks in those cases.

Checkboxes and radio buttons also use the old UI icons, not sure why
they don't get mapped.

* Add fallback path for icon loading

* Update project settings

* Also load iconColorsOnSelection from theme

* Fix crash in standalone sample

* Clean up painter provider usage

* Re-do icon tinting logic, better match Swing

* Fix tree crashing in sample (see #114)

Also reformat/cleanup after rebase on main

---------

Co-authored-by: Lamberto Basti <basti.lamberto@gmail.com>
---
 .idea/detekt.xml                              |   2 +
 .idea/externalDependencies.xml                |   1 +
 buildSrc/src/main/kotlin/jewel.gradle.kts     |   1 +
 .../theme/IntUiThemeDescriptorReader.kt       |  21 +-
 .../theme/IntelliJThemeGeneratorPlugin.kt     |  55 ++---
 .../jetbrains/jewel/ClassLoaderProvider.kt    |   6 +
 .../org/jetbrains/jewel/IntelliJSvgLoader.kt  | 119 -----------
 .../jewel/IntelliJThemeColorPalette.kt        |   6 +-
 .../jetbrains/jewel/IntelliJThemeIconData.kt  |  30 ++-
 .../jetbrains/jewel/JewelResourceLoader.kt    |  76 ++++++-
 .../org/jetbrains/jewel/JewelSvgLoader.kt     |  54 +++++
 .../kotlin/org/jetbrains/jewel/LazyTree.kt    |   4 +-
 .../org/jetbrains/jewel/PaletteMapper.kt      |  50 +++--
 .../jetbrains/jewel/SimpleResourceLoader.kt   |  20 ++
 .../kotlin/org/jetbrains/jewel/SvgLoader.kt   |   2 +-
 .../kotlin/org/jetbrains/jewel/SvgPatcher.kt  |   2 +-
 .../kotlin/org/jetbrains/jewel/TextArea.kt    |   2 +-
 .../jewel/foundation/lazy/Keybindings.kt      |   2 -
 .../foundation/lazy/SelectableLazyColumn.kt   |  58 ++---
 .../lazy/SelectableLazyListScope.kt           |  54 +++--
 .../jewel/foundation/tree/BasicLazyTree.kt    |   2 +-
 .../jewel/styling/LazyTreeStyling.kt          |  15 +-
 .../jewel/styling/PainterProvider.kt          |  23 ++
 .../jewel/styling/ResourcePainterProvider.kt  |   3 +-
 .../jewel/themes/PaletteMapperFactory.kt      | 142 +++++--------
 .../themes/StandalonePaletteMapperFactory.kt  |  82 +++++++
 .../jetbrains/jewel/bridge/BridgeIconData.kt  |  17 +-
 .../jewel/bridge/BridgeIconMapper.kt          |  60 ++++++
 .../bridge/BridgePaletteMapperFactory.kt      |  27 +++
 .../jewel/bridge/BridgeResourceLoader.kt      |  25 +++
 ...er.kt => BridgeResourcePainterProvider.kt} |  29 ++-
 .../jewel/bridge/BridgeThemeColorPalette.kt   |  72 +++++--
 .../org/jetbrains/jewel/bridge/BridgeUtils.kt |  18 +-
 .../jetbrains/jewel/bridge/ComposePanel.kt    |   1 -
 .../org/jetbrains/jewel/bridge/IconMapper.kt  |   3 +-
 .../org/jetbrains/jewel/bridge/IntUiBridge.kt |  64 +++---
 .../jewel/bridge/IntelliJIconMapper.kt        |  44 ----
 .../jewel/bridge/SwingBridgeService.kt        |  24 ++-
 .../jewel/bridge/SwingBridgeTheme.kt          |  15 +-
 .../jewel/bridge/UiThemeExtensions.kt         |  42 ++++
 .../samples/ideplugin/JewelDemoToolWindow.kt  | 200 ++++++++++++++----
 .../jewel/samples/standalone/Main.kt          |   4 +-
 .../standalone/components/ChipsAndTree.kt     | 159 +++++++-------
 .../intui/core/IntUiThemeColorPalette.kt      |   2 +-
 .../themes/intui/core/IntelliJSvgPatcher.kt   |  21 +-
 .../standalone/IntUiDefaultResourceLoader.kt  |  20 --
 .../themes/intui/standalone/IntUiTheme.kt     |  15 +-
 .../styling/IntUiLazyTreeStyling.kt           |  33 +--
 48 files changed, 1123 insertions(+), 604 deletions(-)
 create mode 100644 core/src/main/kotlin/org/jetbrains/jewel/ClassLoaderProvider.kt
 delete mode 100644 core/src/main/kotlin/org/jetbrains/jewel/IntelliJSvgLoader.kt
 create mode 100644 core/src/main/kotlin/org/jetbrains/jewel/JewelSvgLoader.kt
 create mode 100644 core/src/main/kotlin/org/jetbrains/jewel/SimpleResourceLoader.kt
 create mode 100644 core/src/main/kotlin/org/jetbrains/jewel/themes/StandalonePaletteMapperFactory.kt
 create mode 100644 ide-laf-bridge/src/main/kotlin/org/jetbrains/jewel/bridge/BridgeIconMapper.kt
 create mode 100644 ide-laf-bridge/src/main/kotlin/org/jetbrains/jewel/bridge/BridgePaletteMapperFactory.kt
 create mode 100644 ide-laf-bridge/src/main/kotlin/org/jetbrains/jewel/bridge/BridgeResourceLoader.kt
 rename ide-laf-bridge/src/main/kotlin/org/jetbrains/jewel/bridge/{IntelliJResourcePainterProvider.kt => BridgeResourcePainterProvider.kt} (57%)
 delete mode 100644 ide-laf-bridge/src/main/kotlin/org/jetbrains/jewel/bridge/IntelliJIconMapper.kt
 create mode 100644 ide-laf-bridge/src/main/kotlin/org/jetbrains/jewel/bridge/UiThemeExtensions.kt
 delete mode 100644 themes/int-ui/int-ui-standalone/src/main/kotlin/org/jetbrains/jewel/themes/intui/standalone/IntUiDefaultResourceLoader.kt

diff --git a/.idea/detekt.xml b/.idea/detekt.xml
index a921d6684..efda1cfc1 100644
--- a/.idea/detekt.xml
+++ b/.idea/detekt.xml
@@ -11,5 +11,7 @@
         <option value="$PROJECT_DIR$/detekt.yml" />
       </list>
     </option>
+    <option name="enableDetekt" value="true" />
+    <option name="enableForProjectResult" value="Accepted" />
   </component>
 </project>
\ No newline at end of file
diff --git a/.idea/externalDependencies.xml b/.idea/externalDependencies.xml
index 5d8159909..ab326d5c9 100644
--- a/.idea/externalDependencies.xml
+++ b/.idea/externalDependencies.xml
@@ -3,5 +3,6 @@
   <component name="ExternalDependencies">
     <plugin id="com.nbadal.ktlint" />
     <plugin id="detekt" />
+    <plugin id="org.jetbrains.compose.desktop.ide" />
   </component>
 </project>
\ No newline at end of file
diff --git a/buildSrc/src/main/kotlin/jewel.gradle.kts b/buildSrc/src/main/kotlin/jewel.gradle.kts
index 6f02f49e5..e6fc51148 100644
--- a/buildSrc/src/main/kotlin/jewel.gradle.kts
+++ b/buildSrc/src/main/kotlin/jewel.gradle.kts
@@ -1,6 +1,7 @@
 @file:Suppress("UnstableApiUsage")
 
 import io.gitlab.arturbosch.detekt.Detekt
+import org.gradle.api.attributes.Usage
 import org.jmailen.gradle.kotlinter.tasks.LintTask
 
 plugins {
diff --git a/buildSrc/src/main/kotlin/org/jetbrains/jewel/buildlogic/theme/IntUiThemeDescriptorReader.kt b/buildSrc/src/main/kotlin/org/jetbrains/jewel/buildlogic/theme/IntUiThemeDescriptorReader.kt
index 715236bf7..8ace1fd57 100644
--- a/buildSrc/src/main/kotlin/org/jetbrains/jewel/buildlogic/theme/IntUiThemeDescriptorReader.kt
+++ b/buildSrc/src/main/kotlin/org/jetbrains/jewel/buildlogic/theme/IntUiThemeDescriptorReader.kt
@@ -30,8 +30,7 @@ internal object IntUiThemeDescriptorReader {
     ) =
         FileSpec.builder(className).apply {
             indent("    ")
-            this.
-            addFileComment("Generated by the Jewel Int UI Palette Generator\n")
+            this.addFileComment("Generated by the Jewel Int UI Palette Generator\n")
             addFileComment("Generated from the IntelliJ Platform version $ideaVersion\n")
             addFileComment("Source: $descriptorUrl")
 
@@ -78,6 +77,23 @@ internal object IntUiThemeDescriptorReader {
             }.forEach { (group, colors) ->
                 readColorGroup(className, group, colors)
             }
+
+            val rawMapProperty = PropertySpec
+                .builder(
+                    "rawMap",
+                    Map::class.asClassName().parameterizedBy(String::class.asClassName(), colorClassName),
+                    KModifier.OVERRIDE
+                )
+                .initializer(
+                    colors
+                        .map { (key, value) ->
+                            val colorHexString = value.replace("#", "0xFF")
+                            CodeBlock.of("%S to Color(%L)", key, colorHexString)
+                        }
+                        .joinToCode(prefix = "mapOf(", separator = ",\n", suffix = ")")
+                )
+                .build()
+            addProperty(rawMapProperty)
         }.build())
 
         addProperty(
@@ -159,6 +175,7 @@ internal object IntUiThemeDescriptorReader {
             }
 
             addProperty(createOverrideStringMapProperty("iconOverrides", iconOverrides))
+            addProperty(createOverrideStringMapProperty("selectionColorPalette", theme.iconColorsOnSelection))
         }.build())
 
         addProperty(
diff --git a/buildSrc/src/main/kotlin/org/jetbrains/jewel/buildlogic/theme/IntelliJThemeGeneratorPlugin.kt b/buildSrc/src/main/kotlin/org/jetbrains/jewel/buildlogic/theme/IntelliJThemeGeneratorPlugin.kt
index c6f025d85..8b9ac863b 100644
--- a/buildSrc/src/main/kotlin/org/jetbrains/jewel/buildlogic/theme/IntelliJThemeGeneratorPlugin.kt
+++ b/buildSrc/src/main/kotlin/org/jetbrains/jewel/buildlogic/theme/IntelliJThemeGeneratorPlugin.kt
@@ -11,6 +11,7 @@ import org.gradle.api.NamedDomainObjectContainer
 import org.gradle.api.Plugin
 import org.gradle.api.Project
 import org.gradle.api.file.DirectoryProperty
+import org.gradle.api.file.RegularFileProperty
 import org.gradle.api.tasks.Input
 import org.gradle.api.tasks.OutputFile
 import org.gradle.api.tasks.TaskAction
@@ -27,30 +28,32 @@ import java.net.URL
 
 abstract class IntelliJThemeGeneratorPlugin : Plugin<Project> {
 
-    final override fun apply(target: Project): Unit = with(target) {
-        val extension = ThemeGeneratorContainer(container<ThemeGeneration> { ThemeGeneration(it, project) })
-        extensions.add("intelliJThemeGenerator", extension)
-
-        extension.all {
-            val task = tasks.register<IntelliJThemeGeneratorTask>("generate${GUtil.toCamelCase(name)}Theme") {
-                outputFile.set(targetDir.file(this@all.themeClassName.map {
-                    val className = ClassName.bestGuess(it)
-                    className.packageName.replace(".", "/")
-                        .plus("/${className.simpleName}.kt")
-                }))
-                themeClassName.set(this@all.themeClassName)
-                ideaVersion.set(this@all.ideaVersion)
-                themeFile.set(this@all.themeFile)
-            }
-            tasks.withType<BaseKotlinCompile> {
-                dependsOn(task)
-            }
-            tasks.withType<Detekt> {
-                dependsOn(task)
-            }
-            pluginManager.withPlugin("org.jetbrains.kotlin.jvm") {
-                extensions.getByType<KotlinJvmProjectExtension>().apply {
-                    sourceSets["main"].kotlin.srcDir(targetDir)
+    final override fun apply(target: Project) {
+        with(target) {
+            val extension = ThemeGeneratorContainer(container<ThemeGeneration> { ThemeGeneration(it, project) })
+            extensions.add("intelliJThemeGenerator", extension)
+
+            extension.all {
+                val task = tasks.register<IntelliJThemeGeneratorTask>("generate${GUtil.toCamelCase(name)}Theme") {
+                    outputFile.set(targetDir.file(this@all.themeClassName.map {
+                        val className = ClassName.bestGuess(it)
+                        className.packageName.replace(".", "/")
+                            .plus("/${className.simpleName}.kt")
+                    }))
+                    themeClassName.set(this@all.themeClassName)
+                    ideaVersion.set(this@all.ideaVersion)
+                    themeFile.set(this@all.themeFile)
+                }
+                tasks.withType<BaseKotlinCompile> {
+                    dependsOn(task)
+                }
+                tasks.withType<Detekt> {
+                    dependsOn(task)
+                }
+                pluginManager.withPlugin("org.jetbrains.kotlin.jvm") {
+                    extensions.getByType<KotlinJvmProjectExtension>().apply {
+                        sourceSets["main"].kotlin.srcDir(targetDir)
+                    }
                 }
             }
         }
@@ -60,6 +63,7 @@ abstract class IntelliJThemeGeneratorPlugin : Plugin<Project> {
 class ThemeGeneratorContainer(container: NamedDomainObjectContainer<ThemeGeneration>) : NamedDomainObjectContainer<ThemeGeneration> by container
 
 class ThemeGeneration(val name: String, project: Project) {
+
     val targetDir: DirectoryProperty = project.objects.directoryProperty()
         .convention(project.layout.buildDirectory.dir("generated/theme"))
     val ideaVersion = project.objects.property<String>()
@@ -71,7 +75,7 @@ class ThemeGeneration(val name: String, project: Project) {
 open class IntelliJThemeGeneratorTask : DefaultTask() {
 
     @get:OutputFile
-    val outputFile = project.objects.fileProperty()
+    val outputFile: RegularFileProperty = project.objects.fileProperty()
 
     @get:Input
     val ideaVersion = project.objects.property<String>()
@@ -120,4 +124,5 @@ data class IntellijThemeDescriptor(
     val colors: Map<String, String> = emptyMap(),
     val ui: Map<String, JsonElement> = emptyMap(),
     val icons: Map<String, JsonElement> = emptyMap(),
+    val iconColorsOnSelection: Map<String, String> = emptyMap(),
 )
diff --git a/core/src/main/kotlin/org/jetbrains/jewel/ClassLoaderProvider.kt b/core/src/main/kotlin/org/jetbrains/jewel/ClassLoaderProvider.kt
new file mode 100644
index 000000000..5ad576d3f
--- /dev/null
+++ b/core/src/main/kotlin/org/jetbrains/jewel/ClassLoaderProvider.kt
@@ -0,0 +1,6 @@
+package org.jetbrains.jewel
+
+interface ClassLoaderProvider {
+
+    val classLoaders: List<ClassLoader>
+}
diff --git a/core/src/main/kotlin/org/jetbrains/jewel/IntelliJSvgLoader.kt b/core/src/main/kotlin/org/jetbrains/jewel/IntelliJSvgLoader.kt
deleted file mode 100644
index bde9c8e66..000000000
--- a/core/src/main/kotlin/org/jetbrains/jewel/IntelliJSvgLoader.kt
+++ /dev/null
@@ -1,119 +0,0 @@
-package org.jetbrains.jewel
-
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.Immutable
-import androidx.compose.runtime.remember
-import androidx.compose.ui.graphics.painter.Painter
-import androidx.compose.ui.platform.LocalDensity
-import androidx.compose.ui.res.ResourceLoader
-import androidx.compose.ui.res.loadSvgPainter
-import java.io.InputStream
-import java.util.concurrent.ConcurrentHashMap
-
-@Immutable
-class IntelliJSvgLoader(private val svgPatcher: SvgPatcher) : SvgLoader {
-
-    private val cache = ConcurrentHashMap<String, Painter>()
-
-    @Composable
-    override fun loadSvgResource(
-        originalPath: String,
-        resourceLoader: ResourceLoader,
-        pathPatcher: @Composable (String) -> String,
-    ): Painter {
-        val patchedPath = pathPatcher(originalPath)
-        cache[patchedPath]?.let { return it }
-
-        val painter = rememberPatchedSvgResource(originalPath, patchedPath, resourceLoader)
-        cache[patchedPath] = painter
-        return painter
-    }
-
-    @Composable
-    private fun rememberPatchedSvgResource(
-        basePath: String,
-        resourcePath: String,
-        loader: ResourceLoader,
-    ): Painter {
-        val density = LocalDensity.current
-
-        val painter =
-            try {
-                useResource(resourcePath, loader) {
-                    loadSvgPainter(it.patchColors(), density)
-                }
-            } catch (e: IllegalArgumentException) {
-                val simplerPath = trySimplifyingPath(resourcePath)
-                if (simplerPath != null) {
-                    System.err.println("Unable to load '$resourcePath' (base: $basePath), trying simpler version: $simplerPath")
-                    return rememberPatchedSvgResource(basePath, simplerPath, loader)
-                } else {
-                    throw IllegalArgumentException(
-                        "Unable to load '$resourcePath' (base: $basePath), no simpler version available",
-                        e,
-                    )
-                }
-            }
-        return remember(resourcePath, density, loader) { painter }
-    }
-
-    private fun trySimplifyingPath(originalPath: String): String? {
-        // Step 1: attempt to remove extended state qualifiers (pressed, hovered)
-        val pressedIndex = originalPath.lastIndexOf("Pressed")
-        if (pressedIndex > 0) {
-            return originalPath.removeRange(pressedIndex, pressedIndex + "Pressed".length)
-        }
-
-        val hoveredIndex = originalPath.lastIndexOf("Hovered")
-        if (hoveredIndex > 0) {
-            return originalPath.removeRange(hoveredIndex, hoveredIndex + "Hovered".length)
-        }
-
-        // Step 2: attempt to remove state qualifiers (indeterminate, selected, focused, disabled)
-        val indeterminateIndex = originalPath.lastIndexOf("Indeterminate")
-        if (indeterminateIndex > 0) {
-            return originalPath.removeRange(indeterminateIndex, indeterminateIndex + "Indeterminate".length)
-        }
-
-        val selectedIndex = originalPath.lastIndexOf("Selected")
-        if (selectedIndex > 0) {
-            return originalPath.removeRange(selectedIndex, selectedIndex + "Selected".length)
-        }
-
-        val focusedIndex = originalPath.lastIndexOf("Focused")
-        if (focusedIndex > 0) {
-            return originalPath.removeRange(focusedIndex, focusedIndex + "Focused".length)
-        }
-
-        val disabledIndex = originalPath.lastIndexOf("Disabled")
-        if (disabledIndex > 0) {
-            return originalPath.removeRange(disabledIndex, disabledIndex + "Disabled".length)
-        }
-
-        // Step 3: attempt to remove density and size qualifiers
-        val retinaIndex = originalPath.lastIndexOf("@2x")
-        if (retinaIndex > 0) {
-            return originalPath.removeRange(retinaIndex, retinaIndex + "@2x".length)
-        }
-
-        // Step 4: attempt to remove dark qualifier
-        val darkIndex = originalPath.lastIndexOf("_dark")
-        if (darkIndex > 0) {
-            return originalPath.removeRange(darkIndex, darkIndex + "_dark".length)
-        }
-
-        // TODO remove size qualifiers (e.g., "@20x20")
-
-        return null
-    }
-
-    private fun InputStream.patchColors(): InputStream =
-        svgPatcher.patchSvg(this).byteInputStream()
-
-    // Copied from androidx.compose.ui.res.Resources
-    private inline fun <T> useResource(
-        resourcePath: String,
-        loader: ResourceLoader,
-        block: (InputStream) -> T,
-    ): T = loader.load(resourcePath).use(block)
-}
diff --git a/core/src/main/kotlin/org/jetbrains/jewel/IntelliJThemeColorPalette.kt b/core/src/main/kotlin/org/jetbrains/jewel/IntelliJThemeColorPalette.kt
index 7f13cb435..0ab35707d 100644
--- a/core/src/main/kotlin/org/jetbrains/jewel/IntelliJThemeColorPalette.kt
+++ b/core/src/main/kotlin/org/jetbrains/jewel/IntelliJThemeColorPalette.kt
@@ -7,11 +7,13 @@ import androidx.compose.ui.graphics.Color
 @Stable
 interface IntelliJThemeColorPalette {
 
-    fun lookup(colorKey: String): Color?
+    fun lookup(colorKey: String): Color? = rawMap[colorKey]
+
+    val rawMap: Map<String, Color>
 }
 
 @Immutable
 object EmptyThemeColorPalette : IntelliJThemeColorPalette {
 
-    override fun lookup(colorKey: String): Color? = null
+    override val rawMap: Map<String, Color> = emptyMap()
 }
diff --git a/core/src/main/kotlin/org/jetbrains/jewel/IntelliJThemeIconData.kt b/core/src/main/kotlin/org/jetbrains/jewel/IntelliJThemeIconData.kt
index e70ca30c7..0531c1f61 100644
--- a/core/src/main/kotlin/org/jetbrains/jewel/IntelliJThemeIconData.kt
+++ b/core/src/main/kotlin/org/jetbrains/jewel/IntelliJThemeIconData.kt
@@ -1,14 +1,39 @@
 package org.jetbrains.jewel
 
 import androidx.compose.runtime.Immutable
+import androidx.compose.ui.graphics.Color
 
 @Immutable
 interface IntelliJThemeIconData {
 
     val iconOverrides: Map<String, String>
     val colorPalette: Map<String, String>
+    val selectionColorPalette: Map<String, String>
+
+    fun selectionColorMapping() =
+        selectionColorPalette.mapNotNull { (key, value) ->
+            val keyColor = key.toColorOrNull() ?: return@mapNotNull null
+            val valueColor = value.toColorOrNull() ?: return@mapNotNull null
+            keyColor to valueColor
+        }.toMap()
 }
 
+internal fun String.toColorOrNull() =
+    lowercase()
+        .removePrefix("#")
+        .removePrefix("0x")
+        .let {
+            when (it.length) {
+                3 -> "ff${it[0]}${it[0]}${it[1]}${it[1]}${it[2]}${it[2]}"
+                4 -> "${it[0]}${it[0]}${it[1]}${it[1]}${it[2]}${it[2]}${it[3]}${it[3]}"
+                6 -> "ff$it"
+                8 -> it
+                else -> null
+            }
+        }
+        ?.toLongOrNull(radix = 16)
+        ?.let { Color(it) }
+
 @Immutable
 object EmptyThemeIconData : IntelliJThemeIconData {
 
@@ -16,5 +41,8 @@ object EmptyThemeIconData : IntelliJThemeIconData {
 
     override val colorPalette: Map<String, String> = emptyMap()
 
-    override fun toString() = "EmptyThemeIconData(iconOverrides=[], colorPalette=[])"
+    override val selectionColorPalette: Map<String, String> = emptyMap()
+
+    override fun toString() =
+        "EmptyThemeIconData(iconOverrides=[], colorPalette=[], selectionColorPalette=[])"
 }
diff --git a/core/src/main/kotlin/org/jetbrains/jewel/JewelResourceLoader.kt b/core/src/main/kotlin/org/jetbrains/jewel/JewelResourceLoader.kt
index 0fc3782db..d6a3c3fb6 100644
--- a/core/src/main/kotlin/org/jetbrains/jewel/JewelResourceLoader.kt
+++ b/core/src/main/kotlin/org/jetbrains/jewel/JewelResourceLoader.kt
@@ -1,6 +1,78 @@
 package org.jetbrains.jewel
 
-interface JewelResourceLoader {
+import androidx.compose.ui.res.ResourceLoader
+import java.io.InputStream
 
-    val searchClasses: List<Class<out Any>>
+abstract class JewelResourceLoader : ResourceLoader {
+
+    protected var verbose = true
+
+    protected fun loadResourceOrNull(path: String, classLoaders: List<ClassLoader>): InputStream? {
+        for (classLoader in classLoaders) {
+            val stream = classLoader.getResourceAsStream(path)
+            if (stream != null) {
+                if (verbose) println("Found resource: '$path'")
+                return stream
+            }
+
+            // Didn't work, let's see if we can simplify the icon to a base state
+            val simplifiedPath = trySimplifyingPath(path)
+            if (simplifiedPath != null) {
+                if (verbose) println("Resource not found: '$path'. Trying simplified path: '$simplifiedPath'")
+                return loadResourceOrNull(simplifiedPath, classLoaders)
+            }
+        }
+
+        return null
+    }
+
+    private fun trySimplifyingPath(originalPath: String): String? {
+        // Step 1: attempt to remove dark qualifier
+        val darkIndex = originalPath.lastIndexOf("_dark")
+        if (darkIndex > 0) {
+            return originalPath.removeRange(darkIndex, darkIndex + "_dark".length)
+        }
+
+        // Step 2: attempt to remove extended state qualifiers (pressed, hovered)
+        val pressedIndex = originalPath.lastIndexOf("Pressed")
+        if (pressedIndex > 0) {
+            return originalPath.removeRange(pressedIndex, pressedIndex + "Pressed".length)
+        }
+
+        val hoveredIndex = originalPath.lastIndexOf("Hovered")
+        if (hoveredIndex > 0) {
+            return originalPath.removeRange(hoveredIndex, hoveredIndex + "Hovered".length)
+        }
+
+        // Step 3: attempt to remove state qualifiers (indeterminate, selected, focused, disabled)
+        val indeterminateIndex = originalPath.lastIndexOf("Indeterminate")
+        if (indeterminateIndex > 0) {
+            return originalPath.removeRange(indeterminateIndex, indeterminateIndex + "Indeterminate".length)
+        }
+
+        val selectedIndex = originalPath.lastIndexOf("Selected")
+        if (selectedIndex > 0) {
+            return originalPath.removeRange(selectedIndex, selectedIndex + "Selected".length)
+        }
+
+        val focusedIndex = originalPath.lastIndexOf("Focused")
+        if (focusedIndex > 0) {
+            return originalPath.removeRange(focusedIndex, focusedIndex + "Focused".length)
+        }
+
+        val disabledIndex = originalPath.lastIndexOf("Disabled")
+        if (disabledIndex > 0) {
+            return originalPath.removeRange(disabledIndex, disabledIndex + "Disabled".length)
+        }
+
+        // Step 4: attempt to remove density and size qualifiers
+        val retinaIndex = originalPath.lastIndexOf("@2x")
+        if (retinaIndex > 0) {
+            return originalPath.removeRange(retinaIndex, retinaIndex + "@2x".length)
+        }
+
+        // TODO remove size qualifiers (e.g., "@20x20")
+
+        return null
+    }
 }
diff --git a/core/src/main/kotlin/org/jetbrains/jewel/JewelSvgLoader.kt b/core/src/main/kotlin/org/jetbrains/jewel/JewelSvgLoader.kt
new file mode 100644
index 000000000..e93f4749c
--- /dev/null
+++ b/core/src/main/kotlin/org/jetbrains/jewel/JewelSvgLoader.kt
@@ -0,0 +1,54 @@
+package org.jetbrains.jewel
+
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.Immutable
+import androidx.compose.runtime.remember
+import androidx.compose.ui.graphics.painter.Painter
+import androidx.compose.ui.platform.LocalDensity
+import androidx.compose.ui.res.ResourceLoader
+import androidx.compose.ui.res.loadSvgPainter
+import java.io.InputStream
+import java.util.concurrent.ConcurrentHashMap
+
+@Immutable
+class JewelSvgLoader(private val svgPatcher: SvgPatcher) : SvgLoader {
+
+    private val cache = ConcurrentHashMap<String, Painter>()
+
+    @Composable
+    override fun loadSvgResource(
+        svgPath: String,
+        resourceLoader: ResourceLoader,
+        pathPatcher: @Composable (String) -> String,
+    ): Painter {
+        val patchedPath = pathPatcher(svgPath)
+        cache[patchedPath]?.let { return it }
+
+        val painter = rememberPatchedSvgResource(patchedPath, resourceLoader)
+        cache[patchedPath] = painter
+        return painter
+    }
+
+    @Composable
+    private fun rememberPatchedSvgResource(
+        resourcePath: String,
+        loader: ResourceLoader,
+    ): Painter {
+        val density = LocalDensity.current
+
+        val painter = useResource(resourcePath, loader) {
+            loadSvgPainter(it.patchColors(resourcePath), density)
+        }
+        return remember(resourcePath, density, loader) { painter }
+    }
+
+    private fun InputStream.patchColors(resourcePath: String): InputStream =
+        svgPatcher.patchSvg(this, resourcePath).byteInputStream()
+
+    // Copied from androidx.compose.ui.res.Resources
+    private inline fun <T> useResource(
+        resourcePath: String,
+        loader: ResourceLoader,
+        block: (InputStream) -> T,
+    ): T = loader.load(resourcePath).use(block)
+}
diff --git a/core/src/main/kotlin/org/jetbrains/jewel/LazyTree.kt b/core/src/main/kotlin/org/jetbrains/jewel/LazyTree.kt
index bf7d48a4e..3dce4abe2 100644
--- a/core/src/main/kotlin/org/jetbrains/jewel/LazyTree.kt
+++ b/core/src/main/kotlin/org/jetbrains/jewel/LazyTree.kt
@@ -50,8 +50,8 @@ fun <T> LazyTree(
         onSelectionChange = onSelectionChange,
         keyActions = keyActions,
         chevronContent = { elementState ->
-            val painterProvider = style.icons.nodeChevron(elementState.isExpanded)
-            val painter by painterProvider.getPainter(resourceLoader, elementState)
+            val painterProvider = style.icons.chevron(elementState.isExpanded, elementState.isSelected)
+            val painter by painterProvider.getPainter(resourceLoader)
             Icon(painter = painter, contentDescription = null)
         },
     ) {
diff --git a/core/src/main/kotlin/org/jetbrains/jewel/PaletteMapper.kt b/core/src/main/kotlin/org/jetbrains/jewel/PaletteMapper.kt
index 33373abbf..5ebe6666a 100644
--- a/core/src/main/kotlin/org/jetbrains/jewel/PaletteMapper.kt
+++ b/core/src/main/kotlin/org/jetbrains/jewel/PaletteMapper.kt
@@ -3,28 +3,48 @@ package org.jetbrains.jewel
 import androidx.compose.runtime.Immutable
 import androidx.compose.ui.graphics.Color
 
+// Replicates com.intellij.ide.ui.UITheme.PaletteScopeManager's functionality
+// (note that in Swing, there is also a RadioButtons scope, but while it gets
+// written to, it never gets accessed by the actual color patching, so we ignore
+// writing any Radio button-related entries and read the CheckBox values for them)
 @Immutable
-class PaletteMapper(val colorOverrides: Map<Color, Color>) {
-
-    fun mapColor(originalColor: Color): Color =
-        mapColorOrNull(originalColor) ?: originalColor
+class PaletteMapper(
+    private val ui: Scope,
+    private val checkBoxes: Scope,
+    private val trees: Scope,
+) {
+
+    fun getScopeForPath(path: String?): Scope? {
+        if (path == null) return ui
+        if (!path.contains("com/intellij/ide/ui/laf/icons/")) return ui
+
+        val file = path.substringAfterLast('/')
+        return when {
+            file == "treeCollapsed.svg" || file == "treeExpanded.svg" -> trees
+            // ⚠️ This next line is not a copy-paste error — the code in UITheme.PaletteScopeManager.getScopeByPath()
+            // says they share the same colors
+            file.startsWith("check") || file.startsWith("radio") -> checkBoxes
+            else -> null
+        }
+    }
 
-    fun mapColorOrNull(originalColor: Color): Color? {
-        if (colorOverrides.isEmpty()) return null
+    companion object {
 
-        return colorOverrides[originalColor]
+        val Empty = PaletteMapper(Scope.Empty, Scope.Empty, Scope.Empty)
     }
 
-    override fun equals(other: Any?): Boolean {
-        if (this === other) return true
-        if (javaClass != other?.javaClass) return false
+    @Immutable
+    @JvmInline
+    value class Scope(val colorOverrides: Map<Color, Color>) {
 
-        other as PaletteMapper
+        fun mapColorOrNull(originalColor: Color): Color? =
+            colorOverrides[originalColor]
 
-        return colorOverrides == other.colorOverrides
-    }
+        override fun toString(): String = "PaletteMapper.Scope(colorOverrides=$colorOverrides)"
 
-    override fun hashCode(): Int = colorOverrides.hashCode()
+        companion object {
 
-    override fun toString() = "PaletteMapper(colorOverrides=$colorOverrides)"
+            val Empty = Scope(emptyMap())
+        }
+    }
 }
diff --git a/core/src/main/kotlin/org/jetbrains/jewel/SimpleResourceLoader.kt b/core/src/main/kotlin/org/jetbrains/jewel/SimpleResourceLoader.kt
new file mode 100644
index 000000000..c245a0f28
--- /dev/null
+++ b/core/src/main/kotlin/org/jetbrains/jewel/SimpleResourceLoader.kt
@@ -0,0 +1,20 @@
+package org.jetbrains.jewel
+
+import java.io.InputStream
+
+class SimpleResourceLoader(private val classLoader: ClassLoader) : JewelResourceLoader(), ClassLoaderProvider {
+
+    override val classLoaders
+        get() = listOf(javaClass.classLoader, classLoader)
+
+    override fun load(resourcePath: String): InputStream {
+        val path = resourcePath.removePrefix("/")
+        val parentClassLoader =
+            StackWalker.getInstance(StackWalker.Option.RETAIN_CLASS_REFERENCE)
+                .callerClass
+                .classLoader
+        val resource = loadResourceOrNull(path, classLoaders + parentClassLoader)
+
+        return requireNotNull(resource) { "Resource '$resourcePath' not found (tried loading: '$path')" }
+    }
+}
diff --git a/core/src/main/kotlin/org/jetbrains/jewel/SvgLoader.kt b/core/src/main/kotlin/org/jetbrains/jewel/SvgLoader.kt
index 3081f3b13..1653c8668 100644
--- a/core/src/main/kotlin/org/jetbrains/jewel/SvgLoader.kt
+++ b/core/src/main/kotlin/org/jetbrains/jewel/SvgLoader.kt
@@ -8,7 +8,7 @@ interface SvgLoader {
 
     @Composable
     fun loadSvgResource(
-        originalPath: String,
+        svgPath: String,
         resourceLoader: ResourceLoader,
         pathPatcher: @Composable (String) -> String,
     ): Painter
diff --git a/core/src/main/kotlin/org/jetbrains/jewel/SvgPatcher.kt b/core/src/main/kotlin/org/jetbrains/jewel/SvgPatcher.kt
index 00910c0b4..2cc427fc5 100644
--- a/core/src/main/kotlin/org/jetbrains/jewel/SvgPatcher.kt
+++ b/core/src/main/kotlin/org/jetbrains/jewel/SvgPatcher.kt
@@ -4,5 +4,5 @@ import java.io.InputStream
 
 interface SvgPatcher {
 
-    fun patchSvg(rawSvg: InputStream): String
+    fun patchSvg(rawSvg: InputStream, path: String?): String
 }
diff --git a/core/src/main/kotlin/org/jetbrains/jewel/TextArea.kt b/core/src/main/kotlin/org/jetbrains/jewel/TextArea.kt
index 01d5934f2..1dbc198e1 100644
--- a/core/src/main/kotlin/org/jetbrains/jewel/TextArea.kt
+++ b/core/src/main/kotlin/org/jetbrains/jewel/TextArea.kt
@@ -124,7 +124,7 @@ fun TextArea(
         style = style,
         textStyle = textStyle,
         interactionSource = interactionSource,
-    ) { innerTextField, state ->
+    ) { innerTextField, _ ->
         TextAreaDecorationBox(
             innerTextField = innerTextField,
             contentPadding = style.metrics.contentPadding,
diff --git a/core/src/main/kotlin/org/jetbrains/jewel/foundation/lazy/Keybindings.kt b/core/src/main/kotlin/org/jetbrains/jewel/foundation/lazy/Keybindings.kt
index 9b5f343e7..ea382811d 100644
--- a/core/src/main/kotlin/org/jetbrains/jewel/foundation/lazy/Keybindings.kt
+++ b/core/src/main/kotlin/org/jetbrains/jewel/foundation/lazy/Keybindings.kt
@@ -100,7 +100,6 @@ open class DefaultSelectableColumnKeybindings : SelectableColumnKeybindings {
     override val PointerKeyboardModifiers.isKeyboardMultiSelectionKeyPressed: Boolean
         get() = isShiftPressed
 
-
     override fun KeyEvent.selectFirstItem() =
         key == Key.Home && !isKeyboardMultiSelectionKeyPressed
 
@@ -141,5 +140,4 @@ open class DefaultSelectableColumnKeybindings : SelectableColumnKeybindings {
 
     override fun KeyEvent.selectAll(): Boolean? =
         key == Key.A && isKeyboardCtrlMetaKeyPressed
-
 }
diff --git a/core/src/main/kotlin/org/jetbrains/jewel/foundation/lazy/SelectableLazyColumn.kt b/core/src/main/kotlin/org/jetbrains/jewel/foundation/lazy/SelectableLazyColumn.kt
index 81423d960..1bc0aba2c 100644
--- a/core/src/main/kotlin/org/jetbrains/jewel/foundation/lazy/SelectableLazyColumn.kt
+++ b/core/src/main/kotlin/org/jetbrains/jewel/foundation/lazy/SelectableLazyColumn.kt
@@ -12,10 +12,11 @@ import androidx.compose.runtime.Composable
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
-import androidx.compose.runtime.rememberCoroutineScope
 import androidx.compose.runtime.setValue
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.focus.FocusRequester
+import androidx.compose.ui.focus.focusRequester
 import androidx.compose.ui.focus.onFocusChanged
 import androidx.compose.ui.input.key.onPreviewKeyEvent
 import androidx.compose.ui.input.pointer.PointerEventType
@@ -28,8 +29,8 @@ import org.jetbrains.jewel.foundation.tree.KeyBindingActions
 import org.jetbrains.jewel.foundation.tree.PointerEventActions
 
 /**
- * A composable that displays a scrollable and selectable list of items in a column arrangement.
- *
+ * A composable that displays a scrollable and selectable list of items in
+ * a column arrangement.
  */
 @Composable
 fun SelectableLazyColumn(
@@ -47,8 +48,6 @@ fun SelectableLazyColumn(
     interactionSource: MutableInteractionSource = remember { MutableInteractionSource() },
     content: SelectableLazyListScope.() -> Unit,
 ) {
-    val scope = rememberCoroutineScope()
-
     val container = remember(content) {
         SelectableLazyListScopeContainer().apply(content)
     }
@@ -56,21 +55,26 @@ fun SelectableLazyColumn(
     val keys = remember(container) {
         container.getKeys()
     }
+    var isFocused by remember { mutableStateOf(false) }
 
-    var isActive by remember { mutableStateOf(false) }
+    fun evaluateIndexes(): List<Int> {
+        val keyToIndexMap = keys.withIndex().associateBy({ it.value.key }, { it.index })
+        return state.selectedKeys
+            .mapNotNull { selected -> keyToIndexMap[selected] }
+            .sorted()
+    }
 
     remember(state.selectedKeys) {
-        onSelectedIndexesChanged(state.selectedKeys.map { selected -> keys.indexOfFirst { it.key == selected } })
+        onSelectedIndexesChanged(evaluateIndexes())
     }
-
+    val focusRequester = remember { FocusRequester() }
     LazyColumn(
         modifier = modifier
+            .onFocusChanged { isFocused = it.hasFocus }
+            .focusRequester(focusRequester)
             .focusable(interactionSource = interactionSource)
-            .onFocusChanged {
-                isActive = it.hasFocus
-            }
             .onPreviewKeyEvent { event ->
-                state.lastActiveItemIndex?.let { _ ->
+                if (state.lastActiveItemIndex != null) {
                     keyActions.handleOnKeyEvent(event, keys, state, selectionMode).invoke(event)
                 }
                 true
@@ -87,11 +91,12 @@ fun SelectableLazyColumn(
                 is Entry.Item -> item(entry.key, entry.contentType) {
                     val itemScope = SelectableLazyItemScope(
                         isSelected = entry.key in state.selectedKeys,
-                        isActive = isActive,
+                        isActive = isFocused,
                     )
                     if (keys.any { it.key == entry.key && it is SelectableLazyListKey.Selectable }) {
                         Box(
                             modifier = Modifier.selectable(
+                                requester = focusRequester,
                                 keybindings = keyActions.keybindings,
                                 actionHandler = pointerEventActions,
                                 selectionMode = selectionMode,
@@ -112,10 +117,11 @@ fun SelectableLazyColumn(
                     key = { entry.key(entry.startIndex + it) },
                     contentType = { entry.contentType(it) },
                 ) { index ->
-                    val itemScope = SelectableLazyItemScope(entry.key(index) in state.selectedKeys, isActive)
+                    val itemScope = SelectableLazyItemScope(entry.key(index) in state.selectedKeys, isFocused)
                     if (keys.any { it.key == entry.key(index) && it is SelectableLazyListKey.Selectable }) {
                         Box(
                             modifier = Modifier.selectable(
+                                requester = focusRequester,
                                 keybindings = keyActions.keybindings,
                                 actionHandler = pointerEventActions,
                                 selectionMode = selectionMode,
@@ -132,7 +138,7 @@ fun SelectableLazyColumn(
                 }
 
                 is Entry.StickyHeader -> stickyHeader(entry.key, entry.contentType) {
-                    val itemScope = SelectableLazyItemScope(entry.key in state.selectedKeys, isActive)
+                    val itemScope = SelectableLazyItemScope(entry.key in state.selectedKeys, isFocused)
                     if (keys.any { it.key == entry.key && it is SelectableLazyListKey.Selectable }) {
                         Box(
                             modifier = Modifier.selectable(
@@ -147,7 +153,7 @@ fun SelectableLazyColumn(
                             entry.content.invoke(itemScope)
                         }
                     } else {
-                        SelectableLazyItemScope(entry.key in state.selectedKeys, isActive).apply {
+                        SelectableLazyItemScope(entry.key in state.selectedKeys, isFocused).apply {
                             entry.content.invoke(itemScope)
                         }
                     }
@@ -158,6 +164,7 @@ fun SelectableLazyColumn(
 }
 
 private fun Modifier.selectable(
+    requester: FocusRequester? = null,
     keybindings: SelectableColumnKeybindings,
     actionHandler: PointerEventActions,
     selectionMode: SelectionMode,
@@ -169,14 +176,17 @@ private fun Modifier.selectable(
         while (true) {
             val event = awaitPointerEvent()
             when (event.type) {
-                PointerEventType.Press -> actionHandler.handlePointerEventPress(
-                    event,
-                    keybindings,
-                    selectableState,
-                    selectionMode,
-                    allKeys,
-                    itemKey,
-                )
+                PointerEventType.Press -> {
+                    requester?.requestFocus()
+                    actionHandler.handlePointerEventPress(
+                        pointerEvent = event,
+                        keyBindings = keybindings,
+                        selectableLazyListState = selectableState,
+                        selectionMode = selectionMode,
+                        allKeys = allKeys,
+                        key = itemKey,
+                    )
+                }
             }
         }
     }
diff --git a/core/src/main/kotlin/org/jetbrains/jewel/foundation/lazy/SelectableLazyListScope.kt b/core/src/main/kotlin/org/jetbrains/jewel/foundation/lazy/SelectableLazyListScope.kt
index f31d028c1..dab700a25 100644
--- a/core/src/main/kotlin/org/jetbrains/jewel/foundation/lazy/SelectableLazyListScope.kt
+++ b/core/src/main/kotlin/org/jetbrains/jewel/foundation/lazy/SelectableLazyListScope.kt
@@ -6,9 +6,7 @@ import androidx.compose.runtime.Composable
 import org.jetbrains.jewel.foundation.lazy.SelectableLazyListKey.NotSelectable
 import org.jetbrains.jewel.foundation.lazy.SelectableLazyListKey.Selectable
 
-/**
- * Interface defining the scope for building a selectable lazy list.
- */
+/** Interface defining the scope for building a selectable lazy list. */
 interface SelectableLazyListScope {
 
     /**
@@ -16,7 +14,8 @@ interface SelectableLazyListScope {
      *
      * @param key The unique identifier for the item.
      * @param contentType The type of content displayed in the item.
-     * @param selectable Determines if the item is selectable. Default is `true`.
+     * @param selectable Determines if the item is selectable. Default is
+     *     `true`.
      * @param content The content of the item as a composable function.
      */
     fun item(
@@ -30,10 +29,14 @@ interface SelectableLazyListScope {
      * Represents a list of items based on the provided parameters.
      *
      * @param count The number of items in the list.
-     * @param key A function that generates a unique key for each item based on its index.
-     * @param contentType A function that returns the content type of an item based on its index. Defaults to `null`.
-     * @param selectable A function that determines if an item is selectable based on its index. Defaults to `true`.
-     * @param itemContent The content of each individual item, specified as a composable function that takes the item's index as a parameter.
+     * @param key A function that generates a unique key for each item based on
+     *     its index.
+     * @param contentType A function that returns the content type of an item
+     *     based on its index. Defaults to `null`.
+     * @param selectable A function that determines if an item is selectable
+     *     based on its index. Defaults to `true`.
+     * @param itemContent The content of each individual item, specified as a
+     *     composable function that takes the item's index as a parameter.
      */
     fun items(
         count: Int,
@@ -49,7 +52,8 @@ interface SelectableLazyListScope {
      * @param key The unique identifier for the sticky header.
      * @param contentType The type of content in the sticky header.
      * @param selectable Specifies whether the sticky header is selectable.
-     * @param content The content to be displayed in the sticky header, provided as a composable function
+     * @param content The content to be displayed in the sticky header,
+     *     provided as a composable function
      */
     fun stickyHeader(
         key: Any,
@@ -142,13 +146,15 @@ fun <T : Any> SelectableLazyListScope.items(
     contentType: (item: T) -> Any? = { it },
     selectable: (item: T) -> Boolean = { true },
     itemContent: @Composable SelectableLazyItemScope.(item: T) -> Unit,
-) = items(
-    count = items.size,
-    key = { key(items[it]) },
-    contentType = { contentType(items[it]) },
-    selectable = { selectable(items[it]) },
-    itemContent = { itemContent(items[it]) }
-)
+) {
+    items(
+        count = items.size,
+        key = { key(items[it]) },
+        contentType = { contentType(items[it]) },
+        selectable = { selectable(items[it]) },
+        itemContent = { itemContent(items[it]) },
+    )
+}
 
 fun <T : Any> SelectableLazyListScope.itemsIndexed(
     items: List<T>,
@@ -156,13 +162,15 @@ fun <T : Any> SelectableLazyListScope.itemsIndexed(
     contentType: (index: Int, item: T) -> Any? = { _, item -> item },
     selectable: (index: Int, item: T) -> Boolean = { _, _ -> true },
     itemContent: @Composable SelectableLazyItemScope.(index: Int, item: T) -> Unit,
-) = items(
-    count = items.size,
-    key = { key(it, items[it]) },
-    contentType = { contentType(it, items[it]) },
-    selectable = { selectable(it, items[it]) },
-    itemContent = { itemContent(it, items[it]) }
-)
+) {
+    items(
+        count = items.size,
+        key = { key(it, items[it]) },
+        contentType = { contentType(it, items[it]) },
+        selectable = { selectable(it, items[it]) },
+        itemContent = { itemContent(it, items[it]) },
+    )
+}
 
 @Composable
 fun LazyItemScope.SelectableLazyItemScope(
diff --git a/core/src/main/kotlin/org/jetbrains/jewel/foundation/tree/BasicLazyTree.kt b/core/src/main/kotlin/org/jetbrains/jewel/foundation/tree/BasicLazyTree.kt
index 2d2f87a24..148972856 100644
--- a/core/src/main/kotlin/org/jetbrains/jewel/foundation/tree/BasicLazyTree.kt
+++ b/core/src/main/kotlin/org/jetbrains/jewel/foundation/tree/BasicLazyTree.kt
@@ -106,7 +106,7 @@ fun <T> BasicLazyTree(
                 .asSequence()
                 .filter { it.id in treeState.delegate.selectedKeys }
                 .map { element -> element as Tree.Element<T> }
-                .toList()
+                .toList(),
         )
     }
 
diff --git a/core/src/main/kotlin/org/jetbrains/jewel/styling/LazyTreeStyling.kt b/core/src/main/kotlin/org/jetbrains/jewel/styling/LazyTreeStyling.kt
index 485af660c..4055bfa92 100644
--- a/core/src/main/kotlin/org/jetbrains/jewel/styling/LazyTreeStyling.kt
+++ b/core/src/main/kotlin/org/jetbrains/jewel/styling/LazyTreeStyling.kt
@@ -56,12 +56,19 @@ interface LazyTreeMetrics {
 @Immutable
 interface LazyTreeIcons {
 
-    val nodeChevronCollapsed: PainterProvider<TreeElementState>
-    val nodeChevronExpanded: PainterProvider<TreeElementState>
+    val chevronCollapsed: PainterProvider<Unit>
+    val chevronExpanded: PainterProvider<Unit>
+    val chevronSelectedCollapsed: PainterProvider<Unit>
+    val chevronSelectedExpanded: PainterProvider<Unit>
 
     @Composable
-    fun nodeChevron(isExpanded: Boolean) =
-        if (isExpanded) nodeChevronExpanded else nodeChevronCollapsed
+    fun chevron(isExpanded: Boolean, isSelected: Boolean) =
+        when {
+            isSelected && isExpanded -> chevronSelectedExpanded
+            isSelected && !isExpanded -> chevronSelectedCollapsed
+            !isSelected && isExpanded -> chevronExpanded
+            else -> chevronCollapsed
+        }
 }
 
 val LocalLazyTreeStyle = staticCompositionLocalOf<LazyTreeStyle> {
diff --git a/core/src/main/kotlin/org/jetbrains/jewel/styling/PainterProvider.kt b/core/src/main/kotlin/org/jetbrains/jewel/styling/PainterProvider.kt
index 3047d789e..ff0779d9d 100644
--- a/core/src/main/kotlin/org/jetbrains/jewel/styling/PainterProvider.kt
+++ b/core/src/main/kotlin/org/jetbrains/jewel/styling/PainterProvider.kt
@@ -9,6 +9,29 @@ import androidx.compose.ui.res.ResourceLoader
 @Immutable
 interface PainterProvider<T> {
 
+    /**
+     * Obtain a painter, with no extra data. It is equivalent to calling
+     * [getPainter] with a `null` value for the `extraData` argument. This
+     * overload should only be used for stateless painter providers (i.e., when
+     * [T] is [Unit]).
+     *
+     * A [resourceLoader] that allows loading the corresponding resource must
+     * be loading. For example, if your resource is in module `my-module`'s
+     * resources, the [resourceLoader] must be pointing to `my-module`s
+     * classloader.
+     *
+     * Passing the wrong [ResourceLoader] will cause your resources not to
+     * load, and you will get cryptic errors. Please also note that using
+     * [ResourceLoader.Default] will probably cause loading to fail if you are
+     * trying to load the icons from a different module. For example, if Jewel
+     * is running in the IDE and you use [ResourceLoader.Default] to try and
+     * load a default IDE resource, it will fail.
+     *
+     * @see getPainter
+     */
+    @Composable
+    fun getPainter(resourceLoader: ResourceLoader): State<Painter> = getPainter(resourceLoader, null)
+
     /**
      * Obtain a painter for the provided [extraData].
      *
diff --git a/core/src/main/kotlin/org/jetbrains/jewel/styling/ResourcePainterProvider.kt b/core/src/main/kotlin/org/jetbrains/jewel/styling/ResourcePainterProvider.kt
index 276fb7a43..60c8e720c 100644
--- a/core/src/main/kotlin/org/jetbrains/jewel/styling/ResourcePainterProvider.kt
+++ b/core/src/main/kotlin/org/jetbrains/jewel/styling/ResourcePainterProvider.kt
@@ -62,7 +62,8 @@ open class ResourcePainterProvider<T> @InternalJewelApi constructor(
     override fun toString(): String =
         "ResourcePainterProvider(basePath='$basePath', svgLoader=$svgLoader, pathPatcher=$pathPatcher)"
 
-    companion object {
+    @OptIn(InternalJewelApi::class) // These are the public constructors
+    companion object Factory {
 
         fun stateless(basePath: String, svgLoader: SvgLoader) =
             ResourcePainterProvider<Unit>(basePath, svgLoader, SimpleResourcePathPatcher())
diff --git a/core/src/main/kotlin/org/jetbrains/jewel/themes/PaletteMapperFactory.kt b/core/src/main/kotlin/org/jetbrains/jewel/themes/PaletteMapperFactory.kt
index d22635b32..643477153 100644
--- a/core/src/main/kotlin/org/jetbrains/jewel/themes/PaletteMapperFactory.kt
+++ b/core/src/main/kotlin/org/jetbrains/jewel/themes/PaletteMapperFactory.kt
@@ -1,97 +1,64 @@
 package org.jetbrains.jewel.themes
 
 import androidx.compose.ui.graphics.Color
-import org.jetbrains.jewel.IntelliJThemeColorPalette
-import org.jetbrains.jewel.IntelliJThemeIconData
 import org.jetbrains.jewel.PaletteMapper
 
-object PaletteMapperFactory {
+abstract class PaletteMapperFactory {
 
-    // Extracted from com.intellij.ide.ui.UITheme#colorPalette
-    private val colorsToMap = mapOf(
-        "Actions.Red" to "#DB5860",
-        "Actions.Red.Dark" to "#C75450",
-        "Actions.Yellow" to "#EDA200",
-        "Actions.Yellow.Dark" to "#F0A732",
-        "Actions.Green" to "#59A869",
-        "Actions.Green.Dark" to "#499C54",
-        "Actions.Blue" to "#389FD6",
-        "Actions.Blue.Dark" to "#3592C4",
-        "Actions.Grey" to "#6E6E6E",
-        "Actions.Grey.Dark" to "#AFB1B3",
-        "Actions.GreyInline" to "#7F8B91",
-        "Actions.GreyInline.Dark" to "#7F8B91",
-        "Objects.Grey" to "#9AA7B0",
-        "Objects.Blue" to "#40B6E0",
-        "Objects.Green" to "#62B543",
-        "Objects.Yellow" to "#F4AF3D",
-        "Objects.YellowDark" to "#D9A343",
-        "Objects.Purple" to "#B99BF8",
-        "Objects.Pink" to "#F98B9E",
-        "Objects.Red" to "#F26522",
-        "Objects.RedStatus" to "#E05555",
-        "Objects.GreenAndroid" to "#3DDC84",
-        "Objects.BlackText" to "#231F20",
-        "Checkbox.Background.Default" to "#FFFFFF",
-        "Checkbox.Background.Default.Dark" to "#43494A",
-        "Checkbox.Background.Disabled" to "#F2F2F2",
-        "Checkbox.Background.Disabled.Dark" to "#3C3F41",
-        "Checkbox.Border.Default" to "#b0b0b0",
-        "Checkbox.Border.Default.Dark" to "#6B6B6B",
-        "Checkbox.Border.Disabled" to "#BDBDBD",
-        "Checkbox.Border.Disabled.Dark" to "#545556",
-        "Checkbox.Focus.Thin.Default" to "#7B9FC7",
-        "Checkbox.Focus.Thin.Default.Dark" to "#466D94",
-        "Checkbox.Focus.Wide" to "#97C3F3",
-        "Checkbox.Focus.Wide.Dark" to "#3D6185",
-        "Checkbox.Foreground.Disabled" to "#ABABAB",
-        "Checkbox.Foreground.Disabled.Dark" to "#606060",
-        "Checkbox.Background.Selected" to "#4F9EE3",
-        "Checkbox.Background.Selected.Dark" to "#43494A",
-        "Checkbox.Border.Selected" to "#4B97D9",
-        "Checkbox.Border.Selected.Dark" to "#6B6B6B",
-        "Checkbox.Foreground.Selected" to "#FEFEFE",
-        "Checkbox.Foreground.Selected.Dark" to "#A7A7A7",
-        "Checkbox.Focus.Thin.Selected" to "#ACCFF7",
-        "Checkbox.Focus.Thin.Selected.Dark" to "#466D94",
-        "Tree.iconColor" to "#808080",
-        "Tree.iconColor.Dark" to "#AFB1B3",
-    )
-
-    fun create(
+    protected fun createInternal(
+        iconColorPalette: Map<String, String>,
+        keyPalette: Map<String, String>,
+        themeColors: Map<String, Any>,
         isDark: Boolean,
-        iconData: IntelliJThemeIconData,
-        colorPalette: IntelliJThemeColorPalette,
     ): PaletteMapper {
-        val overrides = computeOverrides(isDark, iconData.colorPalette, colorPalette)
-        return PaletteMapper(overrides)
+        // This partially emulates what com.intellij.ide.ui.UITheme.loadFromJson does
+        val ui = mutableMapOf<Color, Color>()
+        val checkBoxes = mutableMapOf<Color, Color>()
+        val trees = mutableMapOf<Color, Color>()
+
+        for ((key, value) in iconColorPalette) {
+            val map = selectMap(key, checkBoxes, trees, ui) ?: continue
+
+            // If the value is one of the named colors in the theme, use that named color's value
+            val namedColor = themeColors.get(value) as? String
+            val resolvedValue = namedColor ?: value
+
+            // If either the key or the resolved value aren't valid colors, ignore the entry
+            val keyAsColor = resolveKeyColor(key, keyPalette, isDark) ?: continue
+            val resolvedValueAsColor = resolvedValue.toColorOrNull() ?: continue
+
+            // Save the new entry (oldColor -> newColor) in the map
+            map[keyAsColor] = resolvedValueAsColor
+        }
+
+        return PaletteMapper(
+            ui = PaletteMapper.Scope(ui),
+            checkBoxes = PaletteMapper.Scope(checkBoxes),
+            trees = PaletteMapper.Scope(trees),
+        )
     }
 
-    // 1. Load the icons.ColorPalette map from the theme JSON, if it exists, and for each key:
-    // 2. Resolve the hex value by looking up the ColorPalette key
-    //    * Append ".Dark" to the key if in dark theme
-    //    * Read the corresponding value from the UITheme#colorPalette map (the "oldColor" hex value)
-    // 3. Read the "newColor" hex value corresponding to the key from the theme's icons.ColorPalette map
-    // 4. Resolve (if needed) the newColor
-    //    * The "newColor" in the theme may be a theme color palette key, that needs to be resolved to a hex value
-    //    * Note down the alpha value, if any is specified (that is, if the value is in the #AARRGGBB format)
-    // 6. Write a new entry oldColor -> newColor, bringing over the original alpha into the newColor (if any)
-    private fun computeOverrides(
-        isDark: Boolean,
-        iconColorMap: Map<String, String>,
-        colorPalette: IntelliJThemeColorPalette,
-    ) =
-        buildMap {
-            for (colorOverride in iconColorMap) {
-                val key = colorHexForKey(colorOverride.key, isDark)
-                val overrideValue = colorOverride.value
-                val newColor = overrideValue.takeIf { it.startsWith("#") }?.toColorOrNull()
-                    ?: colorPalette.lookup(overrideValue)
-                    ?: continue
-                val oldColor = key.toColorOrNull() ?: continue
-                put(oldColor, newColor)
-            }
+    // See com.intellij.ide.ui.UITheme.toColorString
+    private fun resolveKeyColor(key: String, keyPalette: Map<String, String>, isDark: Boolean): Color? {
+        val darkKey = "$key.Dark"
+        val resolvedKey = if (isDark && keyPalette.containsKey(darkKey)) darkKey else key
+        return keyPalette[resolvedKey]?.toColorOrNull()
+    }
+
+    private fun selectMap(
+        key: String,
+        checkBoxes: MutableMap<Color, Color>,
+        trees: MutableMap<Color, Color>,
+        ui: MutableMap<Color, Color>,
+    ) = when {
+        key.startsWith("Checkbox.") -> checkBoxes
+        key.startsWith("Tree.iconColor.") -> trees
+        key.startsWith("Objects.") || key.startsWith("Actions.") || key.startsWith("#") -> ui
+        else -> {
+            logInfo("No PaletteMapperScope defined for key '$key'")
+            null
         }
+    }
 
     private fun String.toColorOrNull() =
         lowercase()
@@ -109,12 +76,5 @@ object PaletteMapperFactory {
             ?.toLongOrNull(radix = 16)
             ?.let { Color(it) }
 
-    private fun colorHexForKey(key: String, isDark: Boolean): String {
-        val resolvedColor = if (isDark) {
-            colorsToMap["$key.Dark"] ?: colorsToMap[key]
-        } else {
-            colorsToMap[key]
-        }
-        return (resolvedColor ?: key).lowercase()
-    }
+    abstract fun logInfo(message: String)
 }
diff --git a/core/src/main/kotlin/org/jetbrains/jewel/themes/StandalonePaletteMapperFactory.kt b/core/src/main/kotlin/org/jetbrains/jewel/themes/StandalonePaletteMapperFactory.kt
new file mode 100644
index 000000000..bd49dc09d
--- /dev/null
+++ b/core/src/main/kotlin/org/jetbrains/jewel/themes/StandalonePaletteMapperFactory.kt
@@ -0,0 +1,82 @@
+package org.jetbrains.jewel.themes
+
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.toArgb
+import org.jetbrains.jewel.IntelliJThemeColorPalette
+import org.jetbrains.jewel.IntelliJThemeIconData
+import org.jetbrains.jewel.PaletteMapper
+
+object StandalonePaletteMapperFactory : PaletteMapperFactory() {
+
+    // Extracted from com.intellij.ide.ui.UITheme#colorPalette
+    private val colorsToMap = mapOf(
+        "Actions.Red" to "#DB5860",
+        "Actions.Red.Dark" to "#C75450",
+        "Actions.Yellow" to "#EDA200",
+        "Actions.Yellow.Dark" to "#F0A732",
+        "Actions.Green" to "#59A869",
+        "Actions.Green.Dark" to "#499C54",
+        "Actions.Blue" to "#389FD6",
+        "Actions.Blue.Dark" to "#3592C4",
+        "Actions.Grey" to "#6E6E6E",
+        "Actions.Grey.Dark" to "#AFB1B3",
+        "Actions.GreyInline" to "#7F8B91",
+        "Actions.GreyInline.Dark" to "#7F8B91",
+        "Objects.Grey" to "#9AA7B0",
+        "Objects.Blue" to "#40B6E0",
+        "Objects.Green" to "#62B543",
+        "Objects.Yellow" to "#F4AF3D",
+        "Objects.YellowDark" to "#D9A343",
+        "Objects.Purple" to "#B99BF8",
+        "Objects.Pink" to "#F98B9E",
+        "Objects.Red" to "#F26522",
+        "Objects.RedStatus" to "#E05555",
+        "Objects.GreenAndroid" to "#3DDC84",
+        "Objects.BlackText" to "#231F20",
+        "Checkbox.Background.Default" to "#FFFFFF",
+        "Checkbox.Background.Default.Dark" to "#43494A",
+        "Checkbox.Background.Disabled" to "#F2F2F2",
+        "Checkbox.Background.Disabled.Dark" to "#3C3F41",
+        "Checkbox.Border.Default" to "#b0b0b0",
+        "Checkbox.Border.Default.Dark" to "#6B6B6B",
+        "Checkbox.Border.Disabled" to "#BDBDBD",
+        "Checkbox.Border.Disabled.Dark" to "#545556",
+        "Checkbox.Focus.Thin.Default" to "#7B9FC7",
+        "Checkbox.Focus.Thin.Default.Dark" to "#466D94",
+        "Checkbox.Focus.Wide" to "#97C3F3",
+        "Checkbox.Focus.Wide.Dark" to "#3D6185",
+        "Checkbox.Foreground.Disabled" to "#ABABAB",
+        "Checkbox.Foreground.Disabled.Dark" to "#606060",
+        "Checkbox.Background.Selected" to "#4F9EE3",
+        "Checkbox.Background.Selected.Dark" to "#43494A",
+        "Checkbox.Border.Selected" to "#4B97D9",
+        "Checkbox.Border.Selected.Dark" to "#6B6B6B",
+        "Checkbox.Foreground.Selected" to "#FEFEFE",
+        "Checkbox.Foreground.Selected.Dark" to "#A7A7A7",
+        "Checkbox.Focus.Thin.Selected" to "#ACCFF7",
+        "Checkbox.Focus.Thin.Selected.Dark" to "#466D94",
+        "Tree.iconColor" to "#808080",
+        "Tree.iconColor.Dark" to "#AFB1B3",
+    )
+
+    fun create(
+        isDark: Boolean,
+        iconData: IntelliJThemeIconData,
+        colorPalette: IntelliJThemeColorPalette,
+    ): PaletteMapper =
+        createInternal(
+            iconColorPalette = iconData.colorPalette,
+            keyPalette = colorsToMap,
+            themeColors = colorPalette.rawMap.asColorStringsMap(),
+            isDark = isDark,
+        )
+
+    private fun Map<String, Color>.asColorStringsMap() =
+        mapValues { (_, color) ->
+            "#${color.toArgb().toString(16).padStart(6, '0')}"
+        }
+
+    override fun logInfo(message: String) {
+        println("[${javaClass.simpleName}] $message")
+    }
+}
diff --git a/ide-laf-bridge/src/main/kotlin/org/jetbrains/jewel/bridge/BridgeIconData.kt b/ide-laf-bridge/src/main/kotlin/org/jetbrains/jewel/bridge/BridgeIconData.kt
index 120646adf..3c69af4a1 100644
--- a/ide-laf-bridge/src/main/kotlin/org/jetbrains/jewel/bridge/BridgeIconData.kt
+++ b/ide-laf-bridge/src/main/kotlin/org/jetbrains/jewel/bridge/BridgeIconData.kt
@@ -1,12 +1,14 @@
 package org.jetbrains.jewel.bridge
 
 import androidx.compose.runtime.Immutable
+import com.intellij.ide.ui.UITheme
 import org.jetbrains.jewel.IntelliJThemeIconData
 
 @Immutable
 internal class BridgeIconData(
     override val iconOverrides: Map<String, String>,
     override val colorPalette: Map<String, String>,
+    override val selectionColorPalette: Map<String, String>,
 ) : IntelliJThemeIconData {
 
     override fun equals(other: Any?): Boolean {
@@ -17,6 +19,7 @@ internal class BridgeIconData(
 
         if (iconOverrides != other.iconOverrides) return false
         if (colorPalette != other.colorPalette) return false
+        if (selectionColorPalette != other.selectionColorPalette) return false
 
         return true
     }
@@ -24,15 +27,23 @@ internal class BridgeIconData(
     override fun hashCode(): Int {
         var result = iconOverrides.hashCode()
         result = 31 * result + colorPalette.hashCode()
+        result = 31 * result + selectionColorPalette.hashCode()
         return result
     }
 
     override fun toString(): String =
-        "BridgeIconData(iconOverrides=$iconOverrides, colorPalette=$colorPalette)"
+        "BridgeIconData(iconOverrides=$iconOverrides, colorPalette=$colorPalette, " +
+            "selectionColorPalette=$selectionColorPalette)"
 
     companion object {
 
-        // TODO retrieve icon data from Swing
-        fun readFromLaF() = BridgeIconData(emptyMap(), emptyMap())
+        fun readFromLaF(): BridgeIconData {
+            val uiTheme = currentUiThemeOrNull()
+            val iconMap = uiTheme?.icons.orEmpty()
+            val selectedIconColorPalette = uiTheme?.selectedIconColorPalette.orEmpty()
+
+            val colorPalette = UITheme.getColorPalette()
+            return BridgeIconData(iconMap, colorPalette, selectedIconColorPalette)
+        }
     }
 }
diff --git a/ide-laf-bridge/src/main/kotlin/org/jetbrains/jewel/bridge/BridgeIconMapper.kt b/ide-laf-bridge/src/main/kotlin/org/jetbrains/jewel/bridge/BridgeIconMapper.kt
new file mode 100644
index 000000000..0c3c245a5
--- /dev/null
+++ b/ide-laf-bridge/src/main/kotlin/org/jetbrains/jewel/bridge/BridgeIconMapper.kt
@@ -0,0 +1,60 @@
+package org.jetbrains.jewel.bridge
+
+import androidx.compose.ui.res.ResourceLoader
+import com.intellij.openapi.diagnostic.thisLogger
+import com.intellij.util.ui.DirProvider
+import org.jetbrains.jewel.ClassLoaderProvider
+import org.jetbrains.jewel.IntelliJThemeIconData
+
+internal object BridgeIconMapper : IconMapper {
+
+    private val logger = thisLogger()
+
+    private val dirProvider = DirProvider()
+
+    override fun mapPath(
+        originalPath: String,
+        iconData: IntelliJThemeIconData,
+        resourceLoader: ResourceLoader,
+    ): String {
+        val classLoaders = (resourceLoader as? ClassLoaderProvider)?.classLoaders
+        if (classLoaders == null) {
+            logger.warn(
+                "Tried loading a resource but the provided ResourceLoader is now a JewelResourceLoader; " +
+                    "this is probably a bug. Make sure you always use JewelResourceLoaders.",
+            )
+            return originalPath
+        }
+
+        val clazz = Class.forName("com.intellij.ui.icons.CachedImageIconKt")
+        val patchIconPath = clazz.getMethod("patchIconPath", String::class.java, ClassLoader::class.java)
+        patchIconPath.isAccessible = true
+
+        // For all provided classloaders, we try to get the patched path, both using
+        // the original path, and an "abridged" path that has gotten the icon path prefix
+        // removed (the classloader is set up differently in prod IDEs and when running
+        // from Gradle, and the icon could be in either place depending on the environment)
+        val fallbackPath = originalPath.removePrefix(dirProvider.dir())
+        val patchedPath = classLoaders.firstNotNullOfOrNull { classLoader ->
+            val patchedPathAndClassLoader =
+                patchIconPath.invoke(null, originalPath.removePrefix("/"), classLoader)
+                    ?: patchIconPath.invoke(null, fallbackPath, classLoader)
+            patchedPathAndClassLoader as? Pair<*, *>
+        }?.first as? String
+
+        val path = if (patchedPath != null) {
+            logger.info("Found icon mapping: '$originalPath' -> '$patchedPath'")
+            patchedPath
+        } else {
+            logger.debug("Icon '$originalPath' has no available mapping")
+            originalPath
+        }
+
+        val overriddenPath = iconData.iconOverrides[path] ?: path
+        if (overriddenPath != path) {
+            logger.info("Found theme icon override: '$path' -> '$overriddenPath'")
+        }
+
+        return overriddenPath
+    }
+}
diff --git a/ide-laf-bridge/src/main/kotlin/org/jetbrains/jewel/bridge/BridgePaletteMapperFactory.kt b/ide-laf-bridge/src/main/kotlin/org/jetbrains/jewel/bridge/BridgePaletteMapperFactory.kt
new file mode 100644
index 000000000..3d902a98d
--- /dev/null
+++ b/ide-laf-bridge/src/main/kotlin/org/jetbrains/jewel/bridge/BridgePaletteMapperFactory.kt
@@ -0,0 +1,27 @@
+package org.jetbrains.jewel.bridge
+
+import com.intellij.ide.ui.UITheme
+import com.intellij.openapi.diagnostic.thisLogger
+import org.jetbrains.jewel.PaletteMapper
+import org.jetbrains.jewel.themes.PaletteMapperFactory
+
+object BridgePaletteMapperFactory : PaletteMapperFactory() {
+
+    private val logger = thisLogger()
+
+    fun create(isDark: Boolean): PaletteMapper {
+        // If we can't read the current theme, no mapping is possible
+        val uiTheme = currentUiThemeOrNull() ?: return PaletteMapper.Empty
+        logger.info("Parsing theme info from theme ${uiTheme.name} (id: ${uiTheme.id}, isDark: ${uiTheme.isDark})")
+
+        val iconColorPalette = uiTheme.iconColorPalette
+        val keyPalette = UITheme.getColorPalette()
+        val themeColors = uiTheme.colors.orEmpty()
+
+        return createInternal(iconColorPalette, keyPalette, themeColors, isDark)
+    }
+
+    override fun logInfo(message: String) {
+        logger.info(message)
+    }
+}
diff --git a/ide-laf-bridge/src/main/kotlin/org/jetbrains/jewel/bridge/BridgeResourceLoader.kt b/ide-laf-bridge/src/main/kotlin/org/jetbrains/jewel/bridge/BridgeResourceLoader.kt
new file mode 100644
index 000000000..e070efdec
--- /dev/null
+++ b/ide-laf-bridge/src/main/kotlin/org/jetbrains/jewel/bridge/BridgeResourceLoader.kt
@@ -0,0 +1,25 @@
+package org.jetbrains.jewel.bridge
+
+import com.intellij.util.ui.DirProvider
+import org.jetbrains.jewel.ClassLoaderProvider
+import org.jetbrains.jewel.JewelResourceLoader
+import java.io.InputStream
+
+object BridgeResourceLoader : JewelResourceLoader(), ClassLoaderProvider {
+
+    private val dirProvider = DirProvider()
+
+    override val classLoaders
+        get() = listOf(dirProvider::class.java.classLoader, javaClass.classLoader)
+
+    override fun load(resourcePath: String): InputStream {
+        val normalizedPath = resourcePath.removePrefix("/")
+        val fallbackPath = resourcePath.removePrefix(dirProvider.dir())
+        val resource = loadResourceOrNull(normalizedPath, classLoaders)
+            ?: loadResourceOrNull(fallbackPath, classLoaders)
+
+        return requireNotNull(resource) {
+            "Resource '$resourcePath' not found (tried using '$normalizedPath' and '$fallbackPath')"
+        }
+    }
+}
diff --git a/ide-laf-bridge/src/main/kotlin/org/jetbrains/jewel/bridge/IntelliJResourcePainterProvider.kt b/ide-laf-bridge/src/main/kotlin/org/jetbrains/jewel/bridge/BridgeResourcePainterProvider.kt
similarity index 57%
rename from ide-laf-bridge/src/main/kotlin/org/jetbrains/jewel/bridge/IntelliJResourcePainterProvider.kt
rename to ide-laf-bridge/src/main/kotlin/org/jetbrains/jewel/bridge/BridgeResourcePainterProvider.kt
index 671328835..82c271645 100644
--- a/ide-laf-bridge/src/main/kotlin/org/jetbrains/jewel/bridge/IntelliJResourcePainterProvider.kt
+++ b/ide-laf-bridge/src/main/kotlin/org/jetbrains/jewel/bridge/BridgeResourcePainterProvider.kt
@@ -2,6 +2,7 @@ package org.jetbrains.jewel.bridge
 
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.res.ResourceLoader
+import org.jetbrains.jewel.IntelliJThemeIconData
 import org.jetbrains.jewel.InteractiveComponentState
 import org.jetbrains.jewel.InternalJewelApi
 import org.jetbrains.jewel.SvgLoader
@@ -11,27 +12,39 @@ import org.jetbrains.jewel.styling.SimpleResourcePathPatcher
 import org.jetbrains.jewel.styling.StatefulResourcePathPatcher
 
 @OptIn(InternalJewelApi::class)
-class IntelliJResourcePainterProvider<T> @InternalJewelApi constructor(
+internal class BridgeResourcePainterProvider<T> @InternalJewelApi constructor(
     basePath: String,
     svgLoader: SvgLoader,
     pathPatcher: ResourcePathPatcher<T>,
     private val iconMapper: IconMapper,
+    private val iconData: IntelliJThemeIconData,
 ) : ResourcePainterProvider<T>(basePath, svgLoader, pathPatcher) {
 
     @Composable
-    override fun patchPath(basePath: String, resourceLoader: ResourceLoader, extraData: T?): String {
+    override fun patchPath(
+        basePath: String,
+        resourceLoader: ResourceLoader,
+        extraData: T?,
+    ): String {
         val patchedPath = super.patchPath(basePath, resourceLoader, extraData)
-        return iconMapper.mapPath(patchedPath, resourceLoader)
+        return iconMapper.mapPath(patchedPath, iconData, resourceLoader)
     }
 
-    companion object {
+    companion object Factory {
 
-        fun stateless(basePath: String, svgLoader: SvgLoader) =
-            IntelliJResourcePainterProvider<Unit>(basePath, svgLoader, SimpleResourcePathPatcher(), IntelliJIconMapper)
+        fun stateless(basePath: String, svgLoader: SvgLoader, iconData: IntelliJThemeIconData) =
+            BridgeResourcePainterProvider<Unit>(
+                basePath,
+                svgLoader,
+                SimpleResourcePathPatcher(),
+                BridgeIconMapper,
+                iconData,
+            )
 
         fun <T : InteractiveComponentState> stateful(
-            basePath: String,
+            iconPath: String,
             svgLoader: SvgLoader,
+            iconData: IntelliJThemeIconData,
             prefixTokensProvider: (state: T) -> String = { "" },
             suffixTokensProvider: (state: T) -> String = { "" },
             pathPatcher: ResourcePathPatcher<T> = StatefulResourcePathPatcher(
@@ -39,6 +52,6 @@ class IntelliJResourcePainterProvider<T> @InternalJewelApi constructor(
                 suffixTokensProvider,
             ),
         ) =
-            IntelliJResourcePainterProvider(basePath, svgLoader, pathPatcher, IntelliJIconMapper)
+            BridgeResourcePainterProvider(iconPath, svgLoader, pathPatcher, BridgeIconMapper, iconData)
     }
 }
diff --git a/ide-laf-bridge/src/main/kotlin/org/jetbrains/jewel/bridge/BridgeThemeColorPalette.kt b/ide-laf-bridge/src/main/kotlin/org/jetbrains/jewel/bridge/BridgeThemeColorPalette.kt
index 88d2218b0..d96efce07 100644
--- a/ide-laf-bridge/src/main/kotlin/org/jetbrains/jewel/bridge/BridgeThemeColorPalette.kt
+++ b/ide-laf-bridge/src/main/kotlin/org/jetbrains/jewel/bridge/BridgeThemeColorPalette.kt
@@ -2,13 +2,16 @@ package org.jetbrains.jewel.bridge
 
 import androidx.compose.runtime.Immutable
 import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.isSpecified
 import com.intellij.openapi.diagnostic.Logger
 import org.jetbrains.jewel.themes.intui.core.IntUiThemeColorPalette
+import java.util.TreeMap
 
 private val logger = Logger.getInstance("BridgeThemeColorPalette")
 
 @Immutable
-class BridgeThemeColorPalette(
+class BridgeThemeColorPalette private constructor(
+    override val rawMap: Map<String, Color>,
     private val grey: List<Color>,
     private val blue: List<Color>,
     private val green: List<Color>,
@@ -17,6 +20,7 @@ class BridgeThemeColorPalette(
     private val orange: List<Color>,
     private val purple: List<Color>,
     private val teal: List<Color>,
+    private val windowsPopupBorder: Color,
 ) : IntUiThemeColorPalette {
 
     override fun grey(): List<Color> = grey
@@ -53,18 +57,44 @@ class BridgeThemeColorPalette(
 
     companion object {
 
-        fun readFromLaF() = BridgeThemeColorPalette(
-            grey = readPaletteColors("Grey"),
-            blue = readPaletteColors("Blue"),
-            green = readPaletteColors("Green"),
-            red = readPaletteColors("Red"),
-            yellow = readPaletteColors("Yellow"),
-            orange = readPaletteColors("Orange"),
-            purple = readPaletteColors("Purple"),
-            teal = readPaletteColors("Teal"),
-        )
-
-        private fun readPaletteColors(colorName: String): List<Color> {
+        fun readFromLaF(): BridgeThemeColorPalette {
+            val grey = readPaletteColors("Grey")
+            val blue = readPaletteColors("Blue")
+            val green = readPaletteColors("Green")
+            val red = readPaletteColors("Red")
+            val yellow = readPaletteColors("Yellow")
+            val orange = readPaletteColors("Orange")
+            val purple = readPaletteColors("Purple")
+            val teal = readPaletteColors("Teal")
+            val windowsPopupBorder = readPaletteColor("windowsPopupBorder")
+
+            val rawMap = buildMap<String, Color> {
+                putAll(grey)
+                putAll(blue)
+                putAll(green)
+                putAll(red)
+                putAll(yellow)
+                putAll(orange)
+                putAll(purple)
+                putAll(teal)
+                if (windowsPopupBorder.isSpecified) put("windowsPopupBorder", windowsPopupBorder)
+            }
+
+            return BridgeThemeColorPalette(
+                grey = grey.values.toList(),
+                blue = blue.values.toList(),
+                green = green.values.toList(),
+                red = red.values.toList(),
+                yellow = yellow.values.toList(),
+                orange = orange.values.toList(),
+                purple = purple.values.toList(),
+                teal = teal.values.toList(),
+                windowsPopupBorder = windowsPopupBorder,
+                rawMap = rawMap,
+            )
+        }
+
+        private fun readPaletteColors(colorName: String): Map<String, Color> {
             val defaults = uiDefaults
             val allKeys = defaults.keys
             val colorNameKeyPrefix = "ColorPalette.$colorName"
@@ -77,19 +107,27 @@ class BridgeThemeColorPalette(
                     val afterName = it.substring(colorNameKeyPrefixLength)
                     afterName.toIntOrNull()
                 }
-                .maxOrNull() ?: return emptyList()
+                .maxOrNull() ?: return TreeMap()
 
-            return buildList {
+            return buildMap {
                 for (i in 1..lastColorIndex) {
-                    val value = defaults["$colorNameKeyPrefix$i"] as? java.awt.Color
+                    val key = "$colorNameKeyPrefix$i"
+                    val value = defaults[key] as? java.awt.Color
                     if (value == null) {
                         logger.error("Unable to find color value for palette key '$colorNameKeyPrefix$i'")
                         continue
                     }
 
-                    add(value.toComposeColor())
+                    put(key, value.toComposeColor())
                 }
             }
         }
+
+        private fun readPaletteColor(colorName: String): Color {
+            val defaults = uiDefaults
+            val colorNameKey = "ColorPalette.$colorName"
+            return (defaults[colorNameKey] as? java.awt.Color)
+                ?.toComposeColor() ?: Color.Unspecified
+        }
     }
 }
diff --git a/ide-laf-bridge/src/main/kotlin/org/jetbrains/jewel/bridge/BridgeUtils.kt b/ide-laf-bridge/src/main/kotlin/org/jetbrains/jewel/bridge/BridgeUtils.kt
index e6ee32764..9938d35a6 100644
--- a/ide-laf-bridge/src/main/kotlin/org/jetbrains/jewel/bridge/BridgeUtils.kt
+++ b/ide-laf-bridge/src/main/kotlin/org/jetbrains/jewel/bridge/BridgeUtils.kt
@@ -155,16 +155,24 @@ internal operator fun TextUnit.plus(delta: Float) =
         else -> this
     }
 
-internal fun <T : InteractiveComponentState> retrieveIcon(
-    baseIconPath: String,
-    iconData: IntelliJThemeIconData,
+internal fun <T : InteractiveComponentState> retrieveStatefulIcon(
+    iconPath: String,
     svgLoader: SvgLoader,
+    iconData: IntelliJThemeIconData,
     prefixTokensProvider: (state: T) -> String = { "" },
     suffixTokensProvider: (state: T) -> String = { "" },
 ): PainterProvider<T> =
-    IntelliJResourcePainterProvider.stateful(
-        basePath = iconData.iconOverrides[baseIconPath] ?: baseIconPath,
+    BridgeResourcePainterProvider.stateful(
+        iconPath = iconPath,
         svgLoader,
+        iconData,
         prefixTokensProvider,
         suffixTokensProvider,
     )
+
+internal fun retrieveStatelessIcon(
+    iconPath: String,
+    svgLoader: SvgLoader,
+    iconData: IntelliJThemeIconData,
+): PainterProvider<Unit> =
+    BridgeResourcePainterProvider.stateless(iconPath, svgLoader, iconData)
diff --git a/ide-laf-bridge/src/main/kotlin/org/jetbrains/jewel/bridge/ComposePanel.kt b/ide-laf-bridge/src/main/kotlin/org/jetbrains/jewel/bridge/ComposePanel.kt
index 0960dfc98..af0764830 100644
--- a/ide-laf-bridge/src/main/kotlin/org/jetbrains/jewel/bridge/ComposePanel.kt
+++ b/ide-laf-bridge/src/main/kotlin/org/jetbrains/jewel/bridge/ComposePanel.kt
@@ -11,4 +11,3 @@ fun ToolWindow.addComposeTab(
 ) = ComposePanel()
     .apply { setContent(content) }
     .also { contentManager.addContent(contentManager.factory.createContent(it, tabDisplayName, isLockable)) }
-
diff --git a/ide-laf-bridge/src/main/kotlin/org/jetbrains/jewel/bridge/IconMapper.kt b/ide-laf-bridge/src/main/kotlin/org/jetbrains/jewel/bridge/IconMapper.kt
index a8b94e902..da88ea8f6 100644
--- a/ide-laf-bridge/src/main/kotlin/org/jetbrains/jewel/bridge/IconMapper.kt
+++ b/ide-laf-bridge/src/main/kotlin/org/jetbrains/jewel/bridge/IconMapper.kt
@@ -1,8 +1,9 @@
 package org.jetbrains.jewel.bridge
 
 import androidx.compose.ui.res.ResourceLoader
+import org.jetbrains.jewel.IntelliJThemeIconData
 
 interface IconMapper {
 
-    fun mapPath(originalPath: String, resourceLoader: ResourceLoader): String
+    fun mapPath(originalPath: String, iconData: IntelliJThemeIconData, resourceLoader: ResourceLoader): String
 }
diff --git a/ide-laf-bridge/src/main/kotlin/org/jetbrains/jewel/bridge/IntUiBridge.kt b/ide-laf-bridge/src/main/kotlin/org/jetbrains/jewel/bridge/IntUiBridge.kt
index 1a572d831..5ffe23d04 100644
--- a/ide-laf-bridge/src/main/kotlin/org/jetbrains/jewel/bridge/IntUiBridge.kt
+++ b/ide-laf-bridge/src/main/kotlin/org/jetbrains/jewel/bridge/IntUiBridge.kt
@@ -263,10 +263,10 @@ private fun readCheckboxStyle(iconData: IntelliJThemeIconData, svgLoader: SvgLoa
             iconContentGap = 5.dp, // See DarculaCheckBoxUI#textIconGap
         ),
         icons = IntUiCheckboxIcons(
-            checkbox = retrieveIcon(
-                baseIconPath = "${iconsBasePath}checkBox.svg",
-                iconData = iconData,
+            checkbox = retrieveStatefulIcon(
+                iconPath = "${iconsBasePath}checkBox.svg",
                 svgLoader = svgLoader,
+                iconData = iconData,
                 prefixTokensProvider = { state: CheckboxState ->
                     if (state.toggleableState == ToggleableState.Indeterminate) "Indeterminate" else ""
                 },
@@ -381,8 +381,8 @@ private fun readDropdownStyle(
             borderWidth = DarculaUIUtil.BW.dp,
         ),
         icons = IntUiDropdownIcons(
-            chevronDown = retrieveIcon(
-                baseIconPath = "${iconsBasePath}general/chevron-down.svg",
+            chevronDown = retrieveStatefulIcon(
+                iconPath = "${iconsBasePath}general/chevron-down.svg",
                 iconData = iconData,
                 svgLoader = svgLoader,
             ),
@@ -497,13 +497,13 @@ private fun readLinkStyle(
             iconSize = DpSize.Unspecified,
         ),
         icons = IntUiLinkIcons(
-            dropdownChevron = retrieveIcon(
-                baseIconPath = "${iconsBasePath}general/chevron-down.svg",
+            dropdownChevron = retrieveStatefulIcon(
+                iconPath = "${iconsBasePath}general/chevron-down.svg",
                 iconData = iconData,
                 svgLoader = svgLoader,
             ),
-            externalLink = retrieveIcon(
-                baseIconPath = "${iconsBasePath}ide/external_link_arrow.svg",
+            externalLink = retrieveStatefulIcon(
+                iconPath = "${iconsBasePath}ide/external_link_arrow.svg",
                 iconData = iconData,
                 svgLoader = svgLoader,
             ),
@@ -571,8 +571,8 @@ private fun readMenuStyle(iconData: IntelliJThemeIconData, svgLoader: SvgLoader)
             ),
         ),
         icons = IntUiMenuIcons(
-            submenuChevron = retrieveIcon(
-                baseIconPath = "${iconsBasePath}general/chevron-down.svg",
+            submenuChevron = retrieveStatefulIcon(
+                iconPath = "${iconsBasePath}general/chevron-down.svg",
                 iconData = iconData,
                 svgLoader = svgLoader,
             ),
@@ -599,8 +599,8 @@ private fun readRadioButtonStyle(iconData: IntelliJThemeIconData, svgLoader: Svg
             iconContentGap = retrieveIntAsDpOrUnspecified("RadioButton.textIconGap").takeOrElse { 4.dp },
         ),
         icons = IntUiRadioButtonIcons(
-            radioButton = retrieveIcon(
-                baseIconPath = "${iconsBasePath}darcula/radio.svg",
+            radioButton = retrieveStatefulIcon(
+                iconPath = "${iconsBasePath}radio.svg",
                 iconData = iconData,
                 svgLoader = svgLoader,
             ),
@@ -716,6 +716,7 @@ private fun readLazyTreeStyle(iconData: IntelliJThemeIconData, svgLoader: SvgLoa
     val normalContent = retrieveColorOrUnspecified("Tree.foreground")
     val selectedContent = retrieveColorOrUnspecified("Tree.selectionForeground")
     val selectedElementBackground = retrieveColorOrUnspecified("Tree.selectionBackground")
+    val inactiveSelectedElementBackground = retrieveColorOrUnspecified("Tree.selectionInactiveBackground")
 
     val colors = IntUiLazyTreeColors(
         content = normalContent,
@@ -723,15 +724,26 @@ private fun readLazyTreeStyle(iconData: IntelliJThemeIconData, svgLoader: SvgLoa
         contentSelected = selectedContent,
         contentSelectedFocused = selectedContent,
         elementBackgroundFocused = Color.Transparent,
-        elementBackgroundSelected = selectedElementBackground,
+        elementBackgroundSelected = inactiveSelectedElementBackground,
         elementBackgroundSelectedFocused = selectedElementBackground,
     )
 
+    val chevronCollapsed = retrieveStatelessIcon(
+        iconPath = "${iconsBasePath}general/chevron-right.svg",
+        iconData = iconData,
+        svgLoader = svgLoader,
+    )
+    val chevronExpanded = retrieveStatelessIcon(
+        iconPath = "${iconsBasePath}general/chevron-down.svg",
+        iconData = iconData,
+        svgLoader = svgLoader,
+    )
+
     return IntUiLazyTreeStyle(
         colors = colors,
         metrics = IntUiLazyTreeMetrics(
             indentSize = retrieveIntAsDpOrUnspecified("Tree.leftChildIndent").takeOrElse { 7.dp } +
-                    retrieveIntAsDpOrUnspecified("Tree.rightChildIndent").takeOrElse { 11.dp },
+                retrieveIntAsDpOrUnspecified("Tree.rightChildIndent").takeOrElse { 11.dp },
             elementBackgroundCornerSize = CornerSize(JBUI.CurrentTheme.Tree.ARC.dp / 2),
             elementPadding = PaddingValues(horizontal = 12.dp),
             elementContentPadding = PaddingValues(4.dp),
@@ -739,16 +751,10 @@ private fun readLazyTreeStyle(iconData: IntelliJThemeIconData, svgLoader: SvgLoa
             chevronContentGap = 2.dp, // See com.intellij.ui.tree.ui.ClassicPainter.GAP
         ),
         icons = IntUiLazyTreeIcons(
-            nodeChevronCollapsed = retrieveIcon(
-                baseIconPath = "${iconsBasePath}general/chevron-right.svg",
-                iconData = iconData,
-                svgLoader = svgLoader,
-            ),
-            nodeChevronExpanded = retrieveIcon(
-                baseIconPath = "${iconsBasePath}general/chevron-down.svg",
-                iconData = iconData,
-                svgLoader = svgLoader,
-            ),
+            chevronCollapsed = chevronCollapsed,
+            chevronExpanded = chevronExpanded,
+            chevronSelectedCollapsed = chevronCollapsed,
+            chevronSelectedExpanded = chevronExpanded,
         ),
     )
 }
@@ -790,8 +796,8 @@ private fun readDefaultTabStyle(iconData: IntelliJThemeIconData, svgLoader: SvgL
             tabHeight = retrieveIntAsDpOrUnspecified("TabbedPane.tabHeight").takeOrElse { 24.dp },
         ),
         icons = IntUiTabIcons(
-            close = retrieveIcon(
-                baseIconPath = "${iconsBasePath}expui/general/closeSmall.svg",
+            close = retrieveStatefulIcon(
+                iconPath = "${iconsBasePath}expui/general/closeSmall.svg",
                 iconData = iconData,
                 svgLoader = svgLoader,
             ),
@@ -849,8 +855,8 @@ private fun readEditorTabStyle(iconData: IntelliJThemeIconData, svgLoader: SvgLo
             tabHeight = retrieveIntAsDpOrUnspecified("TabbedPane.tabHeight").takeOrElse { 24.dp },
         ),
         icons = IntUiTabIcons(
-            close = retrieveIcon(
-                baseIconPath = "${iconsBasePath}expui/general/closeSmall.svg",
+            close = retrieveStatefulIcon(
+                iconPath = "${iconsBasePath}expui/general/closeSmall.svg",
                 iconData = iconData,
                 svgLoader = svgLoader,
             ),
diff --git a/ide-laf-bridge/src/main/kotlin/org/jetbrains/jewel/bridge/IntelliJIconMapper.kt b/ide-laf-bridge/src/main/kotlin/org/jetbrains/jewel/bridge/IntelliJIconMapper.kt
deleted file mode 100644
index 29a2a6d3b..000000000
--- a/ide-laf-bridge/src/main/kotlin/org/jetbrains/jewel/bridge/IntelliJIconMapper.kt
+++ /dev/null
@@ -1,44 +0,0 @@
-package org.jetbrains.jewel.bridge
-
-import androidx.compose.ui.res.ResourceLoader
-import com.intellij.ide.ui.IconMapLoader
-import com.intellij.openapi.components.service
-import com.intellij.openapi.diagnostic.thisLogger
-import org.jetbrains.jewel.JewelResourceLoader
-
-object IntelliJIconMapper : IconMapper {
-
-    private val logger = thisLogger()
-
-    private val mappingsByClassLoader
-        get() = service<IconMapLoader>().loadIconMapping()
-
-    override fun mapPath(originalPath: String, resourceLoader: ResourceLoader): String {
-        logger.debug("Loading SVG from '$originalPath'")
-        val searchClasses = (resourceLoader as? JewelResourceLoader)?.searchClasses
-        if (searchClasses == null) {
-            logger.warn(
-                "Tried loading a resource but the provided ResourceLoader is now a JewelResourceLoader; " +
-                    "this is probably a bug. Make sure you always use JewelResourceLoaders.",
-            )
-            return originalPath
-        }
-
-        val allMappings = mappingsByClassLoader
-        if (allMappings.isEmpty()) {
-            logger.info("No mapping info available yet, can't check for '$originalPath' mapping.")
-            return originalPath
-        }
-
-        val applicableMappings = searchClasses.mapNotNull { allMappings[it.classLoader] }
-        val mappedPath = applicableMappings.firstNotNullOfOrNull { it[originalPath.removePrefix("/")] }
-
-        if (mappedPath == null) {
-            logger.debug("Icon '$originalPath' has no mapping defined.")
-            return originalPath
-        }
-
-        logger.debug("Icon '$originalPath' is mapped to '$mappedPath'.")
-        return mappedPath
-    }
-}
diff --git a/ide-laf-bridge/src/main/kotlin/org/jetbrains/jewel/bridge/SwingBridgeService.kt b/ide-laf-bridge/src/main/kotlin/org/jetbrains/jewel/bridge/SwingBridgeService.kt
index aeb2e0f98..3858d684b 100644
--- a/ide-laf-bridge/src/main/kotlin/org/jetbrains/jewel/bridge/SwingBridgeService.kt
+++ b/ide-laf-bridge/src/main/kotlin/org/jetbrains/jewel/bridge/SwingBridgeService.kt
@@ -10,16 +10,17 @@ import kotlinx.coroutines.CoroutineName
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.SupervisorJob
 import kotlinx.coroutines.cancel
+import kotlinx.coroutines.delay
 import kotlinx.coroutines.flow.SharingStarted
 import kotlinx.coroutines.flow.StateFlow
-import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.flow.mapLatest
 import kotlinx.coroutines.flow.stateIn
 import org.jetbrains.jewel.IntelliJComponentStyling
-import org.jetbrains.jewel.IntelliJSvgLoader
+import org.jetbrains.jewel.JewelSvgLoader
 import org.jetbrains.jewel.SvgLoader
-import org.jetbrains.jewel.themes.PaletteMapperFactory
 import org.jetbrains.jewel.themes.intui.core.IntUiThemeDefinition
 import org.jetbrains.jewel.themes.intui.core.IntelliJSvgPatcher
+import kotlin.time.Duration.Companion.milliseconds
 
 @Service(Level.APP)
 class SwingBridgeService : Disposable {
@@ -33,9 +34,20 @@ class SwingBridgeService : Disposable {
     // TODO we shouldn't assume it's Int UI, but we only have that for now
     internal val currentBridgeThemeData: StateFlow<BridgeThemeData> =
         IntelliJApplication.lookAndFeelChangedFlow(coroutineScope)
-            .map { readThemeData() }
+            .mapLatest { getThemeData() }
             .stateIn(coroutineScope, SharingStarted.Eagerly, BridgeThemeData.DEFAULT)
 
+    private suspend fun getThemeData(): BridgeThemeData {
+        var counter = 0
+        while (counter < 20) {
+            delay(20.milliseconds)
+            counter++
+            runCatching { readThemeData() }
+                .onSuccess { return it }
+        }
+        return readThemeData()
+    }
+
     private suspend fun readThemeData(): BridgeThemeData {
         val isIntUi = NewUI.isEnabled()
         if (!isIntUi) {
@@ -86,7 +98,7 @@ class SwingBridgeService : Disposable {
 }
 
 private fun createSvgLoader(theme: IntUiThemeDefinition): SvgLoader {
-    val paletteMapper = PaletteMapperFactory.create(theme.isDark, theme.iconData, theme.colorPalette)
+    val paletteMapper = BridgePaletteMapperFactory.create(theme.isDark)
     val svgPatcher = IntelliJSvgPatcher(paletteMapper)
-    return IntelliJSvgLoader(svgPatcher)
+    return JewelSvgLoader(svgPatcher)
 }
diff --git a/ide-laf-bridge/src/main/kotlin/org/jetbrains/jewel/bridge/SwingBridgeTheme.kt b/ide-laf-bridge/src/main/kotlin/org/jetbrains/jewel/bridge/SwingBridgeTheme.kt
index 5182b5243..4b96f03dc 100644
--- a/ide-laf-bridge/src/main/kotlin/org/jetbrains/jewel/bridge/SwingBridgeTheme.kt
+++ b/ide-laf-bridge/src/main/kotlin/org/jetbrains/jewel/bridge/SwingBridgeTheme.kt
@@ -4,12 +4,9 @@ import androidx.compose.runtime.Composable
 import androidx.compose.runtime.CompositionLocalProvider
 import androidx.compose.runtime.collectAsState
 import androidx.compose.runtime.getValue
-import androidx.compose.ui.res.ResourceLoader
 import com.intellij.openapi.components.service
-import com.intellij.util.ui.DirProvider
 import org.jetbrains.jewel.ExperimentalJewelApi
 import org.jetbrains.jewel.LocalResourceLoader
-import org.jetbrains.jewel.themes.intui.standalone.IntUiDefaultResourceLoader
 import org.jetbrains.jewel.themes.intui.standalone.IntUiTheme
 
 private val bridgeService = service<SwingBridgeService>()
@@ -21,18 +18,8 @@ fun SwingBridgeTheme(content: @Composable () -> Unit) {
 
     // TODO handle non-Int UI themes, too
     IntUiTheme(themeData.themeDefinition, themeData.componentStyling, swingCompatMode = true) {
-        CompositionLocalProvider(LocalResourceLoader provides IntelliJResourceLoader) {
+        CompositionLocalProvider(LocalResourceLoader provides BridgeResourceLoader) {
             content()
         }
     }
 }
-
-object IntelliJResourceLoader : ResourceLoader {
-
-    private val dirProvider = DirProvider()
-
-    override fun load(resourcePath: String) =
-        IntUiDefaultResourceLoader.loadOrNull(resourcePath)
-            ?: IntUiDefaultResourceLoader.load(resourcePath.removePrefix(dirProvider.dir()))
-
-}
diff --git a/ide-laf-bridge/src/main/kotlin/org/jetbrains/jewel/bridge/UiThemeExtensions.kt b/ide-laf-bridge/src/main/kotlin/org/jetbrains/jewel/bridge/UiThemeExtensions.kt
new file mode 100644
index 000000000..44f60c996
--- /dev/null
+++ b/ide-laf-bridge/src/main/kotlin/org/jetbrains/jewel/bridge/UiThemeExtensions.kt
@@ -0,0 +1,42 @@
+package org.jetbrains.jewel.bridge
+
+import com.intellij.ide.ui.LafManager
+import com.intellij.ide.ui.UITheme
+import com.intellij.ide.ui.laf.UIThemeBasedLookAndFeelInfo
+import com.intellij.openapi.diagnostic.Logger
+import java.lang.reflect.Field
+
+private val logger = Logger.getInstance("UiThemeExtensions")
+
+private val classUITheme
+    get() = UITheme::class.java
+
+internal fun currentUiThemeOrNull() =
+    (LafManager.getInstance().currentLookAndFeel as? UIThemeBasedLookAndFeelInfo)?.theme
+
+internal val UITheme.icons: Map<String, String>
+    get() = readMapField<String>(classUITheme.getDeclaredField("icons"))
+        .filterKeys { it != "ColorPalette" }
+
+internal val UITheme.iconColorPalette: Map<String, String>
+    get() = readMapField<Map<String, String>>(classUITheme.getDeclaredField("icons"))
+        .get("ColorPalette").orEmpty()
+
+internal val UITheme.selectedIconColorPalette: Map<String, String>
+    get() = readMapField(classUITheme.getDeclaredField("iconColorsOnSelection"))
+
+private fun <T> UITheme.readMapField(field: Field): Map<String, T> {
+    @Suppress("DEPRECATION") // We don't have an alternative API to use
+    val wasAccessible = field.isAccessible
+    field.isAccessible = true
+
+    return try {
+        @Suppress("UNCHECKED_CAST")
+        (field.get(this) as? Map<String, T>).orEmpty()
+    } catch (e: IllegalAccessException) {
+        logger.warn("Error while retrieving LaF", e)
+        emptyMap()
+    } finally {
+        field.isAccessible = wasAccessible
+    }
+}
diff --git a/samples/ide-plugin/src/main/kotlin/org/jetbrains/jewel/samples/ideplugin/JewelDemoToolWindow.kt b/samples/ide-plugin/src/main/kotlin/org/jetbrains/jewel/samples/ideplugin/JewelDemoToolWindow.kt
index 9364f52f0..2e9d2a1a9 100644
--- a/samples/ide-plugin/src/main/kotlin/org/jetbrains/jewel/samples/ideplugin/JewelDemoToolWindow.kt
+++ b/samples/ide-plugin/src/main/kotlin/org/jetbrains/jewel/samples/ideplugin/JewelDemoToolWindow.kt
@@ -2,19 +2,25 @@ package org.jetbrains.jewel.samples.ideplugin
 
 import androidx.compose.foundation.background
 import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.RowScope
 import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
 import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.layout.width
 import androidx.compose.foundation.rememberScrollState
 import androidx.compose.foundation.verticalScroll
+import androidx.compose.runtime.Composable
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
 import androidx.compose.runtime.setValue
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
+import androidx.compose.ui.res.ResourceLoader
 import androidx.compose.ui.unit.dp
 import com.intellij.openapi.project.DumbAware
 import com.intellij.openapi.project.Project
@@ -25,13 +31,16 @@ import kotlinx.coroutines.ExperimentalCoroutinesApi
 import org.jetbrains.jewel.CheckboxRow
 import org.jetbrains.jewel.DefaultButton
 import org.jetbrains.jewel.ExperimentalJewelApi
+import org.jetbrains.jewel.LazyTree
 import org.jetbrains.jewel.LocalResourceLoader
 import org.jetbrains.jewel.OutlinedButton
+import org.jetbrains.jewel.RadioButtonRow
 import org.jetbrains.jewel.Text
 import org.jetbrains.jewel.TextField
 import org.jetbrains.jewel.bridge.SwingBridgeTheme
 import org.jetbrains.jewel.bridge.addComposeTab
 import org.jetbrains.jewel.bridge.toComposeColor
+import org.jetbrains.jewel.foundation.tree.buildTree
 import org.jetbrains.jewel.themes.intui.standalone.IntUiTheme
 
 @ExperimentalCoroutinesApi
@@ -45,55 +54,172 @@ internal class JewelDemoToolWindow : ToolWindowFactory, DumbAware {
                 val bgColor by remember(IntUiTheme.isDark) { mutableStateOf(JBColor.PanelBackground.toComposeColor()) }
 
                 val scrollState = rememberScrollState()
-                Column(
+                Row(
                     modifier = Modifier
                         .fillMaxSize()
                         .background(bgColor)
                         .verticalScroll(scrollState)
                         .padding(16.dp),
-                    verticalArrangement = Arrangement.spacedBy(16.dp),
+                    horizontalArrangement = Arrangement.spacedBy(16.dp),
                 ) {
-                    Text("Here is a selection of our finest components:")
-
-                    Row(
-                        horizontalArrangement = Arrangement.spacedBy(16.dp),
-                        verticalAlignment = Alignment.CenterVertically,
-                    ) {
-                        var clicks1 by remember { mutableStateOf(0) }
-                        OutlinedButton({ clicks1++ }) {
-                            Text("Outlined: $clicks1")
-                        }
-                        OutlinedButton({ }, enabled = false) {
-                            Text("Outlined")
-                        }
+                    ColumnOne(resourceLoader)
+                    ColumnTwo(resourceLoader)
+                }
+            }
+        }
+    }
 
-                        var clicks2 by remember { mutableStateOf(0) }
-                        DefaultButton({ clicks2++ }) {
-                            Text("Default: $clicks2")
-                        }
-                        DefaultButton({ }, enabled = false) {
-                            Text("Default")
+    @Composable
+    private fun ColumnOne(resourceLoader: ResourceLoader) {
+        Column(
+            verticalArrangement = Arrangement.spacedBy(16.dp),
+        ) {
+            Text("Here is a selection of our finest components:")
+
+            Row(
+                horizontalArrangement = Arrangement.spacedBy(16.dp),
+                verticalAlignment = Alignment.CenterVertically,
+            ) {
+                var clicks1 by remember { mutableStateOf(0) }
+                OutlinedButton({ clicks1++ }) {
+                    Text("Outlined: $clicks1")
+                }
+                OutlinedButton({ }, enabled = false) {
+                    Text("Outlined")
+                }
+
+                var clicks2 by remember { mutableStateOf(0) }
+                DefaultButton({ clicks2++ }) {
+                    Text("Default: $clicks2")
+                }
+                DefaultButton({ }, enabled = false) {
+                    Text("Default")
+                }
+            }
+
+            var textFieldValue by remember { mutableStateOf("") }
+            TextField(
+                value = textFieldValue,
+                onValueChange = { textFieldValue = it },
+                placeholder = { Text("Write something...") },
+                modifier = Modifier.width(200.dp),
+            )
+
+            var checked by remember { mutableStateOf(false) }
+            CheckboxRow(
+                checked = checked,
+                onCheckedChange = { checked = it },
+                resourceLoader = resourceLoader,
+            ) {
+                Text("Hello, I am a themed checkbox")
+            }
+
+            Row(horizontalArrangement = Arrangement.spacedBy(16.dp)) {
+                var index by remember { mutableStateOf(0) }
+                RadioButtonRow(selected = index == 0, resourceLoader, onClick = { index = 0 }) {
+                    Text("I am number one")
+                }
+                RadioButtonRow(selected = index == 1, resourceLoader, onClick = { index = 1 }) {
+                    Text("Sad second")
+                }
+            }
+        }
+    }
+
+    @Composable
+    private fun RowScope.ColumnOne(resourceLoader: ResourceLoader) {
+        Column(
+            Modifier.weight(1f),
+            verticalArrangement = Arrangement.spacedBy(16.dp),
+        ) {
+            Text("Here is a selection of our finest components:")
+
+            Row(
+                horizontalArrangement = Arrangement.spacedBy(16.dp),
+                verticalAlignment = Alignment.CenterVertically,
+            ) {
+                var clicks1 by remember { mutableStateOf(0) }
+                OutlinedButton({ clicks1++ }) {
+                    Text("Outlined: $clicks1")
+                }
+                OutlinedButton({ }, enabled = false) {
+                    Text("Outlined")
+                }
+
+                var clicks2 by remember { mutableStateOf(0) }
+                DefaultButton({ clicks2++ }) {
+                    Text("Default: $clicks2")
+                }
+                DefaultButton({ }, enabled = false) {
+                    Text("Default")
+                }
+            }
+
+            var textFieldValue by remember { mutableStateOf("") }
+            TextField(
+                value = textFieldValue,
+                onValueChange = { textFieldValue = it },
+                placeholder = { Text("Write something...") },
+                modifier = Modifier.width(200.dp),
+            )
+
+            var checked by remember { mutableStateOf(false) }
+            CheckboxRow(
+                checked = checked,
+                onCheckedChange = { checked = it },
+                resourceLoader = resourceLoader,
+            ) {
+                Text("Hello, I am a themed checkbox")
+            }
+
+            Row(horizontalArrangement = Arrangement.spacedBy(16.dp)) {
+                var index by remember { mutableStateOf(0) }
+                RadioButtonRow(selected = index == 0, resourceLoader, onClick = { index = 0 }) {
+                    Text("I am number one")
+                }
+                RadioButtonRow(selected = index == 1, resourceLoader, onClick = { index = 1 }) {
+                    Text("Sad second")
+                }
+            }
+        }
+    }
+
+    @Composable
+    private fun RowScope.ColumnTwo(resourceLoader: ResourceLoader) {
+        Column(
+            Modifier.weight(1f),
+            verticalArrangement = Arrangement.spacedBy(16.dp),
+        ) {
+            val tree = remember {
+                buildTree {
+                    addNode("root 1") {
+                        addLeaf("leaf 1")
+                        addLeaf("leaf 2")
+                    }
+                    addNode("root 2") {
+                        addLeaf("leaf 1")
+                        addNode("node 1") {
+                            addLeaf("leaf 1")
+                            addLeaf("leaf 2")
                         }
                     }
-
-                    var textFieldValue by remember { mutableStateOf("") }
-                    TextField(
-                        value = textFieldValue,
-                        onValueChange = { textFieldValue = it },
-                        placeholder = { Text("Write something...") },
-                        modifier = Modifier.width(200.dp),
-                    )
-
-                    var checked by remember { mutableStateOf(false) }
-                    CheckboxRow(
-                        checked = checked,
-                        onCheckedChange = { checked = it },
-                        resourceLoader = resourceLoader,
-                    ) {
-                        Text("Hello, I am a themed checkbox")
+                    addNode("root 3") {
+                        addLeaf("leaf 1")
+                        addLeaf("leaf 2")
                     }
                 }
             }
+            LazyTree(
+                tree = tree,
+                resourceLoader = resourceLoader,
+                modifier = Modifier.height(200.dp).fillMaxWidth(),
+                onElementClick = {},
+                onElementDoubleClick = {},
+            ) { element ->
+                Box(Modifier.fillMaxWidth()) {
+                    Text(element.data, Modifier.padding(2.dp))
+                }
+            }
         }
     }
 }
diff --git a/samples/standalone/src/main/kotlin/org/jetbrains/jewel/samples/standalone/Main.kt b/samples/standalone/src/main/kotlin/org/jetbrains/jewel/samples/standalone/Main.kt
index ec41aed91..e74a4230f 100644
--- a/samples/standalone/src/main/kotlin/org/jetbrains/jewel/samples/standalone/Main.kt
+++ b/samples/standalone/src/main/kotlin/org/jetbrains/jewel/samples/standalone/Main.kt
@@ -55,9 +55,9 @@ fun main() {
         var swingCompat by remember { mutableStateOf(false) }
         val theme = if (isDark) IntUiTheme.darkThemeDefinition() else IntUiTheme.lightThemeDefinition()
 
-        val resourceLoader = LocalResourceLoader.current
-
         IntUiTheme(theme, swingCompat) {
+            val resourceLoader = LocalResourceLoader.current
+
             val windowBackground = if (isDark) {
                 IntUiTheme.colorPalette.grey(1)
             } else {
diff --git a/samples/standalone/src/main/kotlin/org/jetbrains/jewel/samples/standalone/components/ChipsAndTree.kt b/samples/standalone/src/main/kotlin/org/jetbrains/jewel/samples/standalone/components/ChipsAndTree.kt
index 0f8b33e1c..6205145db 100644
--- a/samples/standalone/src/main/kotlin/org/jetbrains/jewel/samples/standalone/components/ChipsAndTree.kt
+++ b/samples/standalone/src/main/kotlin/org/jetbrains/jewel/samples/standalone/components/ChipsAndTree.kt
@@ -1,6 +1,7 @@
 package org.jetbrains.jewel.samples.standalone.components
 
 import androidx.compose.foundation.background
+import androidx.compose.foundation.border
 import androidx.compose.foundation.clickable
 import androidx.compose.foundation.focusable
 import androidx.compose.foundation.interaction.MutableInteractionSource
@@ -12,6 +13,7 @@ import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.layout.size
 import androidx.compose.foundation.layout.width
+import androidx.compose.foundation.shape.RoundedCornerShape
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableStateOf
@@ -28,22 +30,23 @@ import org.jetbrains.jewel.RadioButtonChip
 import org.jetbrains.jewel.Text
 import org.jetbrains.jewel.ToggleableChip
 import org.jetbrains.jewel.foundation.lazy.SelectableLazyColumn
-import org.jetbrains.jewel.foundation.tree.InitialNodeStatus
 import org.jetbrains.jewel.foundation.tree.buildTree
+import org.jetbrains.jewel.themes.intui.standalone.IntUiTheme
 
 @Composable
 fun ChipsAndTree() {
-    Row(Modifier.fillMaxWidth(), horizontalArrangement = Arrangement.SpaceBetween) {
-        Column {
-            GroupHeader(text = "Chips", modifier = Modifier.width(300.dp))
-            ChipsRow(Modifier.padding(8.dp))
+    Row(Modifier.fillMaxWidth(), horizontalArrangement = Arrangement.spacedBy(16.dp)) {
+        Column(Modifier.weight(1f), verticalArrangement = Arrangement.spacedBy(8.dp)) {
+            GroupHeader(text = "Chips", modifier = Modifier.fillMaxWidth())
+            ChipsSample(Modifier.padding(8.dp))
         }
-        Column {
-            GroupHeader("Tree", modifier = Modifier.width(300.dp))
+
+        Column(Modifier.weight(1f), verticalArrangement = Arrangement.spacedBy(8.dp)) {
+            GroupHeader("Tree", modifier = Modifier.fillMaxWidth())
             TreeSample()
         }
 
-        Column {
+        Column(Modifier.weight(1f), verticalArrangement = Arrangement.spacedBy(8.dp)) {
             GroupHeader("SelectableLazyColumn", modifier = Modifier.width(300.dp))
             SelectableLazyColumnSample()
         }
@@ -53,9 +56,7 @@ fun ChipsAndTree() {
 @Composable
 fun SelectableLazyColumnSample() {
     val listOfItems = remember {
-        (5000..10000).random().let { size ->
-            List(size) { "Item $it" }
-        }
+        List((5000..10000).random()) { "Item $it" }
     }
     val interactionSource = remember { MutableInteractionSource() }
     SelectableLazyColumn(
@@ -87,58 +88,63 @@ fun SelectableLazyColumnSample() {
 }
 
 @Composable
-fun ChipsRow(modifier: Modifier = Modifier) {
-    Row(modifier, horizontalArrangement = Arrangement.spacedBy(8.dp)) {
-        var selectedIndex by remember { mutableStateOf(-1) }
-        RadioButtonChip(
-            selected = selectedIndex == 0,
-            onClick = { selectedIndex = 0 },
-            enabled = true,
-        ) {
-            Text("First")
-        }
+fun ChipsSample(modifier: Modifier = Modifier) {
+    Column(modifier, verticalArrangement = Arrangement.spacedBy(8.dp)) {
+        Row(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
+            var selectedIndex by remember { mutableStateOf(-1) }
+            RadioButtonChip(
+                selected = selectedIndex == 0,
+                onClick = { selectedIndex = 0 },
+                enabled = true,
+            ) {
+                Text("First")
+            }
 
-        RadioButtonChip(
-            selected = selectedIndex == 1,
-            onClick = { selectedIndex = 1 },
-            enabled = true,
-        ) {
-            Text("Second")
-        }
+            RadioButtonChip(
+                selected = selectedIndex == 1,
+                onClick = { selectedIndex = 1 },
+                enabled = true,
+            ) {
+                Text("Second")
+            }
 
-        RadioButtonChip(
-            selected = selectedIndex == 2,
-            onClick = { selectedIndex = 2 },
-            enabled = true,
-        ) {
-            Text("Third")
-        }
-    }
-    Row(modifier, horizontalArrangement = Arrangement.spacedBy(8.dp)) {
-        var isChecked by remember { mutableStateOf(false) }
-        ToggleableChip(
-            checked = isChecked,
-            onClick = {
-                isChecked = it
-            },
-            enabled = true,
-        ) {
-            Text("Toggleable")
+            RadioButtonChip(
+                selected = selectedIndex == 2,
+                onClick = { selectedIndex = 2 },
+                enabled = true,
+            ) {
+                Text("Third")
+            }
         }
 
-        var count by remember { mutableStateOf(1) }
-        Chip(
-            enabled = true,
-            onClick = { count++ },
-        ) {
-            Text("Clicks: $count")
+        Row(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
+            var isChecked by remember { mutableStateOf(false) }
+            ToggleableChip(
+                checked = isChecked,
+                onClick = {
+                    isChecked = it
+                },
+                enabled = true,
+            ) {
+                Text("Toggleable")
+            }
+
+            var count by remember { mutableStateOf(1) }
+            Chip(
+                enabled = true,
+                onClick = { count++ },
+            ) {
+                Text("Clicks: $count")
+            }
         }
 
-        Chip(
-            enabled = false,
-            onClick = {},
-        ) {
-            Text("Disabled")
+        Row(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
+            Chip(
+                enabled = false,
+                onClick = {},
+            ) {
+                Text("Disabled")
+            }
         }
     }
 }
@@ -152,29 +158,38 @@ fun TreeSample(modifier: Modifier = Modifier) {
                 addLeaf("leaf 2")
             }
             addNode("root 2") {
-                addLeaf("leaf 1")
+                addLeaf("leaf 2.1")
                 addNode("node 1") {
-                    addLeaf("leaf 1")
-                    addLeaf("leaf 2")
+                    addLeaf("subleaf 1")
+                    addLeaf("subleaf 2")
                 }
             }
             addNode("root 3") {
-                addLeaf("leaf 1")
-                addLeaf("leaf 2")
+                addLeaf("leaf 3.1")
+                addLeaf("leaf 3.2")
             }
         }
     }
+
     val resourceLoader = LocalResourceLoader.current
-    LazyTree(
-        tree = tree,
-        initialNodeStatus = InitialNodeStatus.Open,
-        resourceLoader = resourceLoader,
-        modifier = Modifier.size(200.dp, 200.dp).then(modifier),
-        onElementClick = {},
-        onElementDoubleClick = {},
-    ) { element ->
-        Box(Modifier.fillMaxWidth()) {
-            Text(element.data, modifier.padding(2.dp))
+    val borderColor =
+        if (IntUiTheme.isDark) {
+            IntUiTheme.colorPalette.grey(3)
+        } else {
+            IntUiTheme.colorPalette.grey(12)
+        }
+
+    Box(modifier.border(1.dp, borderColor, RoundedCornerShape(2.dp))) {
+        LazyTree(
+            tree = tree,
+            resourceLoader = resourceLoader,
+            modifier = Modifier.size(200.dp, 200.dp),
+            onElementClick = {},
+            onElementDoubleClick = {},
+        ) { element ->
+            Box(Modifier.fillMaxWidth()) {
+                Text(element.data, Modifier.padding(2.dp))
+            }
         }
     }
 }
diff --git a/themes/int-ui/int-ui-core/src/main/kotlin/org/jetbrains/jewel/themes/intui/core/IntUiThemeColorPalette.kt b/themes/int-ui/int-ui-core/src/main/kotlin/org/jetbrains/jewel/themes/intui/core/IntUiThemeColorPalette.kt
index 9820621e2..3406ca601 100644
--- a/themes/int-ui/int-ui-core/src/main/kotlin/org/jetbrains/jewel/themes/intui/core/IntUiThemeColorPalette.kt
+++ b/themes/int-ui/int-ui-core/src/main/kotlin/org/jetbrains/jewel/themes/intui/core/IntUiThemeColorPalette.kt
@@ -92,7 +92,7 @@ internal object EmptyIntUiThemeColorPalette : IntUiThemeColorPalette {
 
     override fun teal(index: Int): Color = Color.Unspecified
 
-    override fun lookup(colorKey: String): Color? = null
+    override val rawMap: Map<String, Color> = emptyMap()
 }
 
 private val colorKeyRegex: Regex
diff --git a/themes/int-ui/int-ui-core/src/main/kotlin/org/jetbrains/jewel/themes/intui/core/IntelliJSvgPatcher.kt b/themes/int-ui/int-ui-core/src/main/kotlin/org/jetbrains/jewel/themes/intui/core/IntelliJSvgPatcher.kt
index 2a5da73d5..0fc82510e 100644
--- a/themes/int-ui/int-ui-core/src/main/kotlin/org/jetbrains/jewel/themes/intui/core/IntelliJSvgPatcher.kt
+++ b/themes/int-ui/int-ui-core/src/main/kotlin/org/jetbrains/jewel/themes/intui/core/IntelliJSvgPatcher.kt
@@ -25,35 +25,40 @@ class IntelliJSvgPatcher(private val mapper: PaletteMapper) : SvgPatcher {
     private val documentBuilderFactory = DocumentBuilderFactory.newDefaultInstance()
         .apply { setFeature(XMLConstants.FEATURE_SECURE_PROCESSING, true) }
 
-    override fun patchSvg(rawSvg: InputStream): String {
+    override fun patchSvg(rawSvg: InputStream, path: String?): String {
         val builder = documentBuilderFactory.newDocumentBuilder()
         val document = builder.parse(rawSvg)
-        document.documentElement.patchColors(mapper)
+
+        val scope = mapper.getScopeForPath(path)
+        if (scope != null) {
+            document.documentElement.patchColors(scope)
+        }
+
         return document.writeToString()
     }
 
-    private fun Element.patchColors(mapper: PaletteMapper) {
-        patchColorAttribute("fill", mapper)
-        patchColorAttribute("stroke", mapper)
+    private fun Element.patchColors(mapperScope: PaletteMapper.Scope) {
+        patchColorAttribute("fill", mapperScope)
+        patchColorAttribute("stroke", mapperScope)
 
         val nodes = childNodes
         val length = nodes.length
         for (i in 0 until length) {
             val item = nodes.item(i)
             if (item is Element) {
-                item.patchColors(mapper)
+                item.patchColors(mapperScope)
             }
         }
     }
 
-    private fun Element.patchColorAttribute(attrName: String, mapper: PaletteMapper) {
+    private fun Element.patchColorAttribute(attrName: String, mapperScope: PaletteMapper.Scope) {
         val color = getAttribute(attrName)
         val opacity = getAttribute("$attrName-opacity")
 
         if (color.isNotEmpty()) {
             val alpha = opacity.toFloatOrNull() ?: 1.0f
             val originalColor = tryParseColor(color, alpha) ?: return
-            val newColor = mapper.mapColorOrNull(originalColor) ?: return
+            val newColor = mapperScope.mapColorOrNull(originalColor) ?: return
             setAttribute(attrName, newColor.copy(alpha = alpha).toHexString())
         }
     }
diff --git a/themes/int-ui/int-ui-standalone/src/main/kotlin/org/jetbrains/jewel/themes/intui/standalone/IntUiDefaultResourceLoader.kt b/themes/int-ui/int-ui-standalone/src/main/kotlin/org/jetbrains/jewel/themes/intui/standalone/IntUiDefaultResourceLoader.kt
deleted file mode 100644
index 162b0cd77..000000000
--- a/themes/int-ui/int-ui-standalone/src/main/kotlin/org/jetbrains/jewel/themes/intui/standalone/IntUiDefaultResourceLoader.kt
+++ /dev/null
@@ -1,20 +0,0 @@
-package org.jetbrains.jewel.themes.intui.standalone
-
-import androidx.compose.ui.res.ResourceLoader
-import org.jetbrains.jewel.JewelResourceLoader
-import java.io.InputStream
-
-object IntUiDefaultResourceLoader : ResourceLoader, JewelResourceLoader {
-
-    override val searchClasses = listOf(IntUiTheme::class.java, IntUiDefaultResourceLoader::class.java)
-
-    override fun load(resourcePath: String): InputStream {
-        val resource = loadOrNull(resourcePath)
-        return requireNotNull(resource) { "Resource $resourcePath not found" }
-    }
-
-    fun loadOrNull(resourcePath: String): InputStream? {
-        val normalizedPath = if (!resourcePath.startsWith("/")) "/$resourcePath" else resourcePath
-        return searchClasses.firstNotNullOfOrNull { it.getResourceAsStream(normalizedPath) }
-    }
-}
diff --git a/themes/int-ui/int-ui-standalone/src/main/kotlin/org/jetbrains/jewel/themes/intui/standalone/IntUiTheme.kt b/themes/int-ui/int-ui-standalone/src/main/kotlin/org/jetbrains/jewel/themes/intui/standalone/IntUiTheme.kt
index 9fc0b80bf..17023a8e3 100644
--- a/themes/int-ui/int-ui-standalone/src/main/kotlin/org/jetbrains/jewel/themes/intui/standalone/IntUiTheme.kt
+++ b/themes/int-ui/int-ui-standalone/src/main/kotlin/org/jetbrains/jewel/themes/intui/standalone/IntUiTheme.kt
@@ -13,8 +13,8 @@ import androidx.compose.ui.unit.sp
 import org.jetbrains.jewel.GlobalColors
 import org.jetbrains.jewel.GlobalMetrics
 import org.jetbrains.jewel.IntelliJComponentStyling
-import org.jetbrains.jewel.IntelliJSvgLoader
 import org.jetbrains.jewel.IntelliJThemeIconData
+import org.jetbrains.jewel.JewelSvgLoader
 import org.jetbrains.jewel.LocalColorPalette
 import org.jetbrains.jewel.LocalContentColor
 import org.jetbrains.jewel.LocalGlobalColors
@@ -22,6 +22,7 @@ import org.jetbrains.jewel.LocalGlobalMetrics
 import org.jetbrains.jewel.LocalIconData
 import org.jetbrains.jewel.LocalResourceLoader
 import org.jetbrains.jewel.LocalTextStyle
+import org.jetbrains.jewel.SimpleResourceLoader
 import org.jetbrains.jewel.SvgLoader
 import org.jetbrains.jewel.styling.ButtonStyle
 import org.jetbrains.jewel.styling.CheckboxStyle
@@ -37,7 +38,7 @@ import org.jetbrains.jewel.styling.RadioButtonStyle
 import org.jetbrains.jewel.styling.ScrollbarStyle
 import org.jetbrains.jewel.styling.TabStyle
 import org.jetbrains.jewel.styling.TextFieldStyle
-import org.jetbrains.jewel.themes.PaletteMapperFactory
+import org.jetbrains.jewel.themes.StandalonePaletteMapperFactory
 import org.jetbrains.jewel.themes.intui.core.BaseIntUiTheme
 import org.jetbrains.jewel.themes.intui.core.IntUiThemeColorPalette
 import org.jetbrains.jewel.themes.intui.core.IntUiThemeDefinition
@@ -198,9 +199,13 @@ fun IntUiTheme(
 ) {
     val svgLoader by remember(themeDefinition.isDark, themeDefinition.iconData, themeDefinition.colorPalette) {
         val paletteMapper =
-            PaletteMapperFactory.create(themeDefinition.isDark, themeDefinition.iconData, themeDefinition.colorPalette)
+            StandalonePaletteMapperFactory.create(
+                themeDefinition.isDark,
+                themeDefinition.iconData,
+                themeDefinition.colorPalette,
+            )
         val svgPatcher = IntelliJSvgPatcher(paletteMapper)
-        mutableStateOf(IntelliJSvgLoader(svgPatcher))
+        mutableStateOf(JewelSvgLoader(svgPatcher))
     }
 
     val componentStyling = defaultComponentStyling(themeDefinition, svgLoader)
@@ -215,7 +220,7 @@ fun IntUiTheme(
     content: @Composable () -> Unit,
 ) {
     BaseIntUiTheme(theme, componentStyling, swingCompatMode) {
-        CompositionLocalProvider(LocalResourceLoader provides IntUiDefaultResourceLoader) {
+        CompositionLocalProvider(LocalResourceLoader provides SimpleResourceLoader(IntUiTheme.javaClass.classLoader)) {
             content()
         }
     }
diff --git a/themes/int-ui/int-ui-standalone/src/main/kotlin/org/jetbrains/jewel/themes/intui/standalone/styling/IntUiLazyTreeStyling.kt b/themes/int-ui/int-ui-standalone/src/main/kotlin/org/jetbrains/jewel/themes/intui/standalone/styling/IntUiLazyTreeStyling.kt
index 69c543db2..07f047280 100644
--- a/themes/int-ui/int-ui-standalone/src/main/kotlin/org/jetbrains/jewel/themes/intui/standalone/styling/IntUiLazyTreeStyling.kt
+++ b/themes/int-ui/int-ui-standalone/src/main/kotlin/org/jetbrains/jewel/themes/intui/standalone/styling/IntUiLazyTreeStyling.kt
@@ -9,7 +9,6 @@ import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.unit.Dp
 import androidx.compose.ui.unit.dp
 import org.jetbrains.jewel.SvgLoader
-import org.jetbrains.jewel.foundation.tree.TreeElementState
 import org.jetbrains.jewel.styling.LazyTreeColors
 import org.jetbrains.jewel.styling.LazyTreeIcons
 import org.jetbrains.jewel.styling.LazyTreeMetrics
@@ -111,33 +110,39 @@ data class IntUiLazyTreeMetrics(
 
 @Immutable
 data class IntUiLazyTreeIcons(
-    override val nodeChevronCollapsed: PainterProvider<TreeElementState>,
-    override val nodeChevronExpanded: PainterProvider<TreeElementState>,
+    override val chevronCollapsed: PainterProvider<Unit>,
+    override val chevronExpanded: PainterProvider<Unit>,
+    override val chevronSelectedCollapsed: PainterProvider<Unit>,
+    override val chevronSelectedExpanded: PainterProvider<Unit>,
 ) : LazyTreeIcons {
 
     companion object {
 
         @Composable
-        fun nodeChevronCollapsed(
+        fun chevronCollapsed(
             svgLoader: SvgLoader,
             basePath: String = "icons/intui/chevronRight.svg",
-        ): PainterProvider<TreeElementState> =
-            ResourcePainterProvider.stateful(basePath, svgLoader)
+        ): PainterProvider<Unit> =
+            ResourcePainterProvider.stateless(basePath, svgLoader)
 
         @Composable
-        fun nodeChevronExpanded(
+        fun chevronExpanded(
             svgLoader: SvgLoader,
             basePath: String = "icons/intui/chevronDown.svg",
-        ): PainterProvider<TreeElementState> =
-            ResourcePainterProvider.stateful(basePath, svgLoader)
+        ): PainterProvider<Unit> =
+            ResourcePainterProvider.stateless(basePath, svgLoader)
     }
 }
 
 @Composable
 fun intUiLazyTreeIcons(
     svgLoader: SvgLoader,
-    nodeChevronCollapsed: PainterProvider<TreeElementState> =
-        IntUiLazyTreeIcons.nodeChevronCollapsed(svgLoader),
-    nodeChevronExpanded: PainterProvider<TreeElementState> =
-        IntUiLazyTreeIcons.nodeChevronExpanded(svgLoader),
-) = IntUiLazyTreeIcons(nodeChevronCollapsed, nodeChevronExpanded)
+    chevronCollapsed: PainterProvider<Unit> =
+        IntUiLazyTreeIcons.chevronCollapsed(svgLoader),
+    chevronExpanded: PainterProvider<Unit> =
+        IntUiLazyTreeIcons.chevronExpanded(svgLoader),
+    chevronSelectedCollapsed: PainterProvider<Unit> =
+        IntUiLazyTreeIcons.chevronCollapsed(svgLoader),
+    chevronSelectedExpanded: PainterProvider<Unit> =
+        IntUiLazyTreeIcons.chevronExpanded(svgLoader),
+) = IntUiLazyTreeIcons(chevronCollapsed, chevronExpanded, chevronSelectedCollapsed, chevronSelectedExpanded)