diff --git a/compose/material3/material3/bcv/native/current.txt b/compose/material3/material3/bcv/native/current.txt
index 28918e5..5336029 100644
--- a/compose/material3/material3/bcv/native/current.txt
+++ b/compose/material3/material3/bcv/native/current.txt
@@ -4059,6 +4059,10 @@
 final val androidx.compose.material3/androidx_compose_material3_IndicatorLineElement$stableprop // androidx.compose.material3/androidx_compose_material3_IndicatorLineElement$stableprop|#static{}androidx_compose_material3_IndicatorLineElement$stableprop[0]
 final val androidx.compose.material3/androidx_compose_material3_IndicatorLineNode$stableprop // androidx.compose.material3/androidx_compose_material3_IndicatorLineNode$stableprop|#static{}androidx_compose_material3_IndicatorLineNode$stableprop[0]
 final val androidx.compose.material3/androidx_compose_material3_InputChipDefaults$stableprop // androidx.compose.material3/androidx_compose_material3_InputChipDefaults$stableprop|#static{}androidx_compose_material3_InputChipDefaults$stableprop[0]
+final val androidx.compose.material3/androidx_compose_material3_InteractiveListItemColors$stableprop // androidx.compose.material3/androidx_compose_material3_InteractiveListItemColors$stableprop|#static{}androidx_compose_material3_InteractiveListItemColors$stableprop[0]
+final val androidx.compose.material3/androidx_compose_material3_InteractiveListItemDefaults$stableprop // androidx.compose.material3/androidx_compose_material3_InteractiveListItemDefaults$stableprop|#static{}androidx_compose_material3_InteractiveListItemDefaults$stableprop[0]
+final val androidx.compose.material3/androidx_compose_material3_InteractiveListItemElevation$stableprop // androidx.compose.material3/androidx_compose_material3_InteractiveListItemElevation$stableprop|#static{}androidx_compose_material3_InteractiveListItemElevation$stableprop[0]
+final val androidx.compose.material3/androidx_compose_material3_InteractiveListItemShapes$stableprop // androidx.compose.material3/androidx_compose_material3_InteractiveListItemShapes$stableprop|#static{}androidx_compose_material3_InteractiveListItemShapes$stableprop[0]
 final val androidx.compose.material3/androidx_compose_material3_ListItemColors$stableprop // androidx.compose.material3/androidx_compose_material3_ListItemColors$stableprop|#static{}androidx_compose_material3_ListItemColors$stableprop[0]
 final val androidx.compose.material3/androidx_compose_material3_ListItemDefaults$stableprop // androidx.compose.material3/androidx_compose_material3_ListItemDefaults$stableprop|#static{}androidx_compose_material3_ListItemDefaults$stableprop[0]
 final val androidx.compose.material3/androidx_compose_material3_LoadingIndicatorDefaults$stableprop // androidx.compose.material3/androidx_compose_material3_LoadingIndicatorDefaults$stableprop|#static{}androidx_compose_material3_LoadingIndicatorDefaults$stableprop[0]
@@ -4674,6 +4678,10 @@
 final fun androidx.compose.material3/androidx_compose_material3_IndicatorLineElement$stableprop_getter(): kotlin/Int // androidx.compose.material3/androidx_compose_material3_IndicatorLineElement$stableprop_getter|androidx_compose_material3_IndicatorLineElement$stableprop_getter(){}[0]
 final fun androidx.compose.material3/androidx_compose_material3_IndicatorLineNode$stableprop_getter(): kotlin/Int // androidx.compose.material3/androidx_compose_material3_IndicatorLineNode$stableprop_getter|androidx_compose_material3_IndicatorLineNode$stableprop_getter(){}[0]
 final fun androidx.compose.material3/androidx_compose_material3_InputChipDefaults$stableprop_getter(): kotlin/Int // androidx.compose.material3/androidx_compose_material3_InputChipDefaults$stableprop_getter|androidx_compose_material3_InputChipDefaults$stableprop_getter(){}[0]
+final fun androidx.compose.material3/androidx_compose_material3_InteractiveListItemColors$stableprop_getter(): kotlin/Int // androidx.compose.material3/androidx_compose_material3_InteractiveListItemColors$stableprop_getter|androidx_compose_material3_InteractiveListItemColors$stableprop_getter(){}[0]
+final fun androidx.compose.material3/androidx_compose_material3_InteractiveListItemDefaults$stableprop_getter(): kotlin/Int // androidx.compose.material3/androidx_compose_material3_InteractiveListItemDefaults$stableprop_getter|androidx_compose_material3_InteractiveListItemDefaults$stableprop_getter(){}[0]
+final fun androidx.compose.material3/androidx_compose_material3_InteractiveListItemElevation$stableprop_getter(): kotlin/Int // androidx.compose.material3/androidx_compose_material3_InteractiveListItemElevation$stableprop_getter|androidx_compose_material3_InteractiveListItemElevation$stableprop_getter(){}[0]
+final fun androidx.compose.material3/androidx_compose_material3_InteractiveListItemShapes$stableprop_getter(): kotlin/Int // androidx.compose.material3/androidx_compose_material3_InteractiveListItemShapes$stableprop_getter|androidx_compose_material3_InteractiveListItemShapes$stableprop_getter(){}[0]
 final fun androidx.compose.material3/androidx_compose_material3_ListItemColors$stableprop_getter(): kotlin/Int // androidx.compose.material3/androidx_compose_material3_ListItemColors$stableprop_getter|androidx_compose_material3_ListItemColors$stableprop_getter(){}[0]
 final fun androidx.compose.material3/androidx_compose_material3_ListItemDefaults$stableprop_getter(): kotlin/Int // androidx.compose.material3/androidx_compose_material3_ListItemDefaults$stableprop_getter|androidx_compose_material3_ListItemDefaults$stableprop_getter(){}[0]
 final fun androidx.compose.material3/androidx_compose_material3_LoadingIndicatorDefaults$stableprop_getter(): kotlin/Int // androidx.compose.material3/androidx_compose_material3_LoadingIndicatorDefaults$stableprop_getter|androidx_compose_material3_LoadingIndicatorDefaults$stableprop_getter(){}[0]
diff --git a/compose/material3/material3/src/androidInstrumentedTest/kotlin/androidx/compose/material3/BottomSheetScaffoldTest.kt b/compose/material3/material3/src/androidInstrumentedTest/kotlin/androidx/compose/material3/BottomSheetScaffoldTest.kt
index 7e398a3..648fbcf 100644
--- a/compose/material3/material3/src/androidInstrumentedTest/kotlin/androidx/compose/material3/BottomSheetScaffoldTest.kt
+++ b/compose/material3/material3/src/androidInstrumentedTest/kotlin/androidx/compose/material3/BottomSheetScaffoldTest.kt
@@ -1124,7 +1124,7 @@
         rule.runOnIdle {
             assertThat(bottomSheetState.anchoredDraggableState.anchors.size).isEqualTo(1)
             assertThat(
-                    bottomSheetState.anchoredDraggableState.anchors.hasPositionFor(
+                    bottomSheetState.anchoredDraggableState.anchors.hasAnchorFor(
                         SheetValue.Expanded
                     )
                 )
diff --git a/compose/material3/material3/src/androidInstrumentedTest/kotlin/androidx/compose/material3/InteractiveListTest.kt b/compose/material3/material3/src/androidInstrumentedTest/kotlin/androidx/compose/material3/InteractiveListTest.kt
new file mode 100644
index 0000000..6e79b68
--- /dev/null
+++ b/compose/material3/material3/src/androidInstrumentedTest/kotlin/androidx/compose/material3/InteractiveListTest.kt
@@ -0,0 +1,428 @@
+/*
+ * Copyright 2025 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package androidx.compose.material3
+
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.IntrinsicSize
+import androidx.compose.foundation.layout.fillMaxHeight
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.layout.width
+import androidx.compose.runtime.CompositionLocalProvider
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.setValue
+import androidx.compose.testutils.assertIsEqualTo
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.platform.LocalLayoutDirection
+import androidx.compose.ui.platform.testTag
+import androidx.compose.ui.semantics.SemanticsActions
+import androidx.compose.ui.test.SemanticsMatcher
+import androidx.compose.ui.test.assert
+import androidx.compose.ui.test.assertHasClickAction
+import androidx.compose.ui.test.assertHeightIsEqualTo
+import androidx.compose.ui.test.assertIsNotSelected
+import androidx.compose.ui.test.assertIsOff
+import androidx.compose.ui.test.assertIsOn
+import androidx.compose.ui.test.assertIsSelectable
+import androidx.compose.ui.test.assertIsSelected
+import androidx.compose.ui.test.assertIsToggleable
+import androidx.compose.ui.test.getUnclippedBoundsInRoot
+import androidx.compose.ui.test.junit4.createComposeRule
+import androidx.compose.ui.test.longClick
+import androidx.compose.ui.test.onNodeWithTag
+import androidx.compose.ui.test.performClick
+import androidx.compose.ui.test.performTouchInput
+import androidx.compose.ui.unit.LayoutDirection
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.height
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.test.filters.MediumTest
+import com.google.common.truth.Truth.assertThat
+import org.junit.Rule
+import org.junit.Test
+import org.junit.runner.RunWith
+
+@OptIn(ExperimentalMaterial3ExpressiveApi::class)
+@MediumTest
+@RunWith(AndroidJUnit4::class)
+class InteractiveListTest {
+    @get:Rule val rule = createComposeRule()
+    val ListTag = "list"
+    val LeadingTag = "leading"
+    val TrailingTag = "trailing"
+    val OverlineTag = "overline"
+    val SupportingTag = "supporting"
+    val HeadlineTag = "headline"
+
+    @Test
+    fun clickableListItem_intrinsicSize() {
+        val headlineSize = 200.dp
+        rule.setMaterialContent(lightColorScheme()) {
+            Column(Modifier.height(IntrinsicSize.Min)) {
+                ClickableListItem(
+                    modifier = Modifier.fillMaxHeight().testTag(ListTag),
+                    headlineContent = { Box(Modifier.size(headlineSize)) },
+                    leadingContent = { Box(Modifier.fillMaxHeight().testTag(LeadingTag)) },
+                    trailingContent = { Box(Modifier.fillMaxHeight().testTag(TrailingTag)) },
+                    onClick = {},
+                )
+            }
+        }
+
+        val expectedHeight = headlineSize + InteractiveListTopPadding + InteractiveListBottomPadding
+        rule.onNodeWithTag(ListTag, useUnmergedTree = true).assertHeightIsEqualTo(expectedHeight)
+        rule.onNodeWithTag(LeadingTag, useUnmergedTree = true).assertHeightIsEqualTo(headlineSize)
+        rule.onNodeWithTag(TrailingTag, useUnmergedTree = true).assertHeightIsEqualTo(headlineSize)
+    }
+
+    @Test
+    fun clickableListItem_multipleItems_intrinsicSize() {
+        rule.setMaterialContent(lightColorScheme()) {
+            Column(Modifier.width(300.dp).height(IntrinsicSize.Min)) {
+                // 2 identical list items. Leading content leaves small space
+                // for headline, so it has to wrap.
+                ClickableListItem(
+                    modifier = Modifier.testTag("ListItem1"),
+                    leadingContent = { Box(Modifier.width(240.dp)) },
+                    headlineContent = { Text("A B C D E F G H") },
+                    onClick = {},
+                )
+                ClickableListItem(
+                    modifier = Modifier.testTag("ListItem2"),
+                    leadingContent = { Box(Modifier.width(240.dp)) },
+                    headlineContent = { Text("A B C D E F G H") },
+                    onClick = {},
+                )
+            }
+        }
+
+        val item1Height =
+            rule
+                .onNodeWithTag("ListItem1", useUnmergedTree = true)
+                .getUnclippedBoundsInRoot()
+                .height
+        rule.onNodeWithTag("ListItem2", useUnmergedTree = true).assertHeightIsEqualTo(item1Height)
+    }
+
+    @Test
+    fun clickableListItem_verticalAlignmentCenter_positioning() {
+        val height = InteractiveListVerticalAlignmentBreakpoint - 10.dp
+        rule.setMaterialContent(lightColorScheme()) {
+            ClickableListItem(
+                modifier = Modifier.height(height),
+                leadingContent = { Box(Modifier.testTag(LeadingTag).size(48.dp)) },
+                trailingContent = { Box(Modifier.testTag(TrailingTag).size(48.dp)) },
+                overlineContent = { Text("Overline", Modifier.testTag(OverlineTag)) },
+                supportingContent = { Text("Supporting", Modifier.testTag(SupportingTag)) },
+                headlineContent = { Text("Content", Modifier.testTag(HeadlineTag)) },
+                onClick = {},
+            )
+        }
+
+        val leadingBounds =
+            rule.onNodeWithTag(LeadingTag, useUnmergedTree = true).getUnclippedBoundsInRoot()
+        val overlineBounds =
+            rule.onNodeWithTag(OverlineTag, useUnmergedTree = true).getUnclippedBoundsInRoot()
+        val supportingBounds =
+            rule.onNodeWithTag(SupportingTag, useUnmergedTree = true).getUnclippedBoundsInRoot()
+        val headlineBounds =
+            rule.onNodeWithTag(HeadlineTag, useUnmergedTree = true).getUnclippedBoundsInRoot()
+        val trailingNodeBounds =
+            rule.onNodeWithTag(TrailingTag, useUnmergedTree = true).getUnclippedBoundsInRoot()
+
+        leadingBounds.left.assertIsEqualTo(InteractiveListStartPadding)
+        leadingBounds.top.assertIsEqualTo((rule.rootHeight() - leadingBounds.height) / 2)
+
+        val mainContentX = leadingBounds.right + InteractiveListInternalSpacing
+        val mainContentHeight =
+            overlineBounds.height + supportingBounds.height + headlineBounds.height
+        overlineBounds.top.assertIsEqualTo((rule.rootHeight() - mainContentHeight) / 2)
+        overlineBounds.left.assertIsEqualTo(mainContentX)
+        supportingBounds.left.assertIsEqualTo(mainContentX)
+        headlineBounds.left.assertIsEqualTo(mainContentX)
+
+        trailingNodeBounds.right.assertIsEqualTo(rule.rootWidth() - InteractiveListEndPadding)
+        trailingNodeBounds.top.assertIsEqualTo((rule.rootHeight() - trailingNodeBounds.height) / 2)
+    }
+
+    @Test
+    fun clickableListItem_verticalAlignmentTop_positioning() {
+        val height = InteractiveListVerticalAlignmentBreakpoint + 10.dp
+        rule.setMaterialContent(lightColorScheme()) {
+            ClickableListItem(
+                modifier = Modifier.height(height),
+                leadingContent = { Box(Modifier.testTag(LeadingTag).size(48.dp)) },
+                trailingContent = { Box(Modifier.testTag(TrailingTag).size(48.dp)) },
+                overlineContent = { Text("Overline", Modifier.testTag(OverlineTag)) },
+                supportingContent = { Text("Supporting", Modifier.testTag(SupportingTag)) },
+                headlineContent = { Text("Content", Modifier.testTag(HeadlineTag)) },
+                onClick = {},
+            )
+        }
+
+        val leadingBounds =
+            rule.onNodeWithTag(LeadingTag, useUnmergedTree = true).getUnclippedBoundsInRoot()
+        val overlineBounds =
+            rule.onNodeWithTag(OverlineTag, useUnmergedTree = true).getUnclippedBoundsInRoot()
+        val supportingBounds =
+            rule.onNodeWithTag(SupportingTag, useUnmergedTree = true).getUnclippedBoundsInRoot()
+        val headlineBounds =
+            rule.onNodeWithTag(HeadlineTag, useUnmergedTree = true).getUnclippedBoundsInRoot()
+        val trailingNodeBounds =
+            rule.onNodeWithTag(TrailingTag, useUnmergedTree = true).getUnclippedBoundsInRoot()
+
+        leadingBounds.left.assertIsEqualTo(InteractiveListStartPadding)
+        leadingBounds.top.assertIsEqualTo(InteractiveListTopPadding)
+
+        val mainContentX = leadingBounds.right + InteractiveListInternalSpacing
+        overlineBounds.top.assertIsEqualTo(InteractiveListTopPadding)
+        overlineBounds.left.assertIsEqualTo(mainContentX)
+        supportingBounds.left.assertIsEqualTo(mainContentX)
+        headlineBounds.left.assertIsEqualTo(mainContentX)
+
+        trailingNodeBounds.right.assertIsEqualTo(rule.rootWidth() - InteractiveListEndPadding)
+        trailingNodeBounds.top.assertIsEqualTo(InteractiveListTopPadding)
+    }
+
+    @Test
+    fun clickableListItem_verticalAlignmentCenter_positioning_rtl() {
+        val height = InteractiveListVerticalAlignmentBreakpoint - 10.dp
+        rule.setMaterialContent(lightColorScheme()) {
+            CompositionLocalProvider(LocalLayoutDirection provides LayoutDirection.Rtl) {
+                ClickableListItem(
+                    modifier = Modifier.height(height),
+                    leadingContent = { Box(Modifier.testTag(LeadingTag).size(48.dp)) },
+                    trailingContent = { Box(Modifier.testTag(TrailingTag).size(48.dp)) },
+                    overlineContent = { Text("Overline", Modifier.testTag(OverlineTag)) },
+                    supportingContent = { Text("Supporting", Modifier.testTag(SupportingTag)) },
+                    headlineContent = { Text("Content", Modifier.testTag(HeadlineTag)) },
+                    onClick = {},
+                )
+            }
+        }
+
+        val leadingBounds =
+            rule.onNodeWithTag(LeadingTag, useUnmergedTree = true).getUnclippedBoundsInRoot()
+        val overlineBounds =
+            rule.onNodeWithTag(OverlineTag, useUnmergedTree = true).getUnclippedBoundsInRoot()
+        val supportingBounds =
+            rule.onNodeWithTag(SupportingTag, useUnmergedTree = true).getUnclippedBoundsInRoot()
+        val headlineBounds =
+            rule.onNodeWithTag(HeadlineTag, useUnmergedTree = true).getUnclippedBoundsInRoot()
+        val trailingNodeBounds =
+            rule.onNodeWithTag(TrailingTag, useUnmergedTree = true).getUnclippedBoundsInRoot()
+
+        leadingBounds.right.assertIsEqualTo(rule.rootWidth() - InteractiveListStartPadding)
+        leadingBounds.top.assertIsEqualTo((rule.rootHeight() - leadingBounds.height) / 2)
+
+        val mainContentRightX = leadingBounds.left - InteractiveListInternalSpacing
+        val mainContentHeight =
+            overlineBounds.height + supportingBounds.height + headlineBounds.height
+        overlineBounds.top.assertIsEqualTo((rule.rootHeight() - mainContentHeight) / 2)
+        overlineBounds.right.assertIsEqualTo(mainContentRightX)
+        supportingBounds.right.assertIsEqualTo(mainContentRightX)
+        headlineBounds.right.assertIsEqualTo(mainContentRightX)
+
+        trailingNodeBounds.left.assertIsEqualTo(InteractiveListEndPadding)
+        trailingNodeBounds.top.assertIsEqualTo((rule.rootHeight() - trailingNodeBounds.height) / 2)
+    }
+
+    @Test
+    fun clickableListItem_verticalAlignmentTop_positioning_rtl() {
+        val height = InteractiveListVerticalAlignmentBreakpoint + 10.dp
+        rule.setMaterialContent(lightColorScheme()) {
+            CompositionLocalProvider(LocalLayoutDirection provides LayoutDirection.Rtl) {
+                ClickableListItem(
+                    modifier = Modifier.height(height),
+                    leadingContent = { Box(Modifier.testTag(LeadingTag).size(48.dp)) },
+                    trailingContent = { Box(Modifier.testTag(TrailingTag).size(48.dp)) },
+                    overlineContent = { Text("Overline", Modifier.testTag(OverlineTag)) },
+                    supportingContent = { Text("Supporting", Modifier.testTag(SupportingTag)) },
+                    headlineContent = { Text("Content", Modifier.testTag(HeadlineTag)) },
+                    onClick = {},
+                )
+            }
+        }
+
+        val leadingBounds =
+            rule.onNodeWithTag(LeadingTag, useUnmergedTree = true).getUnclippedBoundsInRoot()
+        val overlineBounds =
+            rule.onNodeWithTag(OverlineTag, useUnmergedTree = true).getUnclippedBoundsInRoot()
+        val supportingBounds =
+            rule.onNodeWithTag(SupportingTag, useUnmergedTree = true).getUnclippedBoundsInRoot()
+        val headlineBounds =
+            rule.onNodeWithTag(HeadlineTag, useUnmergedTree = true).getUnclippedBoundsInRoot()
+        val trailingNodeBounds =
+            rule.onNodeWithTag(TrailingTag, useUnmergedTree = true).getUnclippedBoundsInRoot()
+
+        leadingBounds.right.assertIsEqualTo(rule.rootWidth() - InteractiveListStartPadding)
+        leadingBounds.top.assertIsEqualTo(InteractiveListTopPadding)
+
+        val mainContentRightX = leadingBounds.left - InteractiveListInternalSpacing
+        overlineBounds.top.assertIsEqualTo(InteractiveListTopPadding)
+        overlineBounds.right.assertIsEqualTo(mainContentRightX)
+        supportingBounds.right.assertIsEqualTo(mainContentRightX)
+        headlineBounds.right.assertIsEqualTo(mainContentRightX)
+
+        trailingNodeBounds.left.assertIsEqualTo(InteractiveListEndPadding)
+        trailingNodeBounds.top.assertIsEqualTo(InteractiveListTopPadding)
+    }
+
+    @Test
+    fun clickableListItem_semantics() {
+        var clicked by mutableStateOf(false)
+        rule.setMaterialContent(lightColorScheme()) {
+            ClickableListItem(
+                modifier = Modifier.testTag(ListTag),
+                headlineContent = { Text("Headline") },
+                onClick = { clicked = true },
+            )
+        }
+
+        rule.onNodeWithTag(ListTag, useUnmergedTree = true).assertHasClickAction()
+        assertThat(clicked).isFalse()
+
+        rule.onNodeWithTag(ListTag, useUnmergedTree = true).performClick()
+        rule.waitForIdle()
+
+        assertThat(clicked).isTrue()
+    }
+
+    @Test
+    fun clickableListItem_longClick() {
+        var clicked by mutableStateOf(false)
+        var longClicked by mutableStateOf(false)
+        rule.setMaterialContent(lightColorScheme()) {
+            ClickableListItem(
+                modifier = Modifier.testTag(ListTag),
+                headlineContent = { Text("Headline") },
+                onClick = { clicked = true },
+                onLongClick = { longClicked = true },
+            )
+        }
+
+        rule
+            .onNodeWithTag(ListTag, useUnmergedTree = true)
+            .assert(SemanticsMatcher.keyIsDefined(SemanticsActions.OnLongClick))
+        assertThat(clicked).isFalse()
+        assertThat(longClicked).isFalse()
+
+        rule.onNodeWithTag(ListTag, useUnmergedTree = true).performTouchInput { longClick() }
+        rule.waitForIdle()
+
+        assertThat(clicked).isFalse()
+        assertThat(longClicked).isTrue()
+    }
+
+    @Test
+    fun selectableListItem_semantics() {
+        var selected by mutableStateOf(false)
+        rule.setMaterialContent(lightColorScheme()) {
+            SelectableListItem(
+                modifier = Modifier.testTag(ListTag),
+                headlineContent = { Text("Headline") },
+                selected = selected,
+                onClick = { selected = !selected },
+            )
+        }
+
+        rule.onNodeWithTag(ListTag, useUnmergedTree = true).assertIsSelectable()
+        rule.onNodeWithTag(ListTag, useUnmergedTree = true).assertIsNotSelected()
+
+        rule.onNodeWithTag(ListTag, useUnmergedTree = true).performClick()
+        rule.waitForIdle()
+
+        rule.onNodeWithTag(ListTag, useUnmergedTree = true).assertIsSelected()
+    }
+
+    @Test
+    fun selectableListItem_longClick() {
+        var selected by mutableStateOf(false)
+        var longClicked by mutableStateOf(false)
+        rule.setMaterialContent(lightColorScheme()) {
+            SelectableListItem(
+                modifier = Modifier.testTag(ListTag),
+                headlineContent = { Text("Headline") },
+                selected = selected,
+                onClick = { selected = !selected },
+                onLongClick = { longClicked = true },
+            )
+        }
+
+        rule
+            .onNodeWithTag(ListTag, useUnmergedTree = true)
+            .assert(SemanticsMatcher.keyIsDefined(SemanticsActions.OnLongClick))
+        assertThat(selected).isFalse()
+        assertThat(longClicked).isFalse()
+
+        rule.onNodeWithTag(ListTag, useUnmergedTree = true).performTouchInput { longClick() }
+        rule.waitForIdle()
+
+        assertThat(selected).isFalse()
+        assertThat(longClicked).isTrue()
+    }
+
+    @Test
+    fun toggleableListItem_semantics() {
+        var checked by mutableStateOf(false)
+        rule.setMaterialContent(lightColorScheme()) {
+            ToggleableListItem(
+                modifier = Modifier.testTag(ListTag),
+                headlineContent = { Text("Headline") },
+                checked = checked,
+                onCheckedChange = { checked = it },
+            )
+        }
+
+        rule.onNodeWithTag(ListTag, useUnmergedTree = true).assertIsToggleable()
+        rule.onNodeWithTag(ListTag, useUnmergedTree = true).assertIsOff()
+
+        rule.onNodeWithTag(ListTag, useUnmergedTree = true).performClick()
+        rule.waitForIdle()
+
+        rule.onNodeWithTag(ListTag, useUnmergedTree = true).assertIsOn()
+    }
+
+    @Test
+    fun toggleableListItem_longClick() {
+        var checked by mutableStateOf(false)
+        var longClicked by mutableStateOf(false)
+        rule.setMaterialContent(lightColorScheme()) {
+            ToggleableListItem(
+                modifier = Modifier.testTag(ListTag),
+                headlineContent = { Text("Headline") },
+                checked = checked,
+                onCheckedChange = { checked = it },
+                onLongClick = { longClicked = true },
+            )
+        }
+
+        rule
+            .onNodeWithTag(ListTag, useUnmergedTree = true)
+            .assert(SemanticsMatcher.keyIsDefined(SemanticsActions.OnLongClick))
+        assertThat(checked).isFalse()
+        assertThat(longClicked).isFalse()
+
+        rule.onNodeWithTag(ListTag, useUnmergedTree = true).performTouchInput { longClick() }
+        rule.waitForIdle()
+
+        assertThat(checked).isFalse()
+        assertThat(longClicked).isTrue()
+    }
+}
diff --git a/compose/material3/material3/src/androidInstrumentedTest/kotlin/androidx/compose/material3/ModalBottomSheetScreenshotTest.kt b/compose/material3/material3/src/androidInstrumentedTest/kotlin/androidx/compose/material3/ModalBottomSheetScreenshotTest.kt
index 919f248..892f9020 100644
--- a/compose/material3/material3/src/androidInstrumentedTest/kotlin/androidx/compose/material3/ModalBottomSheetScreenshotTest.kt
+++ b/compose/material3/material3/src/androidInstrumentedTest/kotlin/androidx/compose/material3/ModalBottomSheetScreenshotTest.kt
@@ -102,8 +102,8 @@
                 predictiveBackProgress = remember { Animatable(initialValue = progress) },
                 scope = rememberCoroutineScope(),
                 sheetState = rememberSheetState(initialValue = SheetValue.Expanded),
-                onDismissRequest = {},
                 animateToDismiss = {},
+                settleToDismiss = {},
             ) {
                 Text(
                     "Modal Bottom Sheet Predictive Back\nProgress: $progress",
diff --git a/compose/material3/material3/src/androidInstrumentedTest/kotlin/androidx/compose/material3/ModalBottomSheetTest.kt b/compose/material3/material3/src/androidInstrumentedTest/kotlin/androidx/compose/material3/ModalBottomSheetTest.kt
index dd96f1fd..091b355 100644
--- a/compose/material3/material3/src/androidInstrumentedTest/kotlin/androidx/compose/material3/ModalBottomSheetTest.kt
+++ b/compose/material3/material3/src/androidInstrumentedTest/kotlin/androidx/compose/material3/ModalBottomSheetTest.kt
@@ -71,7 +71,6 @@
 import androidx.compose.ui.test.assertWidthIsEqualTo
 import androidx.compose.ui.test.getUnclippedBoundsInRoot
 import androidx.compose.ui.test.isDialog
-import androidx.compose.ui.test.junit4.ComposeTestRule
 import androidx.compose.ui.test.junit4.createAndroidComposeRule
 import androidx.compose.ui.test.onFirst
 import androidx.compose.ui.test.onNodeWithContentDescription
@@ -659,11 +658,9 @@
         rule.waitForIdle()
         assertThat(state.currentValue).isEqualTo(SheetValue.PartiallyExpanded) // We should
         // retain the current value if possible
-        assertTrue(state.anchoredDraggableState.anchors.hasPositionFor(SheetValue.Hidden))
-        assertTrue(
-            state.anchoredDraggableState.anchors.hasPositionFor(SheetValue.PartiallyExpanded)
-        )
-        assertTrue(state.anchoredDraggableState.anchors.hasPositionFor(SheetValue.Expanded))
+        assertTrue(state.anchoredDraggableState.anchors.hasAnchorFor(SheetValue.Hidden))
+        assertTrue(state.anchoredDraggableState.anchors.hasAnchorFor(SheetValue.PartiallyExpanded))
+        assertTrue(state.anchoredDraggableState.anchors.hasAnchorFor(SheetValue.Expanded))
 
         scope.launch { state.expand() }
         rule.waitForIdle()
@@ -673,20 +670,16 @@
         rule.waitForIdle()
         assertThat(state.currentValue).isEqualTo(SheetValue.Expanded)
         // We should retain the current value if possible
-        assertTrue(state.anchoredDraggableState.anchors.hasPositionFor(SheetValue.Hidden))
-        assertTrue(
-            state.anchoredDraggableState.anchors.hasPositionFor(SheetValue.PartiallyExpanded)
-        )
-        assertTrue(state.anchoredDraggableState.anchors.hasPositionFor(SheetValue.Expanded))
+        assertTrue(state.anchoredDraggableState.anchors.hasAnchorFor(SheetValue.Hidden))
+        assertTrue(state.anchoredDraggableState.anchors.hasAnchorFor(SheetValue.PartiallyExpanded))
+        assertTrue(state.anchoredDraggableState.anchors.hasAnchorFor(SheetValue.Expanded))
 
         amountOfItems = 0 // When the sheet height is 0, we should only have a hidden anchor
         rule.waitForIdle()
         assertThat(state.currentValue).isEqualTo(SheetValue.Hidden)
-        assertTrue(state.anchoredDraggableState.anchors.hasPositionFor(SheetValue.Hidden))
-        assertFalse(
-            state.anchoredDraggableState.anchors.hasPositionFor(SheetValue.PartiallyExpanded)
-        )
-        assertFalse(state.anchoredDraggableState.anchors.hasPositionFor(SheetValue.Expanded))
+        assertTrue(state.anchoredDraggableState.anchors.hasAnchorFor(SheetValue.Hidden))
+        assertFalse(state.anchoredDraggableState.anchors.hasAnchorFor(SheetValue.PartiallyExpanded))
+        assertFalse(state.anchoredDraggableState.anchors.hasAnchorFor(SheetValue.Expanded))
     }
 
     @Test
@@ -778,7 +771,6 @@
         rule.runOnIdle { assertThat(sheetState.currentValue).isEqualTo(SheetValue.Hidden) }
 
         showShortContent = true
-        rule.waitForIdle()
         scope.launch { sheetState.show() } // We can't use LaunchedEffect with Swipeable in tests
         // yet, so we're invoking this outside of composition. See b/254115946.
 
@@ -1116,24 +1108,19 @@
 
         assertThat(sheetState.currentValue).isEqualTo(SheetValue.Hidden)
         assertFalse(
-            sheetState.anchoredDraggableState.anchors.hasPositionFor(SheetValue.PartiallyExpanded)
+            sheetState.anchoredDraggableState.anchors.hasAnchorFor(SheetValue.PartiallyExpanded)
         )
-        assertFalse(sheetState.anchoredDraggableState.anchors.hasPositionFor(SheetValue.Expanded))
+        assertFalse(sheetState.anchoredDraggableState.anchors.hasAnchorFor(SheetValue.Expanded))
 
         scope.launch { sheetState.show() }
         rule.waitForIdle()
 
         assertThat(sheetState.isVisible).isTrue()
-        // animateTo with a non-existent targetValue will force currentValue to the targetValue
-        // (Expanded). TargetValue then returns to the nearest available anchor (Hidden).
-        assertThat(sheetState.currentValue).isEqualTo(SheetValue.Expanded)
-        assertThat(sheetState.targetValue).isEqualTo(SheetValue.Hidden)
-        assertThat(sheetState.requireOffset()).isEqualTo(rule.rootHeightPx())
+        assertThat(sheetState.currentValue).isEqualTo(sheetState.targetValue)
 
         hasSheetContent = true // Recompose with sheet content
         rule.waitForIdle()
         assertThat(sheetState.currentValue).isEqualTo(SheetValue.Expanded)
-        assertThat(sheetState.requireOffset()).isWithin(1f).of(rule.rootHeightPx() * 0.6f)
     }
 
     @Test
@@ -1169,21 +1156,19 @@
 
         assertThat(sheetState.currentValue).isEqualTo(SheetValue.Hidden)
         assertFalse(
-            sheetState.anchoredDraggableState.anchors.hasPositionFor(SheetValue.PartiallyExpanded)
+            sheetState.anchoredDraggableState.anchors.hasAnchorFor(SheetValue.PartiallyExpanded)
         )
-        assertFalse(sheetState.anchoredDraggableState.anchors.hasPositionFor(SheetValue.Expanded))
+        assertFalse(sheetState.anchoredDraggableState.anchors.hasAnchorFor(SheetValue.Expanded))
 
         scope.launch { sheetState.show() }
         rule.waitForIdle()
 
         assertThat(sheetState.isVisible).isTrue()
-        assertThat(sheetState.currentValue).isEqualTo(SheetValue.Expanded)
-        assertThat(sheetState.requireOffset()).isEqualTo(rule.rootHeightPx())
+        assertThat(sheetState.currentValue).isEqualTo(sheetState.targetValue)
 
         hasSheetContent = true // Recompose with sheet content
         rule.waitForIdle()
         assertThat(sheetState.currentValue).isEqualTo(SheetValue.PartiallyExpanded)
-        assertThat(sheetState.requireOffset()).isWithin(1f).of(rule.rootHeightPx() * 0.5f)
     }
 
     @Test
@@ -1481,7 +1466,4 @@
 
     private val Bundle.traversalBefore: Int
         get() = getInt("android.view.accessibility.extra.EXTRA_DATA_TEST_TRAVERSALBEFORE_VAL")
-
-    private fun ComposeTestRule.rootHeightPx(): Float =
-        with(density) { onAllNodes(isDialog()).onFirst().getUnclippedBoundsInRoot().height.toPx() }
 }
diff --git a/compose/material3/material3/src/androidInstrumentedTest/kotlin/androidx/compose/material3/TimePickerTest.kt b/compose/material3/material3/src/androidInstrumentedTest/kotlin/androidx/compose/material3/TimePickerTest.kt
index 408bf8d..4fcde05 100644
--- a/compose/material3/material3/src/androidInstrumentedTest/kotlin/androidx/compose/material3/TimePickerTest.kt
+++ b/compose/material3/material3/src/androidInstrumentedTest/kotlin/androidx/compose/material3/TimePickerTest.kt
@@ -41,6 +41,7 @@
 import androidx.compose.ui.test.assertContentDescriptionContains
 import androidx.compose.ui.test.assertCountEquals
 import androidx.compose.ui.test.assertHasClickAction
+import androidx.compose.ui.test.assertIsFocused
 import androidx.compose.ui.test.assertIsNotSelected
 import androidx.compose.ui.test.assertIsSelectable
 import androidx.compose.ui.test.assertIsSelected
@@ -68,6 +69,7 @@
 import androidx.compose.ui.test.performSemanticsAction
 import androidx.compose.ui.test.performTouchInput
 import androidx.compose.ui.test.pressKey
+import androidx.compose.ui.test.requestFocus
 import androidx.compose.ui.text.input.ImeAction
 import androidx.test.ext.junit.runners.AndroidJUnit4
 import androidx.test.filters.MediumTest
@@ -724,6 +726,47 @@
         }
     }
 
+    @OptIn(ExperimentalTestApi::class)
+    @Test
+    fun clockFace_24Hour_everyValue_byKeyboard() {
+        val state =
+            AnalogTimePickerState(
+                TimePickerState(initialHour = 10, initialMinute = 23, is24Hour = true)
+            )
+
+        rule.setMaterialContent(lightColorScheme()) {
+            ClockFace(
+                modifier = Modifier,
+                state = state,
+                colors = TimePickerDefaults.colors(),
+                autoSwitchToMinute = false,
+            )
+        }
+
+        rule.onNodeWithTimeValue(0, TimePickerSelectionMode.Hour, is24Hour = true).requestFocus()
+
+        repeat(24) { number ->
+            rule
+                .onNodeWithTimeValue(number, TimePickerSelectionMode.Hour, is24Hour = true)
+                .assertIsFocused()
+            rule
+                .onNodeWithTimeValue(number, TimePickerSelectionMode.Hour, is24Hour = true)
+                .performKeyInput { pressKey(Key.Enter) }
+
+            rule.runOnIdle {
+                state.selection = TimePickerSelectionMode.Hour
+                assertThat(state.hour).isEqualTo(number)
+            }
+            rule
+                .onNodeWithTimeValue(number, TimePickerSelectionMode.Hour, is24Hour = true)
+                .assertIsSelected()
+
+            rule
+                .onNodeWithTimeValue(number, TimePickerSelectionMode.Hour, is24Hour = true)
+                .performKeyInput { pressKey(Key.Tab) }
+        }
+    }
+
     @Test
     fun clockFace_12Hour_everyValue() {
         val state =
@@ -759,6 +802,51 @@
         }
     }
 
+    @OptIn(ExperimentalTestApi::class)
+    @Test
+    fun clockFace_12Hour_everyValue_byKeyboard() {
+        val state =
+            AnalogTimePickerState(
+                TimePickerState(initialHour = 0, initialMinute = 0, is24Hour = false)
+            )
+
+        rule.setMaterialContent(lightColorScheme()) {
+            ClockFace(
+                modifier = Modifier,
+                state = state,
+                colors = TimePickerDefaults.colors(),
+                autoSwitchToMinute = false,
+            )
+        }
+
+        rule.onNodeWithTimeValue(12, TimePickerSelectionMode.Hour).requestFocus()
+
+        repeat(12) { number ->
+            val hour =
+                when {
+                    number == 0 -> 12
+                    else -> number
+                }
+
+            rule.onNodeWithTimeValue(hour, TimePickerSelectionMode.Hour).assertIsFocused()
+            rule.onNodeWithTimeValue(hour, TimePickerSelectionMode.Hour).performKeyInput {
+                pressKey(Key.Enter)
+            }
+
+            rule.runOnIdle {
+                state.selection = TimePickerSelectionMode.Hour
+                assertThat(state.hour).isEqualTo(number)
+            }
+            rule
+                .onNodeWithTimeValue(hour, TimePickerSelectionMode.Hour, is24Hour = false)
+                .assertIsSelected()
+
+            rule.onNodeWithTimeValue(hour, TimePickerSelectionMode.Hour).performKeyInput {
+                pressKey(Key.Tab)
+            }
+        }
+    }
+
     @Test
     fun clockFace_12Hour_traversalIndex() {
         val state =
diff --git a/compose/material3/material3/src/commonMain/kotlin/androidx/compose/material3/BottomSheetScaffold.kt b/compose/material3/material3/src/commonMain/kotlin/androidx/compose/material3/BottomSheetScaffold.kt
index af0be34..7f2f6b6 100644
--- a/compose/material3/material3/src/commonMain/kotlin/androidx/compose/material3/BottomSheetScaffold.kt
+++ b/compose/material3/material3/src/commonMain/kotlin/androidx/compose/material3/BottomSheetScaffold.kt
@@ -19,10 +19,7 @@
 import androidx.compose.animation.core.FiniteAnimationSpec
 import androidx.compose.foundation.background
 import androidx.compose.foundation.clickable
-import androidx.compose.foundation.gestures.AnchoredDraggableDefaults
-import androidx.compose.foundation.gestures.DraggableAnchors
 import androidx.compose.foundation.gestures.Orientation
-import androidx.compose.foundation.gestures.anchoredDraggable
 import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.ColumnScope
@@ -34,8 +31,10 @@
 import androidx.compose.material3.SheetValue.Expanded
 import androidx.compose.material3.SheetValue.Hidden
 import androidx.compose.material3.SheetValue.PartiallyExpanded
+import androidx.compose.material3.internal.DraggableAnchors
 import androidx.compose.material3.internal.Strings
-import androidx.compose.material3.internal.draggableAnchorsV2
+import androidx.compose.material3.internal.anchoredDraggable
+import androidx.compose.material3.internal.draggableAnchors
 import androidx.compose.material3.internal.getString
 import androidx.compose.material3.tokens.MotionSchemeKeyTokens
 import androidx.compose.runtime.Composable
@@ -250,12 +249,6 @@
     val scope = rememberCoroutineScope()
     val orientation = Orientation.Vertical
     val peekHeightPx = with(LocalDensity.current) { peekHeight.toPx() }
-    val anchoredDraggableFlingBehavior =
-        AnchoredDraggableDefaults.flingBehavior(
-            state = state.anchoredDraggableState,
-            positionalThreshold = { _ -> state.positionalThreshold.invoke() },
-            animationSpec = BottomSheetAnimationSpec,
-        )
     val nestedScroll =
         if (sheetSwipeEnabled) {
             Modifier.nestedScroll(
@@ -263,7 +256,7 @@
                     ConsumeSwipeWithinBottomSheetBoundsNestedScrollConnection(
                         sheetState = state,
                         orientation = orientation,
-                        flingBehavior = anchoredDraggableFlingBehavior,
+                        onFling = { scope.launch { state.settle(it) } },
                     )
                 }
             )
@@ -276,7 +269,7 @@
                 .fillMaxWidth()
                 .requiredHeightIn(min = peekHeight)
                 .then(nestedScroll)
-                .draggableAnchorsV2(state.anchoredDraggableState, orientation) {
+                .draggableAnchors(state.anchoredDraggableState, orientation) {
                     sheetSize,
                     constraints ->
                     val layoutHeight = constraints.maxHeight.toFloat()
@@ -296,27 +289,23 @@
                     }
                     val newTarget =
                         when (val oldTarget = state.anchoredDraggableState.targetValue) {
-                            Hidden -> if (newAnchors.hasPositionFor(Hidden)) Hidden else oldTarget
+                            Hidden -> if (newAnchors.hasAnchorFor(Hidden)) Hidden else oldTarget
                             PartiallyExpanded ->
                                 when {
-                                    newAnchors.hasPositionFor(PartiallyExpanded) ->
-                                        PartiallyExpanded
-
-                                    newAnchors.hasPositionFor(Expanded) -> Expanded
-                                    newAnchors.hasPositionFor(Hidden) -> Hidden
+                                    newAnchors.hasAnchorFor(PartiallyExpanded) -> PartiallyExpanded
+                                    newAnchors.hasAnchorFor(Expanded) -> Expanded
+                                    newAnchors.hasAnchorFor(Hidden) -> Hidden
                                     else -> oldTarget
                                 }
 
-                            Expanded ->
-                                if (newAnchors.hasPositionFor(Expanded)) Expanded else Hidden
+                            Expanded -> if (newAnchors.hasAnchorFor(Expanded)) Expanded else Hidden
                         }
-                    return@draggableAnchorsV2 newAnchors to newTarget
+                    return@draggableAnchors newAnchors to newTarget
                 }
                 .anchoredDraggable(
                     state = state.anchoredDraggableState,
                     orientation = orientation,
                     enabled = sheetSwipeEnabled,
-                    flingBehavior = anchoredDraggableFlingBehavior,
                 )
                 // Scale up the Surface vertically in case the sheet's offset overflows below the
                 // min anchor. This is done to avoid showing a gap when the sheet opens and bounces
@@ -369,14 +358,22 @@
                                                 sheetSwipeEnabled
                                         ) {
                                             if (currentValue == PartiallyExpanded) {
-                                                if (confirmValueChange(Expanded)) {
+                                                if (
+                                                    anchoredDraggableState.confirmValueChange(
+                                                        Expanded
+                                                    )
+                                                ) {
                                                     expand(expandActionLabel) {
                                                         scope.launch { expand() }
                                                         true
                                                     }
                                                 }
                                             } else {
-                                                if (confirmValueChange(PartiallyExpanded)) {
+                                                if (
+                                                    anchoredDraggableState.confirmValueChange(
+                                                        PartiallyExpanded
+                                                    )
+                                                ) {
                                                     collapse(partialExpandActionLabel) {
                                                         scope.launch { partialExpand() }
                                                         true
@@ -469,7 +466,7 @@
 @OptIn(ExperimentalMaterial3Api::class)
 internal fun Modifier.verticalScaleUp(state: SheetState) = graphicsLayer {
     val offset = state.anchoredDraggableState.offset
-    val anchor = state.anchoredDraggableState.anchors.minPosition()
+    val anchor = state.anchoredDraggableState.anchors.minAnchor()
     val overflow = if (offset < anchor) anchor - offset else 0f
     scaleY = if (overflow > 0f) (size.height + overflow) / size.height else 1f
     transformOrigin = TransformOrigin(pivotFractionX = 0.5f, pivotFractionY = 0f)
@@ -487,7 +484,7 @@
 @OptIn(ExperimentalMaterial3Api::class)
 internal fun Modifier.verticalScaleDown(state: SheetState) = graphicsLayer {
     val offset = state.anchoredDraggableState.offset
-    val anchor = state.anchoredDraggableState.anchors.minPosition()
+    val anchor = state.anchoredDraggableState.anchors.minAnchor()
     val overflow = if (offset < anchor) anchor - offset else 0f
     scaleY = if (overflow > 0f) 1 / ((size.height + overflow) / size.height) else 1f
     transformOrigin = TransformOrigin(pivotFractionX = 0.5f, pivotFractionY = 0f)
diff --git a/compose/material3/material3/src/commonMain/kotlin/androidx/compose/material3/ColorScheme.kt b/compose/material3/material3/src/commonMain/kotlin/androidx/compose/material3/ColorScheme.kt
index d3b287b..ade75ab 100644
--- a/compose/material3/material3/src/commonMain/kotlin/androidx/compose/material3/ColorScheme.kt
+++ b/compose/material3/material3/src/commonMain/kotlin/androidx/compose/material3/ColorScheme.kt
@@ -680,6 +680,8 @@
     internal var defaultOutlinedToggleButtonColorsCached: ToggleButtonColors? = null
 
     internal var defaultListItemColorsCached: ListItemColors? = null
+    @OptIn(ExperimentalMaterial3ExpressiveApi::class)
+    internal var defaultInteractiveListItemColorsCached: InteractiveListItemColors? = null
 
     internal var defaultMenuItemColorsCached: MenuItemColors? = null
 
diff --git a/compose/material3/material3/src/commonMain/kotlin/androidx/compose/material3/InteractiveListItem.kt b/compose/material3/material3/src/commonMain/kotlin/androidx/compose/material3/InteractiveListItem.kt
new file mode 100644
index 0000000..3f6e078
--- /dev/null
+++ b/compose/material3/material3/src/commonMain/kotlin/androidx/compose/material3/InteractiveListItem.kt
@@ -0,0 +1,1321 @@
+/*
+ * Copyright 2025 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package androidx.compose.material3
+
+import androidx.compose.animation.animateColor
+import androidx.compose.animation.core.FiniteAnimationSpec
+import androidx.compose.animation.core.animateDpAsState
+import androidx.compose.animation.core.updateTransition
+import androidx.compose.foundation.combinedClickable
+import androidx.compose.foundation.interaction.DragInteraction
+import androidx.compose.foundation.interaction.FocusInteraction
+import androidx.compose.foundation.interaction.HoverInteraction
+import androidx.compose.foundation.interaction.InteractionSource
+import androidx.compose.foundation.interaction.MutableInteractionSource
+import androidx.compose.foundation.interaction.PressInteraction
+import androidx.compose.foundation.interaction.collectIsFocusedAsState
+import androidx.compose.foundation.interaction.collectIsPressedAsState
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.PaddingValues
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.material3.internal.ProvideContentColorTextStyle
+import androidx.compose.material3.internal.heightOrZero
+import androidx.compose.material3.internal.rememberAnimatedShape
+import androidx.compose.material3.internal.subtractConstraintSafely
+import androidx.compose.material3.internal.widthOrZero
+import androidx.compose.material3.tokens.ColorSchemeKeyTokens
+import androidx.compose.material3.tokens.ElevationTokens
+import androidx.compose.material3.tokens.MotionSchemeKeyTokens
+import androidx.compose.material3.tokens.ShapeKeyTokens
+import androidx.compose.material3.tokens.TypographyKeyTokens
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.Immutable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.MutableState
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.key
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.Shape
+import androidx.compose.ui.graphics.takeOrElse
+import androidx.compose.ui.layout.IntrinsicMeasurable
+import androidx.compose.ui.layout.IntrinsicMeasureScope
+import androidx.compose.ui.layout.Layout
+import androidx.compose.ui.layout.Measurable
+import androidx.compose.ui.layout.MeasureResult
+import androidx.compose.ui.layout.MeasureScope
+import androidx.compose.ui.layout.MultiContentMeasurePolicy
+import androidx.compose.ui.layout.Placeable
+import androidx.compose.ui.semantics.SemanticsPropertyReceiver
+import androidx.compose.ui.semantics.selected
+import androidx.compose.ui.semantics.semantics
+import androidx.compose.ui.semantics.toggleableState
+import androidx.compose.ui.state.ToggleableState
+import androidx.compose.ui.unit.Constraints
+import androidx.compose.ui.unit.Dp
+import androidx.compose.ui.unit.constrainHeight
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.offset
+
+/** TODO: docs */
+@ExperimentalMaterial3ExpressiveApi
+@Composable
+internal fun ClickableListItem(
+    modifier: Modifier = Modifier,
+
+    // slots
+    headlineContent: @Composable () -> Unit, // TODO: should this be `content` trailing lambda?
+    leadingContent: @Composable (() -> Unit)? = null,
+    trailingContent: @Composable (() -> Unit)? = null,
+    overlineContent: @Composable (() -> Unit)? = null,
+    supportingContent: @Composable (() -> Unit)? = null,
+
+    // interaction
+    onClick: () -> Unit,
+    enabled: Boolean = true,
+    onLongClick: (() -> Unit)? = null,
+    onLongClickLabel: String? = null,
+    interactionSource: MutableInteractionSource? = null,
+
+    // styling
+    colors: InteractiveListItemColors = InteractiveListItemDefaults.colors(),
+    shapes: InteractiveListItemShapes = InteractiveListItemDefaults.shapes(),
+    elevation: InteractiveListItemElevation = InteractiveListItemDefaults.elevation(),
+    contentPadding: PaddingValues = InteractiveListPadding,
+) {
+    InteractiveListItem(
+        modifier = modifier,
+        headlineContent = headlineContent,
+        leadingContent = leadingContent,
+        trailingContent = trailingContent,
+        overlineContent = overlineContent,
+        supportingContent = supportingContent,
+        enabled = enabled,
+        selected = false,
+        applySemantics = {},
+        onClick = onClick,
+        onLongClick = onLongClick,
+        onLongClickLabel = onLongClickLabel,
+        interactionSource = interactionSource,
+        colors = colors,
+        shapes = shapes,
+        elevation = elevation,
+        contentPadding = contentPadding,
+    )
+}
+
+/** TODO: docs */
+@ExperimentalMaterial3ExpressiveApi
+@Composable
+internal fun SelectableListItem(
+    modifier: Modifier = Modifier,
+
+    // slots
+    headlineContent: @Composable () -> Unit, // TODO: should this be `content` trailing lambda?
+    leadingContent: @Composable (() -> Unit)? = null,
+    trailingContent: @Composable (() -> Unit)? = null,
+    overlineContent: @Composable (() -> Unit)? = null,
+    supportingContent: @Composable (() -> Unit)? = null,
+
+    // interaction
+    selected: Boolean,
+    onClick: () -> Unit,
+    enabled: Boolean = true,
+    onLongClick: (() -> Unit)? = null,
+    onLongClickLabel: String? = null,
+    interactionSource: MutableInteractionSource? = null,
+
+    // styling
+    colors: InteractiveListItemColors = InteractiveListItemDefaults.colors(),
+    shapes: InteractiveListItemShapes = InteractiveListItemDefaults.shapes(),
+    elevation: InteractiveListItemElevation = InteractiveListItemDefaults.elevation(),
+    contentPadding: PaddingValues = InteractiveListPadding,
+) {
+    InteractiveListItem(
+        modifier = modifier,
+        headlineContent = headlineContent,
+        leadingContent = leadingContent,
+        trailingContent = trailingContent,
+        overlineContent = overlineContent,
+        supportingContent = supportingContent,
+        enabled = enabled,
+        selected = selected,
+        applySemantics = { this.selected = selected },
+        onClick = onClick,
+        onLongClick = onLongClick,
+        onLongClickLabel = onLongClickLabel,
+        interactionSource = interactionSource,
+        colors = colors,
+        shapes = shapes,
+        elevation = elevation,
+        contentPadding = contentPadding,
+    )
+}
+
+/** TODO: docs */
+@ExperimentalMaterial3ExpressiveApi
+@Composable
+internal fun ToggleableListItem(
+    modifier: Modifier = Modifier,
+
+    // slots
+    headlineContent: @Composable () -> Unit, // TODO: should this be `content` trailing lambda?
+    leadingContent: @Composable (() -> Unit)? = null,
+    trailingContent: @Composable (() -> Unit)? = null,
+    overlineContent: @Composable (() -> Unit)? = null,
+    supportingContent: @Composable (() -> Unit)? = null,
+
+    // interaction
+    checked: Boolean,
+    onCheckedChange: (Boolean) -> Unit,
+    enabled: Boolean = true,
+    onLongClick: (() -> Unit)? = null,
+    onLongClickLabel: String? = null,
+    interactionSource: MutableInteractionSource? = null,
+
+    // styling
+    colors: InteractiveListItemColors = InteractiveListItemDefaults.colors(),
+    shapes: InteractiveListItemShapes = InteractiveListItemDefaults.shapes(),
+    elevation: InteractiveListItemElevation = InteractiveListItemDefaults.elevation(),
+    contentPadding: PaddingValues = InteractiveListPadding,
+) {
+    InteractiveListItem(
+        modifier = modifier,
+        headlineContent = headlineContent,
+        leadingContent = leadingContent,
+        trailingContent = trailingContent,
+        overlineContent = overlineContent,
+        supportingContent = supportingContent,
+        enabled = enabled,
+        selected = checked,
+        applySemantics = { toggleableState = ToggleableState(checked) },
+        onClick = { onCheckedChange(!checked) },
+        onLongClick = onLongClick,
+        onLongClickLabel = onLongClickLabel,
+        interactionSource = interactionSource,
+        colors = colors,
+        shapes = shapes,
+        elevation = elevation,
+        contentPadding = contentPadding,
+    )
+}
+
+/** TODO: docs */
+@ExperimentalMaterial3ExpressiveApi
+@Immutable
+internal class InteractiveListItemColors(
+    // default
+    val containerColor: Color,
+    val headlineColor: Color,
+    val leadingIconColor: Color,
+    val trailingIconColor: Color,
+    val overlineColor: Color,
+    val supportingTextColor: Color,
+    // selected
+    val selectedContainerColor: Color,
+    val selectedHeadlineColor: Color,
+    val selectedLeadingIconColor: Color,
+    val selectedTrailingIconColor: Color,
+    val selectedOverlineColor: Color,
+    val selectedSupportingTextColor: Color,
+    // disabled
+    val disabledContainerColor: Color,
+    val disabledHeadlineColor: Color,
+    val disabledLeadingIconColor: Color,
+    val disabledTrailingIconColor: Color,
+    val disabledOverlineColor: Color,
+    val disabledSupportingTextColor: Color,
+    // dragged
+    val draggedContainerColor: Color,
+    val draggedHeadlineColor: Color,
+    val draggedLeadingIconColor: Color,
+    val draggedTrailingIconColor: Color,
+    val draggedOverlineColor: Color,
+    val draggedSupportingTextColor: Color,
+) {
+    /** TODO: docs */
+    fun containerColor(enabled: Boolean, selected: Boolean, dragged: Boolean): Color =
+        when {
+            !enabled -> disabledContainerColor
+            dragged -> draggedContainerColor
+            selected -> selectedContainerColor
+            else -> containerColor
+        }
+
+    /** TODO: docs */
+    fun headlineColor(enabled: Boolean, selected: Boolean, dragged: Boolean): Color =
+        when {
+            !enabled -> disabledHeadlineColor
+            dragged -> draggedHeadlineColor
+            selected -> selectedHeadlineColor
+            else -> headlineColor
+        }
+
+    /** TODO: docs */
+    fun leadingIconColor(enabled: Boolean, selected: Boolean, dragged: Boolean): Color =
+        when {
+            !enabled -> disabledLeadingIconColor
+            dragged -> draggedLeadingIconColor
+            selected -> selectedLeadingIconColor
+            else -> leadingIconColor
+        }
+
+    /** TODO: docs */
+    fun trailingIconColor(enabled: Boolean, selected: Boolean, dragged: Boolean): Color =
+        when {
+            !enabled -> disabledTrailingIconColor
+            dragged -> draggedTrailingIconColor
+            selected -> selectedTrailingIconColor
+            else -> trailingIconColor
+        }
+
+    /** TODO: docs */
+    fun overlineColor(enabled: Boolean, selected: Boolean, dragged: Boolean): Color =
+        when {
+            !enabled -> disabledOverlineColor
+            dragged -> draggedOverlineColor
+            selected -> selectedOverlineColor
+            else -> overlineColor
+        }
+
+    /** TODO: docs */
+    fun supportingTextColor(enabled: Boolean, selected: Boolean, dragged: Boolean): Color =
+        when {
+            !enabled -> disabledSupportingTextColor
+            dragged -> draggedSupportingTextColor
+            selected -> selectedSupportingTextColor
+            else -> supportingTextColor
+        }
+
+    /** TODO: docs */
+    fun copy(
+        containerColor: Color = this.containerColor,
+        headlineColor: Color = this.headlineColor,
+        leadingIconColor: Color = this.leadingIconColor,
+        trailingIconColor: Color = this.trailingIconColor,
+        overlineColor: Color = this.overlineColor,
+        supportingTextColor: Color = this.supportingTextColor,
+        selectedContainerColor: Color = this.selectedContainerColor,
+        selectedHeadlineColor: Color = this.selectedHeadlineColor,
+        selectedLeadingIconColor: Color = this.selectedLeadingIconColor,
+        selectedTrailingIconColor: Color = this.selectedTrailingIconColor,
+        selectedOverlineColor: Color = this.selectedOverlineColor,
+        selectedSupportingTextColor: Color = this.selectedSupportingTextColor,
+        disabledContainerColor: Color = this.disabledContainerColor,
+        disabledHeadlineColor: Color = this.disabledHeadlineColor,
+        disabledLeadingIconColor: Color = this.disabledLeadingIconColor,
+        disabledTrailingIconColor: Color = this.disabledTrailingIconColor,
+        disabledOverlineColor: Color = this.disabledOverlineColor,
+        disabledSupportingTextColor: Color = this.disabledSupportingTextColor,
+        draggedContainerColor: Color = this.draggedContainerColor,
+        draggedHeadlineColor: Color = this.draggedHeadlineColor,
+        draggedLeadingIconColor: Color = this.draggedLeadingIconColor,
+        draggedTrailingIconColor: Color = this.draggedTrailingIconColor,
+        draggedOverlineColor: Color = this.draggedOverlineColor,
+        draggedSupportingTextColor: Color = this.draggedSupportingTextColor,
+    ): InteractiveListItemColors {
+        return InteractiveListItemColors(
+            containerColor = containerColor.takeOrElse { this.containerColor },
+            headlineColor = headlineColor.takeOrElse { this.headlineColor },
+            leadingIconColor = leadingIconColor.takeOrElse { this.leadingIconColor },
+            trailingIconColor = trailingIconColor.takeOrElse { this.trailingIconColor },
+            overlineColor = overlineColor.takeOrElse { this.overlineColor },
+            supportingTextColor = supportingTextColor.takeOrElse { this.supportingTextColor },
+            selectedContainerColor =
+                selectedContainerColor.takeOrElse { this.selectedContainerColor },
+            selectedHeadlineColor = selectedHeadlineColor.takeOrElse { this.selectedHeadlineColor },
+            selectedLeadingIconColor =
+                selectedLeadingIconColor.takeOrElse { this.selectedLeadingIconColor },
+            selectedTrailingIconColor =
+                selectedTrailingIconColor.takeOrElse { this.selectedTrailingIconColor },
+            selectedOverlineColor = selectedOverlineColor.takeOrElse { this.selectedOverlineColor },
+            selectedSupportingTextColor =
+                selectedSupportingTextColor.takeOrElse { this.selectedSupportingTextColor },
+            disabledContainerColor =
+                disabledContainerColor.takeOrElse { this.disabledContainerColor },
+            disabledHeadlineColor = disabledHeadlineColor.takeOrElse { this.disabledHeadlineColor },
+            disabledLeadingIconColor =
+                disabledLeadingIconColor.takeOrElse { this.disabledLeadingIconColor },
+            disabledTrailingIconColor =
+                disabledTrailingIconColor.takeOrElse { this.disabledTrailingIconColor },
+            disabledOverlineColor = disabledOverlineColor.takeOrElse { this.disabledOverlineColor },
+            disabledSupportingTextColor =
+                disabledSupportingTextColor.takeOrElse { this.disabledSupportingTextColor },
+            draggedContainerColor = draggedContainerColor.takeOrElse { this.draggedContainerColor },
+            draggedHeadlineColor = draggedHeadlineColor.takeOrElse { this.draggedHeadlineColor },
+            draggedLeadingIconColor =
+                draggedLeadingIconColor.takeOrElse { this.draggedLeadingIconColor },
+            draggedTrailingIconColor =
+                draggedTrailingIconColor.takeOrElse { this.draggedTrailingIconColor },
+            draggedOverlineColor = draggedOverlineColor.takeOrElse { this.draggedOverlineColor },
+            draggedSupportingTextColor =
+                draggedSupportingTextColor.takeOrElse { this.draggedSupportingTextColor },
+        )
+    }
+
+    override fun equals(other: Any?): Boolean {
+        if (this === other) return true
+        if (other == null || other !is InteractiveListItemColors) return false
+
+        if (containerColor != other.containerColor) return false
+        if (headlineColor != other.headlineColor) return false
+        if (leadingIconColor != other.leadingIconColor) return false
+        if (trailingIconColor != other.trailingIconColor) return false
+        if (overlineColor != other.overlineColor) return false
+        if (supportingTextColor != other.supportingTextColor) return false
+        if (selectedContainerColor != other.selectedContainerColor) return false
+        if (selectedHeadlineColor != other.selectedHeadlineColor) return false
+        if (selectedLeadingIconColor != other.selectedLeadingIconColor) return false
+        if (selectedTrailingIconColor != other.selectedTrailingIconColor) return false
+        if (selectedOverlineColor != other.selectedOverlineColor) return false
+        if (selectedSupportingTextColor != other.selectedSupportingTextColor) return false
+        if (disabledContainerColor != other.disabledContainerColor) return false
+        if (disabledHeadlineColor != other.disabledHeadlineColor) return false
+        if (disabledLeadingIconColor != other.disabledLeadingIconColor) return false
+        if (disabledTrailingIconColor != other.disabledTrailingIconColor) return false
+        if (disabledOverlineColor != other.disabledOverlineColor) return false
+        if (disabledSupportingTextColor != other.disabledSupportingTextColor) return false
+        if (draggedContainerColor != other.draggedContainerColor) return false
+        if (draggedHeadlineColor != other.draggedHeadlineColor) return false
+        if (draggedLeadingIconColor != other.draggedLeadingIconColor) return false
+        if (draggedTrailingIconColor != other.draggedTrailingIconColor) return false
+        if (draggedOverlineColor != other.draggedOverlineColor) return false
+        if (draggedSupportingTextColor != other.draggedSupportingTextColor) return false
+
+        return true
+    }
+
+    override fun hashCode(): Int {
+        var result = containerColor.hashCode()
+        result = 31 * result + headlineColor.hashCode()
+        result = 31 * result + leadingIconColor.hashCode()
+        result = 31 * result + trailingIconColor.hashCode()
+        result = 31 * result + overlineColor.hashCode()
+        result = 31 * result + supportingTextColor.hashCode()
+        result = 31 * result + selectedContainerColor.hashCode()
+        result = 31 * result + selectedHeadlineColor.hashCode()
+        result = 31 * result + selectedLeadingIconColor.hashCode()
+        result = 31 * result + selectedTrailingIconColor.hashCode()
+        result = 31 * result + selectedOverlineColor.hashCode()
+        result = 31 * result + selectedSupportingTextColor.hashCode()
+        result = 31 * result + disabledContainerColor.hashCode()
+        result = 31 * result + disabledHeadlineColor.hashCode()
+        result = 31 * result + disabledLeadingIconColor.hashCode()
+        result = 31 * result + disabledTrailingIconColor.hashCode()
+        result = 31 * result + disabledOverlineColor.hashCode()
+        result = 31 * result + disabledSupportingTextColor.hashCode()
+        result = 31 * result + draggedContainerColor.hashCode()
+        result = 31 * result + draggedHeadlineColor.hashCode()
+        result = 31 * result + draggedLeadingIconColor.hashCode()
+        result = 31 * result + draggedTrailingIconColor.hashCode()
+        result = 31 * result + draggedOverlineColor.hashCode()
+        result = 31 * result + draggedSupportingTextColor.hashCode()
+        return result
+    }
+}
+
+/** TODO: docs */
+@ExperimentalMaterial3ExpressiveApi
+@Immutable
+internal class InteractiveListItemShapes(
+    val shape: Shape,
+    val selectedShape: Shape,
+    val pressedShape: Shape,
+    val focusedShape: Shape,
+    val hoveredShape: Shape,
+    val draggedShape: Shape,
+) {
+    fun copy(
+        shape: Shape? = this.shape,
+        selectedShape: Shape? = this.selectedShape,
+        pressedShape: Shape? = this.pressedShape,
+        focusedShape: Shape? = this.focusedShape,
+        hoveredShape: Shape? = this.hoveredShape,
+        draggedShape: Shape? = this.draggedShape,
+    ): InteractiveListItemShapes =
+        InteractiveListItemShapes(
+            shape = shape.takeOrElse { this.shape },
+            selectedShape = selectedShape.takeOrElse { this.selectedShape },
+            pressedShape = pressedShape.takeOrElse { this.pressedShape },
+            focusedShape = focusedShape.takeOrElse { this.focusedShape },
+            hoveredShape = hoveredShape.takeOrElse { this.hoveredShape },
+            draggedShape = draggedShape.takeOrElse { this.draggedShape },
+        )
+
+    internal fun Shape?.takeOrElse(block: () -> Shape): Shape = this ?: block()
+
+    override fun equals(other: Any?): Boolean {
+        if (this === other) return true
+        if (other == null || other !is InteractiveListItemShapes) return false
+
+        if (shape != other.shape) return false
+        if (selectedShape != other.selectedShape) return false
+        if (pressedShape != other.pressedShape) return false
+        if (focusedShape != other.focusedShape) return false
+        if (hoveredShape != other.hoveredShape) return false
+        if (draggedShape != other.draggedShape) return false
+
+        return true
+    }
+
+    override fun hashCode(): Int {
+        var result = shape.hashCode()
+        result = 31 * result + selectedShape.hashCode()
+        result = 31 * result + pressedShape.hashCode()
+        result = 31 * result + focusedShape.hashCode()
+        result = 31 * result + hoveredShape.hashCode()
+        result = 31 * result + draggedShape.hashCode()
+        return result
+    }
+}
+
+@OptIn(ExperimentalMaterial3ExpressiveApi::class)
+private val InteractiveListItemShapes.hasRoundedCornerShapes: Boolean
+    get() =
+        shape is RoundedCornerShape &&
+            selectedShape is RoundedCornerShape &&
+            pressedShape is RoundedCornerShape &&
+            focusedShape is RoundedCornerShape &&
+            hoveredShape is RoundedCornerShape &&
+            draggedShape is RoundedCornerShape
+
+@OptIn(ExperimentalMaterial3ExpressiveApi::class)
+@Composable
+private fun InteractiveListItemShapes.shapeForInteraction(
+    selected: Boolean,
+    pressed: Boolean,
+    focused: Boolean,
+    hovered: Boolean,
+    dragged: Boolean,
+    animationSpec: FiniteAnimationSpec<Float>,
+): Shape {
+    val shape =
+        when {
+            pressed -> pressedShape
+            dragged -> draggedShape
+            selected -> selectedShape
+            focused -> focusedShape
+            hovered -> hoveredShape
+            else -> shape
+        }
+
+    if (hasRoundedCornerShapes)
+        return key(this) { rememberAnimatedShape(shape as RoundedCornerShape, animationSpec) }
+
+    return shape
+}
+
+/** TODO: docs */
+@ExperimentalMaterial3ExpressiveApi
+@Immutable
+internal class InteractiveListItemElevation(val elevation: Dp, val draggedElevation: Dp) {
+    override fun equals(other: Any?): Boolean {
+        if (this === other) return true
+        if (other == null || other !is InteractiveListItemElevation) return false
+
+        if (elevation != other.elevation) return false
+        if (draggedElevation != other.draggedElevation) return false
+
+        return true
+    }
+
+    override fun hashCode(): Int {
+        var result = elevation.hashCode()
+        result = 31 * result + draggedElevation.hashCode()
+        return result
+    }
+}
+
+/** TODO: docs */
+@ExperimentalMaterial3ExpressiveApi
+@Immutable
+internal object InteractiveListItemDefaults {
+    /** TODO: docs */
+    @Composable
+    fun colors(): InteractiveListItemColors {
+        return MaterialTheme.colorScheme.defaultInteractiveListItemColors
+    }
+
+    /** TODO: docs */
+    @Composable
+    fun colors(
+        containerColor: Color = Color.Unspecified,
+        headlineColor: Color = Color.Unspecified,
+        leadingIconColor: Color = Color.Unspecified,
+        trailingIconColor: Color = Color.Unspecified,
+        overlineColor: Color = Color.Unspecified,
+        supportingTextColor: Color = Color.Unspecified,
+        selectedContainerColor: Color = Color.Unspecified,
+        selectedHeadlineColor: Color = Color.Unspecified,
+        selectedLeadingIconColor: Color = Color.Unspecified,
+        selectedTrailingIconColor: Color = Color.Unspecified,
+        selectedOverlineColor: Color = Color.Unspecified,
+        selectedSupportingTextColor: Color = Color.Unspecified,
+        disabledContainerColor: Color = Color.Unspecified,
+        disabledHeadlineColor: Color = Color.Unspecified,
+        disabledLeadingIconColor: Color = Color.Unspecified,
+        disabledTrailingIconColor: Color = Color.Unspecified,
+        disabledOverlineColor: Color = Color.Unspecified,
+        disabledSupportingTextColor: Color = Color.Unspecified,
+        draggedContainerColor: Color = Color.Unspecified,
+        draggedHeadlineColor: Color = Color.Unspecified,
+        draggedLeadingIconColor: Color = Color.Unspecified,
+        draggedTrailingIconColor: Color = Color.Unspecified,
+        draggedOverlineColor: Color = Color.Unspecified,
+        draggedSupportingTextColor: Color = Color.Unspecified,
+    ): InteractiveListItemColors {
+        return MaterialTheme.colorScheme.defaultInteractiveListItemColors.copy(
+            containerColor = containerColor,
+            headlineColor = headlineColor,
+            leadingIconColor = leadingIconColor,
+            trailingIconColor = trailingIconColor,
+            overlineColor = overlineColor,
+            supportingTextColor = supportingTextColor,
+            selectedContainerColor = selectedContainerColor,
+            selectedHeadlineColor = selectedHeadlineColor,
+            selectedLeadingIconColor = selectedLeadingIconColor,
+            selectedTrailingIconColor = selectedTrailingIconColor,
+            selectedOverlineColor = selectedOverlineColor,
+            selectedSupportingTextColor = selectedSupportingTextColor,
+            disabledContainerColor = disabledContainerColor,
+            disabledHeadlineColor = disabledHeadlineColor,
+            disabledLeadingIconColor = disabledLeadingIconColor,
+            disabledTrailingIconColor = disabledTrailingIconColor,
+            disabledOverlineColor = disabledOverlineColor,
+            disabledSupportingTextColor = disabledSupportingTextColor,
+            draggedContainerColor = draggedContainerColor,
+            draggedHeadlineColor = draggedHeadlineColor,
+            draggedLeadingIconColor = draggedLeadingIconColor,
+            draggedTrailingIconColor = draggedTrailingIconColor,
+            draggedOverlineColor = draggedOverlineColor,
+            draggedSupportingTextColor = draggedSupportingTextColor,
+        )
+    }
+
+    // TODO: load tokens from component file
+    internal val ColorScheme.defaultInteractiveListItemColors: InteractiveListItemColors
+        get() {
+            return defaultInteractiveListItemColorsCached
+                ?: InteractiveListItemColors(
+                        // default
+                        containerColor = fromToken(ColorSchemeKeyTokens.SurfaceBright),
+                        headlineColor = fromToken(ColorSchemeKeyTokens.OnSurface),
+                        leadingIconColor = fromToken(ColorSchemeKeyTokens.OnSurfaceVariant),
+                        trailingIconColor = fromToken(ColorSchemeKeyTokens.OnSurfaceVariant),
+                        overlineColor = fromToken(ColorSchemeKeyTokens.OnSurfaceVariant),
+                        supportingTextColor = fromToken(ColorSchemeKeyTokens.OnSurfaceVariant),
+                        // selected
+                        selectedContainerColor = fromToken(ColorSchemeKeyTokens.SecondaryContainer),
+                        selectedHeadlineColor =
+                            fromToken(ColorSchemeKeyTokens.OnSecondaryContainer),
+                        selectedLeadingIconColor =
+                            fromToken(ColorSchemeKeyTokens.OnSecondaryContainer),
+                        selectedTrailingIconColor =
+                            fromToken(ColorSchemeKeyTokens.OnSecondaryContainer),
+                        selectedOverlineColor =
+                            fromToken(ColorSchemeKeyTokens.OnSecondaryContainer),
+                        selectedSupportingTextColor =
+                            fromToken(ColorSchemeKeyTokens.OnSecondaryContainer),
+                        // disabled
+                        disabledContainerColor = fromToken(ColorSchemeKeyTokens.SurfaceBright),
+                        disabledHeadlineColor =
+                            fromToken(ColorSchemeKeyTokens.OnSurface)
+                                .copy(alpha = InteractiveListDisabledOpacity),
+                        disabledLeadingIconColor =
+                            fromToken(ColorSchemeKeyTokens.OnSurface)
+                                .copy(alpha = InteractiveListDisabledOpacity),
+                        disabledTrailingIconColor =
+                            fromToken(ColorSchemeKeyTokens.OnSurface)
+                                .copy(alpha = InteractiveListDisabledOpacity),
+                        disabledOverlineColor =
+                            fromToken(ColorSchemeKeyTokens.OnSurface)
+                                .copy(alpha = InteractiveListDisabledOpacity),
+                        disabledSupportingTextColor =
+                            fromToken(ColorSchemeKeyTokens.OnSurface)
+                                .copy(alpha = InteractiveListDisabledOpacity),
+                        // dragged
+                        draggedContainerColor = fromToken(ColorSchemeKeyTokens.TertiaryContainer),
+                        draggedHeadlineColor = fromToken(ColorSchemeKeyTokens.Tertiary),
+                        draggedLeadingIconColor = fromToken(ColorSchemeKeyTokens.Tertiary),
+                        draggedTrailingIconColor = fromToken(ColorSchemeKeyTokens.Tertiary),
+                        draggedOverlineColor = fromToken(ColorSchemeKeyTokens.Tertiary),
+                        draggedSupportingTextColor = fromToken(ColorSchemeKeyTokens.Tertiary),
+                    )
+                    .also { defaultInteractiveListItemColorsCached = it }
+        }
+
+    /** TODO: docs */
+    // TODO: account for first/last item in list shape changing
+    @Composable
+    fun shapes(
+        shape: Shape? = null,
+        selectedShape: Shape? = null,
+        pressedShape: Shape? = null,
+        focusedShape: Shape? = null,
+        hoveredShape: Shape? = null,
+        draggedShape: Shape? = null,
+    ): InteractiveListItemShapes =
+        MaterialTheme.shapes.defaultInteractiveListItemShapes.copy(
+            shape = shape,
+            selectedShape = selectedShape,
+            pressedShape = pressedShape,
+            focusedShape = focusedShape,
+            hoveredShape = hoveredShape,
+            draggedShape = draggedShape,
+        )
+
+    // TODO: load tokens from component file
+    internal val Shapes.defaultInteractiveListItemShapes: InteractiveListItemShapes
+        get() {
+            return defaultInteractiveListItemShapesCached
+                ?: InteractiveListItemShapes(
+                        shape = fromToken(ShapeKeyTokens.CornerExtraSmall),
+                        selectedShape = fromToken(ShapeKeyTokens.CornerLarge),
+                        pressedShape = fromToken(ShapeKeyTokens.CornerLarge),
+                        focusedShape = fromToken(ShapeKeyTokens.CornerLarge),
+                        hoveredShape = fromToken(ShapeKeyTokens.CornerLarge),
+                        draggedShape = fromToken(ShapeKeyTokens.CornerLarge),
+                    )
+                    .also { defaultInteractiveListItemShapesCached = it }
+        }
+
+    /** TODO: docs */
+    // TODO: load tokens from component file
+    fun elevation(
+        elevation: Dp = ElevationTokens.Level0,
+        draggedElevation: Dp = ElevationTokens.Level4,
+    ): InteractiveListItemElevation =
+        InteractiveListItemElevation(elevation = elevation, draggedElevation = draggedElevation)
+}
+
+@Composable
+private fun LeadingDecorator(
+    color: Color,
+    textStyle: TypographyKeyTokens,
+    content: (@Composable () -> Unit)?,
+) {
+    if (content != null) {
+        Box(Modifier.padding(end = InteractiveListInternalSpacing)) {
+            // TODO: perhaps also turn off MICS enforcement
+            ProvideContentColorTextStyle(
+                contentColor = color,
+                textStyle = textStyle.value,
+                content = content,
+            )
+        }
+    }
+}
+
+@Composable
+private fun TrailingDecorator(
+    color: Color,
+    textStyle: TypographyKeyTokens,
+    content: (@Composable () -> Unit)?,
+) {
+    if (content != null) {
+        Box(Modifier.padding(start = InteractiveListInternalSpacing)) {
+            // TODO: perhaps also turn off MICS enforcement
+            ProvideContentColorTextStyle(
+                contentColor = color,
+                textStyle = textStyle.value,
+                content = content,
+            )
+        }
+    }
+}
+
+@Composable
+private fun OverlineDecorator(
+    color: Color,
+    textStyle: TypographyKeyTokens,
+    content: (@Composable () -> Unit)?,
+) {
+    if (content != null) {
+        Box {
+            ProvideContentColorTextStyle(
+                contentColor = color,
+                textStyle = textStyle.value,
+                content = content,
+            )
+        }
+    }
+}
+
+@Composable
+private fun SupportingDecorator(
+    color: Color,
+    textStyle: TypographyKeyTokens,
+    content: (@Composable () -> Unit)?,
+) {
+    if (content != null) {
+        Box {
+            ProvideContentColorTextStyle(
+                contentColor = color,
+                textStyle = textStyle.value,
+                content = content,
+            )
+        }
+    }
+}
+
+@Composable
+private fun HeadlineDecorator(
+    color: Color,
+    textStyle: TypographyKeyTokens,
+    content: @Composable () -> Unit,
+) {
+    Box {
+        ProvideContentColorTextStyle(
+            contentColor = color,
+            textStyle = textStyle.value,
+            content = content,
+        )
+    }
+}
+
+/**
+ * Equivalent to [collectIsPressedAsState], [collectIsFocusedAsState], etc. but only uses one
+ * [LaunchedEffect]. The [MutableState] parameters, if provided, will be set to the corresponding
+ * state value.
+ */
+@OptIn(ExperimentalMaterial3ExpressiveApi::class)
+@Composable
+private fun InteractionSource.CollectInteractionsAsState(
+    pressedState: MutableState<Boolean>? = null,
+    focusedState: MutableState<Boolean>? = null,
+    hoveredState: MutableState<Boolean>? = null,
+    draggedState: MutableState<Boolean>? = null,
+) {
+    LaunchedEffect(this) {
+        val pressInteractions = pressedState?.let { mutableListOf<PressInteraction.Press>() }
+        val focusInteractions = focusedState?.let { mutableListOf<FocusInteraction.Focus>() }
+        val hoverInteractions = hoveredState?.let { mutableListOf<HoverInteraction.Enter>() }
+        val dragInteractions = draggedState?.let { mutableListOf<DragInteraction.Start>() }
+
+        interactions.collect { interaction ->
+            when (interaction) {
+                // press
+                is PressInteraction.Press -> pressInteractions?.add(interaction)
+                is PressInteraction.Release -> pressInteractions?.remove(interaction.press)
+                is PressInteraction.Cancel -> pressInteractions?.remove(interaction.press)
+                // focus
+                is FocusInteraction.Focus -> focusInteractions?.add(interaction)
+                is FocusInteraction.Unfocus -> focusInteractions?.remove(interaction.focus)
+                // hover
+                is HoverInteraction.Enter -> hoverInteractions?.add(interaction)
+                is HoverInteraction.Exit -> hoverInteractions?.remove(interaction.enter)
+                // drag
+                is DragInteraction.Start -> dragInteractions?.add(interaction)
+                is DragInteraction.Stop -> dragInteractions?.remove(interaction.start)
+                is DragInteraction.Cancel -> dragInteractions?.remove(interaction.start)
+            }
+            if (pressedState != null && pressInteractions != null) {
+                pressedState.value = pressInteractions.isNotEmpty()
+            }
+            if (focusedState != null && focusInteractions != null) {
+                focusedState.value = focusInteractions.isNotEmpty()
+            }
+            if (hoveredState != null && hoverInteractions != null) {
+                hoveredState.value = hoverInteractions.isNotEmpty()
+            }
+            if (draggedState != null && dragInteractions != null) {
+                draggedState.value = dragInteractions.isNotEmpty()
+            }
+        }
+    }
+}
+
+private data class InteractiveListColorState(
+    val enabled: Boolean,
+    val selected: Boolean,
+    val dragged: Boolean,
+)
+
+@OptIn(ExperimentalMaterial3ExpressiveApi::class)
+@Composable
+private fun InteractiveListItem(
+    modifier: Modifier,
+    headlineContent: @Composable () -> Unit,
+    leadingContent: @Composable (() -> Unit)?,
+    trailingContent: @Composable (() -> Unit)?,
+    overlineContent: @Composable (() -> Unit)?,
+    supportingContent: @Composable (() -> Unit)?,
+    enabled: Boolean,
+    selected: Boolean,
+    applySemantics: SemanticsPropertyReceiver.() -> Unit,
+    onClick: () -> Unit,
+    onLongClick: (() -> Unit)?,
+    onLongClickLabel: String?,
+    interactionSource: MutableInteractionSource?,
+    colors: InteractiveListItemColors,
+    shapes: InteractiveListItemShapes,
+    elevation: InteractiveListItemElevation,
+    contentPadding: PaddingValues,
+) {
+    @Suppress("NAME_SHADOWING")
+    val interactionSource = interactionSource ?: remember { MutableInteractionSource() }
+
+    val pressed = remember { mutableStateOf(false) }
+    val focused = remember { mutableStateOf(false) }
+    val hovered = remember { mutableStateOf(false) }
+    val dragged = remember { mutableStateOf(false) }
+
+    interactionSource.CollectInteractionsAsState(
+        pressedState = pressed,
+        focusedState = focused,
+        hoveredState = hovered,
+        draggedState = dragged,
+    )
+
+    // TODO: Load the motionScheme tokens from the component tokens file
+    val colorAnimationSpec = MotionSchemeKeyTokens.DefaultEffects.value<Color>()
+    val shapeAnimationSpec = MotionSchemeKeyTokens.FastSpatial.value<Float>()
+    val elevationAnimationSpec = MotionSchemeKeyTokens.FastSpatial.value<Dp>()
+
+    val shape =
+        shapes.shapeForInteraction(
+            selected = selected,
+            pressed = pressed.value,
+            focused = focused.value,
+            hovered = hovered.value,
+            dragged = dragged.value,
+            animationSpec = shapeAnimationSpec,
+        )
+
+    val colorState = InteractiveListColorState(enabled, selected, dragged.value)
+    val transition = updateTransition(colorState, "ListColor")
+
+    val containerColor by
+        transition.animateColor(transitionSpec = { colorAnimationSpec }) { state ->
+            colors.containerColor(
+                enabled = state.enabled,
+                selected = state.selected,
+                dragged = state.dragged,
+            )
+        }
+    val contentColor by
+        transition.animateColor(transitionSpec = { colorAnimationSpec }) { state ->
+            colors.headlineColor(
+                enabled = state.enabled,
+                selected = state.selected,
+                dragged = state.dragged,
+            )
+        }
+    val leadingColor by
+        transition.animateColor(transitionSpec = { colorAnimationSpec }) { state ->
+            colors.leadingIconColor(
+                enabled = state.enabled,
+                selected = state.selected,
+                dragged = state.dragged,
+            )
+        }
+    val trailingColor by
+        transition.animateColor(transitionSpec = { colorAnimationSpec }) { state ->
+            colors.trailingIconColor(
+                enabled = state.enabled,
+                selected = state.selected,
+                dragged = state.dragged,
+            )
+        }
+    val overlineColor by
+        transition.animateColor(transitionSpec = { colorAnimationSpec }) { state ->
+            colors.overlineColor(
+                enabled = state.enabled,
+                selected = state.selected,
+                dragged = state.dragged,
+            )
+        }
+    val supportingColor by
+        transition.animateColor(transitionSpec = { colorAnimationSpec }) { state ->
+            colors.supportingTextColor(
+                enabled = state.enabled,
+                selected = state.selected,
+                dragged = state.dragged,
+            )
+        }
+
+    // TODO: load tokens from component tokens file
+    val leadingTextStyle = TypographyKeyTokens.TitleMedium
+    val trailingTextStyle = TypographyKeyTokens.LabelSmall
+    val overlineTextStyle = TypographyKeyTokens.LabelMedium
+    val supportingTextStyle = TypographyKeyTokens.BodyMedium
+    val contentTextStyle = TypographyKeyTokens.BodyLarge
+
+    val targetElevation = if (dragged.value) elevation.draggedElevation else elevation.elevation
+    val shadowElevation = animateDpAsState(targetElevation, elevationAnimationSpec)
+
+    Surface(
+        modifier =
+            modifier
+                .semantics(mergeDescendants = true, properties = applySemantics)
+                .minimumInteractiveComponentSize()
+                // FIXME: we need to clip the ripple without clipping away the shadow applied by
+                //   Surface
+                .combinedClickable(
+                    interactionSource = interactionSource,
+                    indication = ripple(),
+                    enabled = enabled,
+                    onLongClick = onLongClick,
+                    onLongClickLabel = onLongClickLabel,
+                    onClick = onClick,
+                ),
+        shape = shape,
+        color = containerColor,
+        contentColor = contentColor,
+        shadowElevation = shadowElevation.value,
+    ) {
+        val alignmentBreakpoint =
+            (InteractiveListVerticalAlignmentBreakpoint -
+                    contentPadding.calculateTopPadding() -
+                    contentPadding.calculateBottomPadding())
+                .coerceAtLeast(0.dp)
+        InteractiveListItemLayout(
+            modifier = Modifier.padding(contentPadding),
+            alignmentBreakpoint = alignmentBreakpoint,
+            leading = {
+                LeadingDecorator(
+                    color = leadingColor,
+                    textStyle = leadingTextStyle,
+                    content = leadingContent,
+                )
+            },
+            trailing = {
+                TrailingDecorator(
+                    color = trailingColor,
+                    textStyle = trailingTextStyle,
+                    content = trailingContent,
+                )
+            },
+            overline = {
+                OverlineDecorator(
+                    color = overlineColor,
+                    textStyle = overlineTextStyle,
+                    content = overlineContent,
+                )
+            },
+            supporting = {
+                SupportingDecorator(
+                    color = supportingColor,
+                    textStyle = supportingTextStyle,
+                    content = supportingContent,
+                )
+            },
+            headline = {
+                HeadlineDecorator(
+                    color = contentColor,
+                    textStyle = contentTextStyle,
+                    content = headlineContent,
+                )
+            },
+        )
+    }
+}
+
+@Composable
+private fun InteractiveListItemLayout(
+    modifier: Modifier,
+    alignmentBreakpoint: Dp,
+    leading: @Composable () -> Unit,
+    trailing: @Composable () -> Unit,
+    overline: @Composable () -> Unit,
+    supporting: @Composable () -> Unit,
+    headline: @Composable () -> Unit,
+) {
+    val measurePolicy =
+        remember(alignmentBreakpoint) { InteractiveListItemMeasurePolicy(alignmentBreakpoint) }
+    Layout(
+        modifier = modifier,
+        contents = listOf(leading, trailing, overline, supporting, headline),
+        measurePolicy = measurePolicy,
+    )
+}
+
+private class InteractiveListItemMeasurePolicy(val alignmentBreakpoint: Dp) :
+    MultiContentMeasurePolicy {
+    override fun MeasureScope.measure(
+        measurables: List<List<Measurable>>,
+        constraints: Constraints,
+    ): MeasureResult {
+        val (
+            leadingMeasurable,
+            trailingMeasurable,
+            overlineMeasurable,
+            supportingMeasurable,
+            headlineMeasurable,
+        ) = measurables
+
+        val looseConstraints = constraints.copy(minWidth = 0, minHeight = 0)
+        var constraintOffsetX = 0
+        var constraintOffsetY = 0
+
+        val leadingPlaceable = leadingMeasurable.firstOrNull()?.measure(looseConstraints)
+        constraintOffsetX += leadingPlaceable.widthOrZero
+
+        val trailingPlaceable =
+            trailingMeasurable
+                .firstOrNull()
+                ?.measure(looseConstraints.offset(horizontal = -constraintOffsetX))
+        constraintOffsetX += trailingPlaceable.widthOrZero
+
+        val overlinePlaceable =
+            overlineMeasurable
+                .firstOrNull()
+                ?.measure(looseConstraints.offset(horizontal = -constraintOffsetX))
+        constraintOffsetY += overlinePlaceable.heightOrZero
+
+        val headlinePlaceable =
+            headlineMeasurable
+                .firstOrNull()
+                ?.measure(
+                    looseConstraints.offset(
+                        horizontal = -constraintOffsetX,
+                        vertical = -constraintOffsetY,
+                    )
+                )
+        constraintOffsetY += headlinePlaceable.heightOrZero
+
+        val supportingPlaceable =
+            supportingMeasurable
+                .firstOrNull()
+                ?.measure(
+                    looseConstraints.offset(
+                        horizontal = -constraintOffsetX,
+                        vertical = -constraintOffsetY,
+                    )
+                )
+
+        val width =
+            calculateWidth(
+                leadingWidth = leadingPlaceable.widthOrZero,
+                trailingWidth = trailingPlaceable.widthOrZero,
+                overlineWidth = overlinePlaceable.widthOrZero,
+                supportingWidth = supportingPlaceable.widthOrZero,
+                headlineWidth = headlinePlaceable.widthOrZero,
+                constraints = constraints,
+            )
+        val height =
+            calculateHeight(
+                leadingHeight = leadingPlaceable.heightOrZero,
+                trailingHeight = trailingPlaceable.heightOrZero,
+                overlineHeight = overlinePlaceable.heightOrZero,
+                supportingHeight = supportingPlaceable.heightOrZero,
+                headlineHeight = headlinePlaceable.heightOrZero,
+                constraints = constraints,
+            )
+
+        return place(
+            width = width,
+            height = height,
+            leadingPlaceable = leadingPlaceable,
+            trailingPlaceable = trailingPlaceable,
+            headlinePlaceable = headlinePlaceable,
+            overlinePlaceable = overlinePlaceable,
+            supportingPlaceable = supportingPlaceable,
+        )
+    }
+
+    override fun IntrinsicMeasureScope.maxIntrinsicHeight(
+        measurables: List<List<IntrinsicMeasurable>>,
+        width: Int,
+    ): Int = calculateIntrinsicHeight(measurables, width, IntrinsicMeasurable::maxIntrinsicHeight)
+
+    override fun IntrinsicMeasureScope.maxIntrinsicWidth(
+        measurables: List<List<IntrinsicMeasurable>>,
+        height: Int,
+    ): Int = calculateIntrinsicWidth(measurables, height, IntrinsicMeasurable::maxIntrinsicWidth)
+
+    override fun IntrinsicMeasureScope.minIntrinsicHeight(
+        measurables: List<List<IntrinsicMeasurable>>,
+        width: Int,
+    ): Int = calculateIntrinsicHeight(measurables, width, IntrinsicMeasurable::minIntrinsicHeight)
+
+    override fun IntrinsicMeasureScope.minIntrinsicWidth(
+        measurables: List<List<IntrinsicMeasurable>>,
+        height: Int,
+    ): Int = calculateIntrinsicWidth(measurables, height, IntrinsicMeasurable::minIntrinsicWidth)
+
+    private fun calculateIntrinsicWidth(
+        measurables: List<List<IntrinsicMeasurable>>,
+        height: Int,
+        intrinsicMeasure: IntrinsicMeasurable.(height: Int) -> Int,
+    ): Int {
+        val (
+            leadingMeasurable,
+            trailingMeasurable,
+            overlineMeasurable,
+            supportingMeasurable,
+            headlineMeasurable,
+        ) = measurables
+
+        return calculateWidth(
+            leadingWidth = leadingMeasurable.firstOrNull()?.intrinsicMeasure(height) ?: 0,
+            trailingWidth = trailingMeasurable.firstOrNull()?.intrinsicMeasure(height) ?: 0,
+            overlineWidth = overlineMeasurable.firstOrNull()?.intrinsicMeasure(height) ?: 0,
+            supportingWidth = supportingMeasurable.firstOrNull()?.intrinsicMeasure(height) ?: 0,
+            headlineWidth = headlineMeasurable.firstOrNull()?.intrinsicMeasure(height) ?: 0,
+            constraints = Constraints(),
+        )
+    }
+
+    private fun calculateIntrinsicHeight(
+        measurables: List<List<IntrinsicMeasurable>>,
+        width: Int,
+        intrinsicMeasure: IntrinsicMeasurable.(width: Int) -> Int,
+    ): Int {
+        val (
+            leadingMeasurable,
+            trailingMeasurable,
+            overlineMeasurable,
+            supportingMeasurable,
+            headlineMeasurable,
+        ) = measurables
+
+        var remainingWidth = width
+
+        val leadingHeight =
+            leadingMeasurable.firstOrNull()?.let {
+                val height = it.intrinsicMeasure(remainingWidth)
+                remainingWidth =
+                    remainingWidth.subtractConstraintSafely(
+                        it.maxIntrinsicWidth(Constraints.Infinity)
+                    )
+                height
+            } ?: 0
+        val trailingHeight =
+            trailingMeasurable.firstOrNull()?.let {
+                val height = it.intrinsicMeasure(remainingWidth)
+                remainingWidth =
+                    remainingWidth.subtractConstraintSafely(
+                        it.maxIntrinsicWidth(Constraints.Infinity)
+                    )
+                height
+            } ?: 0
+        val overlineHeight = overlineMeasurable.firstOrNull()?.intrinsicMeasure(remainingWidth) ?: 0
+        val supportingHeight =
+            supportingMeasurable.firstOrNull()?.intrinsicMeasure(remainingWidth) ?: 0
+        val headlineHeight = headlineMeasurable.firstOrNull()?.intrinsicMeasure(remainingWidth) ?: 0
+
+        return calculateHeight(
+            leadingHeight = leadingHeight,
+            trailingHeight = trailingHeight,
+            overlineHeight = overlineHeight,
+            supportingHeight = supportingHeight,
+            headlineHeight = headlineHeight,
+            constraints = Constraints(),
+        )
+    }
+
+    private fun MeasureScope.place(
+        width: Int,
+        height: Int,
+        leadingPlaceable: Placeable?,
+        trailingPlaceable: Placeable?,
+        headlinePlaceable: Placeable?,
+        overlinePlaceable: Placeable?,
+        supportingPlaceable: Placeable?,
+    ): MeasureResult {
+        return layout(width, height) {
+            val verticalAlignment =
+                if (height > alignmentBreakpoint.roundToPx()) {
+                    Alignment.Top
+                } else {
+                    Alignment.CenterVertically
+                }
+
+            leadingPlaceable?.placeRelative(
+                x = 0,
+                y = verticalAlignment.align(leadingPlaceable.height, height),
+            )
+
+            val mainContentX = leadingPlaceable.widthOrZero
+            val mainContentTotalHeight =
+                headlinePlaceable.heightOrZero +
+                    overlinePlaceable.heightOrZero +
+                    supportingPlaceable.heightOrZero
+            val mainContentY = verticalAlignment.align(mainContentTotalHeight, height)
+            var currY = mainContentY
+
+            overlinePlaceable?.placeRelative(mainContentX, currY)
+            currY += overlinePlaceable.heightOrZero
+
+            headlinePlaceable?.placeRelative(mainContentX, currY)
+            currY += headlinePlaceable.heightOrZero
+
+            supportingPlaceable?.placeRelative(mainContentX, currY)
+
+            trailingPlaceable?.placeRelative(
+                x = width - trailingPlaceable.width,
+                y = verticalAlignment.align(trailingPlaceable.height, height),
+            )
+        }
+    }
+
+    private fun calculateWidth(
+        leadingWidth: Int,
+        trailingWidth: Int,
+        overlineWidth: Int,
+        supportingWidth: Int,
+        headlineWidth: Int,
+        constraints: Constraints,
+    ): Int {
+        if (constraints.hasBoundedWidth) {
+            return constraints.maxWidth
+        }
+        // Fallback behavior if width constraints are infinite
+        val mainContentWidth = maxOf(headlineWidth, overlineWidth, supportingWidth)
+        return leadingWidth + mainContentWidth + trailingWidth
+    }
+
+    private fun calculateHeight(
+        leadingHeight: Int,
+        trailingHeight: Int,
+        overlineHeight: Int,
+        supportingHeight: Int,
+        headlineHeight: Int,
+        constraints: Constraints,
+    ): Int {
+        val mainContentHeight = headlineHeight + overlineHeight + supportingHeight
+
+        return constraints.constrainHeight(maxOf(leadingHeight, mainContentHeight, trailingHeight))
+    }
+}
+
+// TODO: replace with tokens
+internal val InteractiveListStartPadding = 16.dp
+internal val InteractiveListEndPadding = 16.dp
+internal val InteractiveListTopPadding = 12.dp
+internal val InteractiveListBottomPadding = 12.dp
+internal val InteractiveListInternalSpacing = 12.dp
+internal val InteractiveListDisabledOpacity = 0.38f
+/**
+ * How tall a list item needs to be before internal content is top-aligned instead of
+ * center-aligned.
+ */
+internal val InteractiveListVerticalAlignmentBreakpoint = 80.dp
+
+// TODO: move to defaults
+private val InteractiveListPadding =
+    PaddingValues(
+        start = InteractiveListStartPadding,
+        end = InteractiveListEndPadding,
+        top = InteractiveListTopPadding,
+        bottom = InteractiveListBottomPadding,
+    )
diff --git a/compose/material3/material3/src/commonMain/kotlin/androidx/compose/material3/ModalBottomSheet.kt b/compose/material3/material3/src/commonMain/kotlin/androidx/compose/material3/ModalBottomSheet.kt
index 43e20e3..9ccd938 100644
--- a/compose/material3/material3/src/commonMain/kotlin/androidx/compose/material3/ModalBottomSheet.kt
+++ b/compose/material3/material3/src/commonMain/kotlin/androidx/compose/material3/ModalBottomSheet.kt
@@ -22,13 +22,9 @@
 import androidx.compose.animation.core.animateFloatAsState
 import androidx.compose.foundation.Canvas
 import androidx.compose.foundation.clickable
-import androidx.compose.foundation.gestures.AnchoredDraggableDefaults
-import androidx.compose.foundation.gestures.DraggableAnchors
-import androidx.compose.foundation.gestures.FlingBehavior
 import androidx.compose.foundation.gestures.Orientation
-import androidx.compose.foundation.gestures.ScrollScope
-import androidx.compose.foundation.gestures.anchoredDraggable
 import androidx.compose.foundation.gestures.detectTapGestures
+import androidx.compose.foundation.gestures.draggable
 import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.BoxScope
 import androidx.compose.foundation.layout.Column
@@ -43,8 +39,9 @@
 import androidx.compose.material3.SheetValue.Expanded
 import androidx.compose.material3.SheetValue.Hidden
 import androidx.compose.material3.SheetValue.PartiallyExpanded
+import androidx.compose.material3.internal.DraggableAnchors
 import androidx.compose.material3.internal.Strings
-import androidx.compose.material3.internal.draggableAnchorsV2
+import androidx.compose.material3.internal.draggableAnchors
 import androidx.compose.material3.internal.getString
 import androidx.compose.material3.tokens.MotionSchemeKeyTokens
 import androidx.compose.runtime.Composable
@@ -152,7 +149,7 @@
     }
     val scope = rememberCoroutineScope()
     val animateToDismiss: () -> Unit = {
-        if (sheetState.confirmValueChange(Hidden)) {
+        if (sheetState.anchoredDraggableState.confirmValueChange(Hidden)) {
             scope
                 .launch { sheetState.hide() }
                 .invokeOnCompletion {
@@ -162,6 +159,11 @@
                 }
         }
     }
+    val settleToDismiss: (velocity: Float) -> Unit = {
+        scope
+            .launch { sheetState.settle(it) }
+            .invokeOnCompletion { if (!sheetState.isVisible) onDismissRequest() }
+    }
 
     val predictiveBackProgress = remember { Animatable(initialValue = 0f) }
 
@@ -191,8 +193,8 @@
             ModalBottomSheetContent(
                 predictiveBackProgress,
                 scope,
-                onDismissRequest,
                 animateToDismiss,
+                settleToDismiss,
                 modifier,
                 sheetState,
                 sheetMaxWidth,
@@ -255,8 +257,8 @@
 internal fun BoxScope.ModalBottomSheetContent(
     predictiveBackProgress: Animatable<Float, AnimationVector1D>,
     scope: CoroutineScope,
-    onDismissRequest: () -> Unit,
     animateToDismiss: () -> Unit,
+    settleToDismiss: (velocity: Float) -> Unit,
     modifier: Modifier = Modifier,
     sheetState: SheetState = rememberModalBottomSheetState(),
     sheetMaxWidth: Dp = BottomSheetDefaults.SheetMaxWidth,
@@ -270,27 +272,6 @@
     content: @Composable ColumnScope.() -> Unit,
 ) {
     val bottomSheetPaneTitle = getString(string = Strings.BottomSheetPaneTitle)
-    val anchoredDraggableFlingBehavior =
-        AnchoredDraggableDefaults.flingBehavior(
-            state = sheetState.anchoredDraggableState,
-            positionalThreshold = { _ -> sheetState.positionalThreshold.invoke() },
-            animationSpec = BottomSheetAnimationSpec,
-        )
-    val modalBottomSheetFlingBehavior =
-        remember(anchoredDraggableFlingBehavior) {
-            object : FlingBehavior {
-                override suspend fun ScrollScope.performFling(initialVelocity: Float): Float {
-                    var remainingVelocity = 0f
-                    try {
-                        remainingVelocity =
-                            with(anchoredDraggableFlingBehavior) { performFling(initialVelocity) }
-                    } finally {
-                        if (!sheetState.isVisible) onDismissRequest()
-                    }
-                    return remainingVelocity
-                }
-            }
-        }
 
     Surface(
         modifier =
@@ -305,13 +286,13 @@
                                 ConsumeSwipeWithinBottomSheetBoundsNestedScrollConnection(
                                     sheetState = sheetState,
                                     orientation = Orientation.Vertical,
-                                    flingBehavior = modalBottomSheetFlingBehavior,
+                                    onFling = settleToDismiss,
                                 )
                             }
                         )
                     else Modifier
                 )
-                .draggableAnchorsV2(sheetState.anchoredDraggableState, Orientation.Vertical) {
+                .draggableAnchors(sheetState.anchoredDraggableState, Orientation.Vertical) {
                     sheetSize,
                     constraints ->
                     val fullHeight = constraints.maxHeight.toFloat()
@@ -331,24 +312,24 @@
                             Hidden -> Hidden
                             PartiallyExpanded -> {
                                 val hasPartiallyExpandedState =
-                                    newAnchors.hasPositionFor(PartiallyExpanded)
+                                    newAnchors.hasAnchorFor(PartiallyExpanded)
                                 val newTarget =
                                     if (hasPartiallyExpandedState) PartiallyExpanded
-                                    else if (newAnchors.hasPositionFor(Expanded)) Expanded
-                                    else Hidden
+                                    else if (newAnchors.hasAnchorFor(Expanded)) Expanded else Hidden
                                 newTarget
                             }
                             Expanded -> {
-                                if (newAnchors.hasPositionFor(Expanded)) Expanded else Hidden
+                                if (newAnchors.hasAnchorFor(Expanded)) Expanded else Hidden
                             }
                         }
-                    return@draggableAnchorsV2 newAnchors to newTarget
+                    return@draggableAnchors newAnchors to newTarget
                 }
-                .anchoredDraggable(
-                    state = sheetState.anchoredDraggableState,
+                .draggable(
+                    state = sheetState.anchoredDraggableState.draggableState,
                     orientation = Orientation.Vertical,
-                    enabled = sheetGesturesEnabled && sheetState.currentValue != Hidden,
-                    flingBehavior = modalBottomSheetFlingBehavior,
+                    enabled = sheetGesturesEnabled && sheetState.isVisible,
+                    startDragImmediately = sheetState.anchoredDraggableState.isAnimationRunning,
+                    onDragStopped = { settleToDismiss(it) },
                 )
                 .semantics {
                     paneTitle = bottomSheetPaneTitle
@@ -420,14 +401,22 @@
                                             }
                                             if (currentValue == PartiallyExpanded) {
                                                 expand(expandActionLabel) {
-                                                    if (confirmValueChange(Expanded)) {
+                                                    if (
+                                                        anchoredDraggableState.confirmValueChange(
+                                                            Expanded
+                                                        )
+                                                    ) {
                                                         scope.launch { sheetState.expand() }
                                                     }
                                                     true
                                                 }
                                             } else if (hasPartiallyExpandedState) {
                                                 collapse(collapseActionLabel) {
-                                                    if (confirmValueChange(PartiallyExpanded)) {
+                                                    if (
+                                                        anchoredDraggableState.confirmValueChange(
+                                                            PartiallyExpanded
+                                                        )
+                                                    ) {
                                                         scope.launch { partialExpand() }
                                                     }
                                                     true
diff --git a/compose/material3/material3/src/commonMain/kotlin/androidx/compose/material3/Shapes.kt b/compose/material3/material3/src/commonMain/kotlin/androidx/compose/material3/Shapes.kt
index daf9192..565e6ea 100644
--- a/compose/material3/material3/src/commonMain/kotlin/androidx/compose/material3/Shapes.kt
+++ b/compose/material3/material3/src/commonMain/kotlin/androidx/compose/material3/Shapes.kt
@@ -260,6 +260,8 @@
     internal var defaultIconToggleButtonShapesCached: IconToggleButtonShapes? = null
     @OptIn(ExperimentalMaterial3ExpressiveApi::class)
     internal var defaultIconButtonShapesCached: IconButtonShapes? = null
+    @OptIn(ExperimentalMaterial3ExpressiveApi::class)
+    internal var defaultInteractiveListItemShapesCached: InteractiveListItemShapes? = null
 }
 
 /** Contains the default values used by [Shapes] */
diff --git a/compose/material3/material3/src/commonMain/kotlin/androidx/compose/material3/SheetDefaults.kt b/compose/material3/material3/src/commonMain/kotlin/androidx/compose/material3/SheetDefaults.kt
index ee416eb..dbffe4d 100644
--- a/compose/material3/material3/src/commonMain/kotlin/androidx/compose/material3/SheetDefaults.kt
+++ b/compose/material3/material3/src/commonMain/kotlin/androidx/compose/material3/SheetDefaults.kt
@@ -22,11 +22,7 @@
 import androidx.compose.animation.core.animate
 import androidx.compose.animation.core.snap
 import androidx.compose.animation.core.tween
-import androidx.compose.foundation.gestures.AnchoredDraggableState
-import androidx.compose.foundation.gestures.FlingBehavior
 import androidx.compose.foundation.gestures.Orientation
-import androidx.compose.foundation.gestures.ScrollScope
-import androidx.compose.foundation.gestures.snapTo
 import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.ColumnScope
 import androidx.compose.foundation.layout.WindowInsets
@@ -38,8 +34,11 @@
 import androidx.compose.material3.SheetValue.Expanded
 import androidx.compose.material3.SheetValue.Hidden
 import androidx.compose.material3.SheetValue.PartiallyExpanded
+import androidx.compose.material3.internal.AnchoredDraggableState
 import androidx.compose.material3.internal.Strings
+import androidx.compose.material3.internal.animateTo
 import androidx.compose.material3.internal.getString
+import androidx.compose.material3.internal.snapTo
 import androidx.compose.material3.tokens.ScrimTokens
 import androidx.compose.material3.tokens.SheetBottomTokens
 import androidx.compose.runtime.Composable
@@ -90,8 +89,8 @@
 @ExperimentalMaterial3Api
 class SheetState(
     internal val skipPartiallyExpanded: Boolean,
-    internal val positionalThreshold: () -> Float,
-    internal val velocityThreshold: () -> Float,
+    positionalThreshold: () -> Float,
+    velocityThreshold: () -> Float,
     initialValue: SheetValue = Hidden,
     internal val confirmValueChange: (SheetValue) -> Boolean = { true },
     internal val skipHiddenState: Boolean = false,
@@ -119,10 +118,7 @@
      * was in before the swipe or animation started.
      */
     val currentValue: SheetValue
-        // Note: Current Value is mapping to the newly introduced settled value for roughly
-        // analogous behavior to internal fork. anchoredDraggableState.currentValue now maps to the
-        // value the touch target is closest to, regardless of release/settling.
-        get() = anchoredDraggableState.settledValue
+        get() = anchoredDraggableState.currentValue
 
     /**
      * The target value of the bottom sheet state.
@@ -166,11 +162,11 @@
 
     /** Whether the sheet has an expanded state defined. */
     val hasExpandedState: Boolean
-        get() = anchoredDraggableState.anchors.hasPositionFor(Expanded)
+        get() = anchoredDraggableState.anchors.hasAnchorFor(Expanded)
 
     /** Whether the modal bottom sheet has a partially expanded state defined. */
     val hasPartiallyExpandedState: Boolean
-        get() = anchoredDraggableState.anchors.hasPositionFor(PartiallyExpanded)
+        get() = anchoredDraggableState.anchors.hasAnchorFor(PartiallyExpanded)
 
     /**
      * If [confirmValueChange] returns true, fully expand the bottom sheet with animation and
@@ -270,41 +266,24 @@
         anchoredDraggableState.snapTo(targetValue)
     }
 
+    /**
+     * Find the closest anchor taking into account the velocity and settle at it with an animation.
+     */
+    internal suspend fun settle(velocity: Float) {
+        anchoredDraggableState.settle(velocity)
+    }
+
     internal var anchoredDraggableMotionSpec: AnimationSpec<Float> = BottomSheetAnimationSpec
 
-    @Suppress("Deprecation")
-    internal var anchoredDraggableState: AnchoredDraggableState<SheetValue> =
-        AnchoredDraggableState(initialValue = initialValue, confirmValueChange = confirmValueChange)
-
-    /**
-     * Calculate the new offset for a [delta] to ensure it is coerced in the bounds
-     *
-     * @param delta The delta to be added to the [offset]
-     * @return The coerced offset
-     */
-    internal fun newOffsetForDelta(delta: Float) =
-        ((if (offset.isNaN()) 0f else offset) + delta).coerceIn(
-            anchoredDraggableState.anchors.minPosition(),
-            anchoredDraggableState.anchors.maxPosition(),
+    internal var anchoredDraggableState =
+        AnchoredDraggableState(
+            initialValue = initialValue,
+            animationSpec = { anchoredDraggableMotionSpec },
+            confirmValueChange = confirmValueChange,
+            positionalThreshold = { positionalThreshold() },
+            velocityThreshold = velocityThreshold,
         )
 
-    internal suspend fun anchoredDrag(flingBehavior: FlingBehavior, initialVelocity: Float): Float {
-        var consumedVelocity = 0f
-        anchoredDraggableState.anchoredDrag {
-            val scrollScope =
-                object : ScrollScope {
-                    override fun scrollBy(pixels: Float): Float {
-                        val newOffset = newOffsetForDelta(pixels)
-                        val consumed = newOffset - offset
-                        dragTo(newOffset)
-                        return consumed
-                    }
-                }
-            consumedVelocity = with(flingBehavior) { scrollScope.performFling(initialVelocity) }
-        }
-        return consumedVelocity
-    }
-
     internal val offset: Float
         get() = anchoredDraggableState.offset
 
@@ -469,7 +448,7 @@
 internal fun ConsumeSwipeWithinBottomSheetBoundsNestedScrollConnection(
     sheetState: SheetState,
     orientation: Orientation,
-    flingBehavior: FlingBehavior,
+    onFling: (velocity: Float) -> Unit,
 ): NestedScrollConnection =
     object : NestedScrollConnection {
         override fun onPreScroll(available: Offset, source: NestedScrollSource): Offset {
@@ -496,9 +475,9 @@
         override suspend fun onPreFling(available: Velocity): Velocity {
             val toFling = available.toFloat()
             val currentOffset = sheetState.requireOffset()
-            val minAnchor = sheetState.anchoredDraggableState.anchors.minPosition()
+            val minAnchor = sheetState.anchoredDraggableState.anchors.minAnchor()
             return if (toFling < 0 && currentOffset > minAnchor) {
-                sheetState.anchoredDrag(flingBehavior, toFling)
+                onFling(toFling)
                 // since we go to the anchor with tween settling, consume all for the best UX
                 available
             } else {
@@ -507,9 +486,8 @@
         }
 
         override suspend fun onPostFling(consumed: Velocity, available: Velocity): Velocity {
-            val toFling = available.y
-            val consumedByAnchoredDraggableFling = sheetState.anchoredDrag(flingBehavior, toFling)
-            return Velocity(consumed.x, consumedByAnchoredDraggableFling)
+            onFling(available.toFloat())
+            return available
         }
 
         private fun Float.toOffset(): Offset =
@@ -565,5 +543,5 @@
 private val DragHandleVerticalPadding = 22.dp
 
 /** A function that provides the default animation spec used by [SheetState]. */
-internal val BottomSheetAnimationSpec: AnimationSpec<Float> =
+private val BottomSheetAnimationSpec: AnimationSpec<Float> =
     tween(durationMillis = 300, easing = FastOutSlowInEasing)
diff --git a/compose/material3/material3/src/commonMain/kotlin/androidx/compose/material3/TimePicker.kt b/compose/material3/material3/src/commonMain/kotlin/androidx/compose/material3/TimePicker.kt
index efed2a5..559beca 100644
--- a/compose/material3/material3/src/commonMain/kotlin/androidx/compose/material3/TimePicker.kt
+++ b/compose/material3/material3/src/commonMain/kotlin/androidx/compose/material3/TimePicker.kt
@@ -35,7 +35,9 @@
 import androidx.compose.foundation.focusable
 import androidx.compose.foundation.gestures.detectDragGestures
 import androidx.compose.foundation.gestures.detectTapGestures
+import androidx.compose.foundation.indication
 import androidx.compose.foundation.interaction.MutableInteractionSource
+import androidx.compose.foundation.interaction.PressInteraction
 import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.Column
@@ -122,7 +124,13 @@
 import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.graphics.Shape
 import androidx.compose.ui.graphics.takeOrElse
+import androidx.compose.ui.input.key.Key
+import androidx.compose.ui.input.key.KeyEvent
+import androidx.compose.ui.input.key.KeyEventType
+import androidx.compose.ui.input.key.KeyEventType.Companion.KeyUp
+import androidx.compose.ui.input.key.key
 import androidx.compose.ui.input.key.onKeyEvent
+import androidx.compose.ui.input.key.type
 import androidx.compose.ui.input.key.utf16CodePoint
 import androidx.compose.ui.input.pointer.PointerEvent
 import androidx.compose.ui.input.pointer.PointerEventPass
@@ -142,10 +150,12 @@
 import androidx.compose.ui.node.ModifierNodeElement
 import androidx.compose.ui.node.PointerInputModifierNode
 import androidx.compose.ui.node.Ref
+import androidx.compose.ui.node.currentValueOf
 import androidx.compose.ui.node.requireDensity
 import androidx.compose.ui.platform.InspectorInfo
 import androidx.compose.ui.platform.InspectorValueInfo
 import androidx.compose.ui.platform.LocalDensity
+import androidx.compose.ui.platform.LocalFocusManager
 import androidx.compose.ui.platform.LocalLayoutDirection
 import androidx.compose.ui.platform.debugInspectorInfo
 import androidx.compose.ui.semantics.Role
@@ -1494,10 +1504,12 @@
             SuspendingPointerInputModifierNode {
                 detectTapGestures(
                     onPress = {
+                        currentValueOf(LocalFocusManager).clearFocus()
                         offsetX = it.x
                         offsetY = it.y
                     },
                     onTap = {
+                        currentValueOf(LocalFocusManager).clearFocus()
                         coroutineScope.launch {
                             state.onTap(
                                 it.x,
@@ -1725,6 +1737,7 @@
     var center by remember { mutableStateOf(Offset.Zero) }
     var parentCenter by remember { mutableStateOf(IntOffset.Zero) }
     var boundsInParent by remember { mutableStateOf(Rect.Zero) }
+    val interactionSource = remember { MutableInteractionSource() }
     val scope = rememberCoroutineScope()
     val contentDescription =
         numberContentDescription(
@@ -1743,6 +1756,19 @@
             }
         }
 
+    val onClockTextClick: () -> Unit = {
+        scope.launch {
+            state.onTap(
+                x = center.x,
+                y = center.y,
+                maxDist = maxDist,
+                autoSwitchToMinute = autoSwitchToMinute,
+                center = parentCenter,
+                animationSpec = SnapSpec(),
+            )
+        }
+    }
+
     // TODO Load the motionScheme tokens from the component tokens file
     Box(
         contentAlignment = Alignment.Center,
@@ -1755,19 +1781,28 @@
                 }
                 .minimumInteractiveComponentSize()
                 .size(MinimumInteractiveSize)
-                .focusable()
-                .semantics(mergeDescendants = true) {
-                    onClick {
+                .onKeyEvent {
+                    if (it.type == KeyEventType.KeyDown && it.isEnter) {
+                        // Emit ripple.
+                        scope.launch { interactionSource.emit(PressInteraction.Press(center)) }
+                    }
+                    if (it.isClick) {
+                        onClockTextClick()
+                        // Make sure indication is cleared.
                         scope.launch {
-                            state.onTap(
-                                x = center.x,
-                                y = center.y,
-                                maxDist = maxDist,
-                                autoSwitchToMinute = autoSwitchToMinute,
-                                center = parentCenter,
-                                animationSpec = SnapSpec(),
+                            interactionSource.emit(
+                                PressInteraction.Release(PressInteraction.Press(center))
                             )
                         }
+                        return@onKeyEvent true
+                    }
+                    false
+                }
+                .indication(interactionSource, ripple(radius = MinimumInteractiveSize / 2))
+                .focusable(interactionSource = interactionSource)
+                .semantics(mergeDescendants = true) {
+                    onClick {
+                        onClockTextClick()
                         true
                     }
                     this.selected = selected
@@ -2043,6 +2078,19 @@
     InnerCircle,
 }
 
+private val KeyEvent.isClick: Boolean
+    get() = type == KeyUp && isEnter
+
+private val KeyEvent.isEnter: Boolean
+    get() =
+        when (key) {
+            Key.DirectionCenter,
+            Key.Enter,
+            Key.NumPadEnter,
+            Key.Spacebar -> true
+            else -> false
+        }
+
 // TODO(https://github.com/JetBrains/compose-multiplatform/issues/3373) fix expect composable getter
 @OptIn(ExperimentalMaterial3Api::class)
 internal val defaultTimePickerLayoutType: TimePickerLayoutType
diff --git a/navigationevent/navigationevent-compose/bcv/native/current.txt b/navigationevent/navigationevent-compose/bcv/native/current.txt
index f505d89..3e4bd6b 100644
--- a/navigationevent/navigationevent-compose/bcv/native/current.txt
+++ b/navigationevent/navigationevent-compose/bcv/native/current.txt
@@ -1,5 +1,5 @@
 // Klib ABI Dump
-// Targets: [iosArm64, iosSimulatorArm64, iosX64, linuxArm64, linuxX64, macosArm64, macosX64, mingwX64, tvosArm64, tvosSimulatorArm64, tvosX64, watchosArm32, watchosArm64, watchosDeviceArm64, watchosSimulatorArm64, watchosX64]
+// Targets: [linuxX64.linuxx64Stubs]
 // Rendering settings:
 // - Signature version: 2
 // - Show manifest properties: true
diff --git a/navigationevent/navigationevent-compose/build.gradle b/navigationevent/navigationevent-compose/build.gradle
index 0dc103e..af5ba7e 100644
--- a/navigationevent/navigationevent-compose/build.gradle
+++ b/navigationevent/navigationevent-compose/build.gradle
@@ -37,15 +37,8 @@
         compileSdk = 36
         namespace = "androidx.navigationevent.compose"
     }
-    desktop()
-    mac()
-    linux()
-    ios()
-    watchos()
-    tvos()
-    mingwX64()
-    js()
-    wasmJs()
+    jvmStubs()
+    linuxX64Stubs()
 
     defaultPlatform(PlatformIdentifier.ANDROID)
 
@@ -94,91 +87,16 @@
             }
         }
 
-        nonAndroidMain {
+        commonStubsMain {
             dependsOn(commonMain)
         }
 
-        nonAndroidTest {
-            dependsOn(commonTest)
+        jvmStubsMain {
+            dependsOn(commonStubsMain)
         }
 
-        desktopMain {
-            dependsOn(nonAndroidMain)
-        }
-
-        desktopTest {
-            dependsOn(nonAndroidTest)
-        }
-
-        nativeMain {
-            dependsOn(nonAndroidMain)
-        }
-
-        nativeTest {
-            dependsOn(nonAndroidTest)
-        }
-
-        darwinMain {
-            dependsOn(nativeMain)
-        }
-
-        darwinTest {
-            dependsOn(nativeTest)
-        }
-
-        linuxMain {
-            dependsOn(nativeMain)
-        }
-
-        linuxTest {
-            dependsOn(nativeTest)
-        }
-
-        mingwMain {
-            dependsOn(nativeMain)
-        }
-
-        mingwTest {
-            dependsOn(nativeTest)
-        }
-
-        webMain {
-            dependsOn(nonAndroidMain)
-        }
-
-        webTest {
-            dependsOn(nonAndroidTest)
-            dependencies {
-                implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.9.0")
-                implementation("org.jetbrains.kotlinx:kotlinx-coroutines-test:1.9.0")
-            }
-        }
-
-        wasmJsMain {
-            dependencies {
-                implementation(libs.kotlinXw3c)
-            }
-        }
-
-        targets.configureEach { target ->
-            if (target.platformType == KotlinPlatformType.native) {
-                if (target.konanTarget.family.appleFamily) {
-                    target.compilations["main"].defaultSourceSet.dependsOn(darwinMain)
-                    target.compilations["test"].defaultSourceSet.dependsOn(darwinTest)
-                } else if (target.konanTarget.family == Family.LINUX) {
-                    target.compilations["main"].defaultSourceSet.dependsOn(linuxMain)
-                    target.compilations["test"].defaultSourceSet.dependsOn(linuxTest)
-                } else if (target.konanTarget.family == Family.MINGW) {
-                    target.compilations["main"].defaultSourceSet.dependsOn(mingwMain)
-                    target.compilations["test"].defaultSourceSet.dependsOn(mingwTest)
-                } else {
-                    target.compilations["main"].defaultSourceSet.dependsOn(nativeMain)
-                    target.compilations["test"].defaultSourceSet.dependsOn(nativeTest)
-                }
-            } else if (target.platformType in [KotlinPlatformType.js, KotlinPlatformType.wasm]) {
-                target.compilations["main"].defaultSourceSet.dependsOn(webMain)
-                target.compilations["test"].defaultSourceSet.dependsOn(webTest)
-            }
+        linuxx64StubsMain {
+            dependsOn(commonStubsMain)
         }
     }
 }
diff --git a/navigationevent/navigationevent-compose/src/androidMain/kotlin/androidx/navigationevent/compose/LocalNavigationEventDispatcherOwner.android.kt b/navigationevent/navigationevent-compose/src/androidMain/kotlin/androidx/navigationevent/compose/LocalNavigationEventDispatcherOwner.android.kt
index 575fa47..c20edb1 100644
--- a/navigationevent/navigationevent-compose/src/androidMain/kotlin/androidx/navigationevent/compose/LocalNavigationEventDispatcherOwner.android.kt
+++ b/navigationevent/navigationevent-compose/src/androidMain/kotlin/androidx/navigationevent/compose/LocalNavigationEventDispatcherOwner.android.kt
@@ -22,8 +22,5 @@
 import androidx.navigationevent.findViewTreeNavigationEventDispatcherOwner
 
 @Composable
-internal actual fun findViewTreeNavigationEventDispatcherOwner(): NavigationEventDispatcherOwner? {
-    // On Android, the NavigationEventDispatcherOwner is expected to be
-    // discoverable up the view hierarchy.
-    return LocalView.current.findViewTreeNavigationEventDispatcherOwner()
-}
+internal actual fun findViewTreeNavigationEventDispatcherOwner(): NavigationEventDispatcherOwner? =
+    LocalView.current.findViewTreeNavigationEventDispatcherOwner()
diff --git a/navigationevent/navigationevent-compose/src/nonAndroidMain/kotlin/androidx/navigationevent/compose/LocalNavigationEventDispatcherOwner.nonAndroid.kt b/navigationevent/navigationevent-compose/src/commonStubsMain/kotlin/androidx/navigationevent/compose/LocalNavigationEventDispatcherOwner.commonStubs.kt
similarity index 80%
rename from navigationevent/navigationevent-compose/src/nonAndroidMain/kotlin/androidx/navigationevent/compose/LocalNavigationEventDispatcherOwner.nonAndroid.kt
rename to navigationevent/navigationevent-compose/src/commonStubsMain/kotlin/androidx/navigationevent/compose/LocalNavigationEventDispatcherOwner.commonStubs.kt
index e0c70d9..8196ffe 100644
--- a/navigationevent/navigationevent-compose/src/nonAndroidMain/kotlin/androidx/navigationevent/compose/LocalNavigationEventDispatcherOwner.nonAndroid.kt
+++ b/navigationevent/navigationevent-compose/src/commonStubsMain/kotlin/androidx/navigationevent/compose/LocalNavigationEventDispatcherOwner.commonStubs.kt
@@ -20,8 +20,5 @@
 import androidx.navigationevent.NavigationEventDispatcherOwner
 
 @Composable
-internal actual fun findViewTreeNavigationEventDispatcherOwner(): NavigationEventDispatcherOwner? {
-    // For non-Android platforms (e.g., Desktop, Web), the concept of a
-    // 'ViewTree' doesn't exist in the same way. Therefore, returns null.
-    return null
-}
+internal actual fun findViewTreeNavigationEventDispatcherOwner(): NavigationEventDispatcherOwner? =
+    implementedInJetBrainsFork()
diff --git a/navigationevent/navigationevent-compose/src/commonStubsMain/kotlin/androidx/navigationevent/compose/NotImplemented.commonStubs.kt b/navigationevent/navigationevent-compose/src/commonStubsMain/kotlin/androidx/navigationevent/compose/NotImplemented.commonStubs.kt
new file mode 100644
index 0000000..b6b100c
--- /dev/null
+++ b/navigationevent/navigationevent-compose/src/commonStubsMain/kotlin/androidx/navigationevent/compose/NotImplemented.commonStubs.kt
@@ -0,0 +1,27 @@
+/*
+ * Copyright 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package androidx.navigationevent.compose
+
+@Suppress("NOTHING_TO_INLINE")
+internal inline fun implementedInJetBrainsFork(): Nothing =
+    throw NotImplementedError(
+        """
+        Implemented only in JetBrains fork.
+        Please use `org.jetbrains.navigationevent:navigationevent-compose` package instead.
+        """
+            .trimIndent()
+    )
diff --git a/tracing/tracing-driver/api/current.txt b/tracing/tracing-driver/api/current.txt
index 043ed6f5..db7cdd7 100644
--- a/tracing/tracing-driver/api/current.txt
+++ b/tracing/tracing-driver/api/current.txt
@@ -7,8 +7,12 @@
 
   public class CounterTrack extends androidx.tracing.driver.Track {
     ctor public CounterTrack(String name, androidx.tracing.driver.Track parent);
+    method public final String getName();
+    method public final androidx.tracing.driver.Track getParent();
     method public final void setCounter(double value);
     method public final void setCounter(long value);
+    property public final String name;
+    property public final androidx.tracing.driver.Track parent;
   }
 
   public final class MetadataEntry {
@@ -42,8 +46,12 @@
 
   public class ProcessTrack extends androidx.tracing.driver.SliceTrack {
     ctor public ProcessTrack(androidx.tracing.driver.TraceContext context, int id, String name);
+    method public final int getId();
+    method public final String getName();
     method public androidx.tracing.driver.CounterTrack getOrCreateCounterTrack(String name);
     method public androidx.tracing.driver.ThreadTrack getOrCreateThreadTrack(int id, String name);
+    property public final int id;
+    property public final String name;
   }
 
   public abstract class SliceTrack extends androidx.tracing.driver.Track {
@@ -63,6 +71,12 @@
 
   public class ThreadTrack extends androidx.tracing.driver.SliceTrack {
     ctor public ThreadTrack(int id, String name, androidx.tracing.driver.ProcessTrack process);
+    method public final int getId();
+    method public final String getName();
+    method public final androidx.tracing.driver.ProcessTrack getProcess();
+    property public final int id;
+    property public final String name;
+    property public final androidx.tracing.driver.ProcessTrack process;
   }
 
   public class TraceContext implements java.lang.AutoCloseable {
diff --git a/tracing/tracing-driver/api/restricted_current.txt b/tracing/tracing-driver/api/restricted_current.txt
index 86b6372..71416ad 100644
--- a/tracing/tracing-driver/api/restricted_current.txt
+++ b/tracing/tracing-driver/api/restricted_current.txt
@@ -19,8 +19,12 @@
 
   public class CounterTrack extends androidx.tracing.driver.Track {
     ctor public CounterTrack(String name, androidx.tracing.driver.Track parent);
+    method public final String getName();
+    method public final androidx.tracing.driver.Track getParent();
     method public final void setCounter(double value);
     method public final void setCounter(long value);
+    property public final String name;
+    property public final androidx.tracing.driver.Track parent;
   }
 
   public final class MetadataEntry {
@@ -76,8 +80,12 @@
 
   public class ProcessTrack extends androidx.tracing.driver.SliceTrack {
     ctor public ProcessTrack(androidx.tracing.driver.TraceContext context, int id, String name);
+    method public final int getId();
+    method public final String getName();
     method public androidx.tracing.driver.CounterTrack getOrCreateCounterTrack(String name);
     method public androidx.tracing.driver.ThreadTrack getOrCreateThreadTrack(int id, String name);
+    property public final int id;
+    property public final String name;
   }
 
   @kotlin.PublishedApi internal final class ProtoPool {
@@ -106,6 +114,12 @@
 
   public class ThreadTrack extends androidx.tracing.driver.SliceTrack {
     ctor public ThreadTrack(int id, String name, androidx.tracing.driver.ProcessTrack process);
+    method public final int getId();
+    method public final String getName();
+    method public final androidx.tracing.driver.ProcessTrack getProcess();
+    property public final int id;
+    property public final String name;
+    property public final androidx.tracing.driver.ProcessTrack process;
   }
 
   public class TraceContext implements java.lang.AutoCloseable {
diff --git a/tracing/tracing-driver/src/commonMain/kotlin/androidx/tracing/driver/CounterTrack.kt b/tracing/tracing-driver/src/commonMain/kotlin/androidx/tracing/driver/CounterTrack.kt
index bad373a..2b0bd40 100644
--- a/tracing/tracing-driver/src/commonMain/kotlin/androidx/tracing/driver/CounterTrack.kt
+++ b/tracing/tracing-driver/src/commonMain/kotlin/androidx/tracing/driver/CounterTrack.kt
@@ -19,9 +19,9 @@
 /** [Track] representing a numerical value that can change over the duration of the trace. */
 public open class CounterTrack(
     /** The name of the counter track */
-    private val name: String,
+    public val name: String,
     /** The parent track the counter belongs to. */
-    private val parent: Track,
+    public val parent: Track,
 ) : Track(context = parent.context, uuid = monotonicId()) {
     internal val packetLock = Any()
 
diff --git a/tracing/tracing-driver/src/commonMain/kotlin/androidx/tracing/driver/ProcessTrack.kt b/tracing/tracing-driver/src/commonMain/kotlin/androidx/tracing/driver/ProcessTrack.kt
index d45eb81..f3acff2 100644
--- a/tracing/tracing-driver/src/commonMain/kotlin/androidx/tracing/driver/ProcessTrack.kt
+++ b/tracing/tracing-driver/src/commonMain/kotlin/androidx/tracing/driver/ProcessTrack.kt
@@ -23,9 +23,9 @@
     /** The tracing context. */
     context: TraceContext,
     /** The process id */
-    internal val id: Int,
+    public val id: Int,
     /** The name of the process. */
-    internal val name: String,
+    public val name: String,
 ) : SliceTrack(context = context, uuid = monotonicId()) {
     internal val threads = mutableScatterMapOf<String, ThreadTrack>()
     internal val counters = mutableScatterMapOf<String, CounterTrack>()
@@ -55,21 +55,18 @@
         // Thread ids are only unique for lifetime of the thread and can be potentially reused.
         // Therefore we end up combining the `name` of the thread and its `id` as a key.
         val key = "$id/$name"
-        return threads[key]
-            ?: synchronized(threads) {
-                val track =
-                    threads.getOrPut(key) { ThreadTrack(id = id, name = name, process = this) }
-                check(track.name == name)
-                track
-            }
+        return synchronized(threads) {
+            val track = threads.getOrPut(key) { ThreadTrack(id = id, name = name, process = this) }
+            check(track.name == name)
+            track
+        }
     }
 
     /** @return A [CounterTrack] for a given [ProcessTrack] and the provided counter [name]. */
     public open fun getOrCreateCounterTrack(name: String): CounterTrack {
-        return counters[name]
-            ?: synchronized(counters) {
-                counters.getOrPut(name) { CounterTrack(name = name, parent = this) }
-            }
+        return synchronized(counters) {
+            counters.getOrPut(name) { CounterTrack(name = name, parent = this) }
+        }
     }
 }
 
diff --git a/tracing/tracing-driver/src/commonMain/kotlin/androidx/tracing/driver/ThreadTrack.kt b/tracing/tracing-driver/src/commonMain/kotlin/androidx/tracing/driver/ThreadTrack.kt
index ff1b482..7db6fdc 100644
--- a/tracing/tracing-driver/src/commonMain/kotlin/androidx/tracing/driver/ThreadTrack.kt
+++ b/tracing/tracing-driver/src/commonMain/kotlin/androidx/tracing/driver/ThreadTrack.kt
@@ -19,11 +19,11 @@
 /** [Track] representing a `Thread` in the specified [ProcessTrack]. */
 public open class ThreadTrack(
     /** The thread id. */
-    internal val id: Int,
+    public val id: Int,
     /** The name of the thread. */
-    internal val name: String,
+    public val name: String,
     /** The process track that the thread belongs to. */
-    internal val process: ProcessTrack,
+    public val process: ProcessTrack,
 ) : SliceTrack(context = process.context, uuid = monotonicId()) {
 
     init {
diff --git a/tracing/tracing-driver/src/commonMain/kotlin/androidx/tracing/driver/TraceContext.kt b/tracing/tracing-driver/src/commonMain/kotlin/androidx/tracing/driver/TraceContext.kt
index eb02bc7..d73d080 100644
--- a/tracing/tracing-driver/src/commonMain/kotlin/androidx/tracing/driver/TraceContext.kt
+++ b/tracing/tracing-driver/src/commonMain/kotlin/androidx/tracing/driver/TraceContext.kt
@@ -44,14 +44,12 @@
      *   [TraceContext].
      */
     public open fun getOrCreateProcessTrack(id: Int, name: String): ProcessTrack {
-        val track = processes[id]
-        return track
-            ?: synchronized(processTrackLock) {
-                val track =
-                    processes.getOrPut(id) { ProcessTrack(context = this, id = id, name = name) }
-                check(track.name == name)
-                track
-            }
+        return synchronized(processTrackLock) {
+            val track =
+                processes.getOrPut(id) { ProcessTrack(context = this, id = id, name = name) }
+            check(track.name == name)
+            track
+        }
     }
 
     /** Flushes the trace packets into the underlying [TraceSink]. */
diff --git a/wear/compose/compose-material3/src/androidTest/kotlin/androidx/wear/compose/material3/ScrollIndicatorScreenshotTest.kt b/wear/compose/compose-material3/src/androidTest/kotlin/androidx/wear/compose/material3/ScrollIndicatorScreenshotTest.kt
index 16e2fc5..c35f6ee 100644
--- a/wear/compose/compose-material3/src/androidTest/kotlin/androidx/wear/compose/material3/ScrollIndicatorScreenshotTest.kt
+++ b/wear/compose/compose-material3/src/androidTest/kotlin/androidx/wear/compose/material3/ScrollIndicatorScreenshotTest.kt
@@ -19,10 +19,13 @@
 import android.content.res.Configuration
 import androidx.compose.foundation.background
 import androidx.compose.foundation.layout.PaddingValues
+import androidx.compose.foundation.layout.fillMaxSize
 import androidx.compose.foundation.layout.height
-import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.lazy.LazyColumn
+import androidx.compose.foundation.lazy.rememberLazyListState
 import androidx.compose.runtime.CompositionLocalProvider
 import androidx.compose.testutils.assertAgainstGolden
+import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.platform.LocalConfiguration
@@ -127,24 +130,14 @@
 
     @Test
     fun position_indicator_round_with_slcAndContentPadding() {
-        val screenSizeDp = 250
-
         rule.setContentWithTheme {
-            val currentConfig = LocalConfiguration.current
-            val updatedConfig =
-                Configuration().apply {
-                    setTo(currentConfig)
-                    screenWidthDp = screenSizeDp
-                    screenHeightDp = screenSizeDp
-                    screenLayout = Configuration.SCREENLAYOUT_ROUND_YES
-                }
-            CompositionLocalProvider(LocalConfiguration provides updatedConfig) {
+            ScreenConfiguration(SCREEN_SIZE_LARGE, isRound = true) {
                 val state = rememberScalingLazyListState()
                 ScalingLazyColumn(
+                    modifier = Modifier.fillMaxSize(),
                     state = state,
                     contentPadding = PaddingValues(100.dp),
                     autoCentering = null,
-                    modifier = Modifier.size(screenSizeDp.dp).background(Color.Black),
                 ) {
                     items(6) { Text("item $it", modifier = Modifier.height(70.dp)) }
                 }
@@ -157,6 +150,49 @@
         rule.verifyScreenshot(testName, screenshotRule)
     }
 
+    @Test
+    fun position_indicator_round_with_slc_reverseLayout() {
+        rule.setContentWithTheme {
+            ScreenConfiguration(SCREEN_SIZE_LARGE, isRound = true) {
+                val state = rememberScalingLazyListState()
+                ScalingLazyColumn(
+                    modifier = Modifier.fillMaxSize(),
+                    state = state,
+                    reverseLayout = true,
+                ) {
+                    items(20) { Text("item $it", modifier = Modifier.height(50.dp)) }
+                }
+                ScrollIndicator(state = state, modifier = Modifier.testTag(TEST_TAG))
+            }
+        }
+
+        rule.waitForIdle()
+
+        rule.verifyScreenshot(testName, screenshotRule)
+    }
+
+    @Test
+    fun position_indicator_round_with_lc_reverseLayout() {
+        rule.setContentWithTheme {
+            ScreenConfiguration(SCREEN_SIZE_LARGE, isRound = true) {
+                val state = rememberLazyListState()
+                LazyColumn(
+                    modifier = Modifier.fillMaxSize(),
+                    state = state,
+                    reverseLayout = true,
+                    horizontalAlignment = Alignment.CenterHorizontally,
+                ) {
+                    items(20) { Text("item $it", modifier = Modifier.height(50.dp)) }
+                }
+                ScrollIndicator(state = state, modifier = Modifier.testTag(TEST_TAG))
+            }
+        }
+
+        rule.waitForIdle()
+
+        rule.verifyScreenshot(testName, screenshotRule)
+    }
+
     private fun position_indicator_position_test(
         size: Float,
         position: Float,
diff --git a/wear/compose/compose-material3/src/main/java/androidx/wear/compose/material3/ScrollIndicator.kt b/wear/compose/compose-material3/src/main/java/androidx/wear/compose/material3/ScrollIndicator.kt
index b6e4fdb..107bc2d 100644
--- a/wear/compose/compose-material3/src/main/java/androidx/wear/compose/material3/ScrollIndicator.kt
+++ b/wear/compose/compose-material3/src/main/java/androidx/wear/compose/material3/ScrollIndicator.kt
@@ -168,7 +168,9 @@
  * @param modifier The modifier to be applied to the component
  * @param colors [ScrollIndicatorColors] that will be used to resolve the indicator and track colors
  *   for this [ScrollIndicator].
- * @param reverseDirection Reverses direction of ScrollIndicator if true
+ * @param reverseDirection Reverses direction of ScrollIndicator if true. The default value is
+ *   inferred from the `reverseLayout` property of the provided [ScalingLazyListState], ensuring the
+ *   indicator automatically matches the list's layout direction.
  * @param positionAnimationSpec [AnimationSpec] for position animation. The Position animation is
  *   used for animating changes to the scroll size and position. To disable this animation [snap]
  *   AnimationSpec should be passed instead.
@@ -178,7 +180,7 @@
     state: ScalingLazyListState,
     modifier: Modifier = Modifier,
     colors: ScrollIndicatorColors = ScrollIndicatorDefaults.colors(),
-    reverseDirection: Boolean = false,
+    reverseDirection: Boolean = state.layoutInfo.reverseLayout,
     positionAnimationSpec: AnimationSpec<Float> = ScrollIndicatorDefaults.PositionAnimationSpec,
 ) {
     val overscrollEffect = rememberOverscrollEffect()?.let { it as? OffsetOverscrollEffect }
@@ -281,7 +283,9 @@
  * @param modifier The modifier to be applied to the component
  * @param colors [ScrollIndicatorColors] that will be used to resolve the indicator and track colors
  *   for this [ScrollIndicator].
- * @param reverseDirection Reverses direction of ScrollIndicator if true
+ * @param reverseDirection Reverses direction of ScrollIndicator if true. The default value is
+ *   inferred from the `reverseLayout` property of the provided [LazyListState], ensuring the
+ *   indicator automatically matches the list's layout direction.
  * @param positionAnimationSpec [AnimationSpec] for position animation. The Position animation is
  *   used for animating changes to the scroll size and position. To disable this animation [snap]
  *   AnimationSpec should be passed instead.
@@ -291,7 +295,7 @@
     state: LazyListState,
     modifier: Modifier = Modifier,
     colors: ScrollIndicatorColors = ScrollIndicatorDefaults.colors(),
-    reverseDirection: Boolean = false,
+    reverseDirection: Boolean = state.layoutInfo.reverseLayout,
     positionAnimationSpec: AnimationSpec<Float> = ScrollIndicatorDefaults.PositionAnimationSpec,
 ) {
     val overscrollEffect = rememberOverscrollEffect()?.let { it as? OffsetOverscrollEffect }