Fix all unresolved CodeRabbit comments on this PR:

• Push a commit to this branch (recommended)
• Create a new PR with the fixes

stream-chat-android-compose/src/main/java/io/getstream/chat/android/compose/ui/components/messages/MessageText.kt (1)

184-184: ⚡ Quick win

isInteractiveAt as a pointerInput key restarts the gesture on every recomposition

isInteractiveAt is an inline lambda defined in the calling composable body that captures annotations. Because annotations is produced by styledText.getStringAnnotations(...) without remember, it's a fresh List instance on every recomposition. Since Kotlin lambdas don't override equals, isInteractiveAt is always a new, inequal instance → pointerInput restarts its coroutine on every recomposition, cancelling any in-flight gesture.

The simplest fix is to remember annotations so that the captured reference is stable when styledText hasn't changed:

♻️ Proposed fix

In MessageText, change line 107 from:

-    val annotations = styledText.getStringAnnotations(0, styledText.lastIndex)
+    val annotations = remember(styledText) { styledText.getStringAnnotations(0, styledText.lastIndex) }

This makes annotations the same instance across recompositions while styledText is stable, stabilising the captured closure and preventing spurious pointerInput restarts.

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In
`@stream-chat-android-compose/src/main/java/io/getstream/chat/android/compose/ui/components/messages/MessageText.kt`
at line 184, The pointerInput coroutine is being restarted every recomposition
because the inline lambda isInteractiveAt closes over a freshly created
annotations list; stabilize this by remembering the annotations produced by
styledText.getStringAnnotations(...) inside MessageText (use remember keyed on
styledText) so the closure captures a stable List instance and pointerInput(
onClick, onLongPress, isInteractiveAt ) no longer restarts unnecessarily; update
the code that builds annotations to use remember(styledText) {
styledText.getStringAnnotations(...) } and keep references to isInteractiveAt
and pressIndicator as before.

stream-chat-android-compose/src/main/java/io/getstream/chat/android/compose/ui/util/ModifierUtils.kt (1)

121-134: 🏗️ Heavy lift

Consider migrating passiveRipple from Modifier.composed to Modifier.Node to improve performance in message list rendering.

The official Android Compose documentation confirms that Modifier.Node is "the most performant way to create custom modifiers" and that Modifier.composed should be reserved for cases requiring composable-style construction. Since passiveRipple() is applied to every message bubble in MessageContent and PollMessageContent, migrating to Modifier.Node (implementing PointerInputModifierNode + DelegatableNode for coroutine scope and indication delegation) would eliminate recomposition overhead on every composition pass.

This refactoring can be deferred pending the planned migration to Compose Foundation's LinkAnnotation API (documented in MessageText.kt), but it's worth tracking as a follow-up performance improvement.

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In
`@stream-chat-android-compose/src/main/java/io/getstream/chat/android/compose/ui/util/ModifierUtils.kt`
around lines 121 - 134, The passiveRipple Modifier currently uses
Modifier.composed which causes extra recompositions for every message bubble;
refactor passiveRipple to implement a Modifier.Node-based solution: create a
custom node implementing PointerInputModifierNode (or PointerInputNode) that
owns a MutableInteractionSource and coroutine scope (use DelegatableNode to
delegate indication behavior), move the pointerInput gesture logic
(awaitEachGesture/awaitFirstDown/waitForUpOrCancellation and emitting
PressInteraction events) into the node's pointer handling, and wire the ripple()
indication via the node-based indication API so passiveRipple returns the new
Node-based modifier instead of using Modifier.composed.

Fix all unresolved CodeRabbit comments on this PR:

• Push a commit to this branch (recommended)
• Create a new PR with the fixes

stream-chat-android-compose/src/main/java/io/getstream/chat/android/compose/ui/util/ModifierUtils.kt (1)

121-134: 💤 Low value

Consider migrating passiveRipple to a Modifier.Node implementation for better list performance.

Modifier.composed { ... } creates subcomposition overhead and is no longer recommended for performance-sensitive code. Since this modifier is applied per message bubble across potentially long lists, migrating to Modifier.Node would eliminate this cost. Use SuspendingPointerInputModifierNode (wrapped in a ModifierNodeElement) to handle the gesture logic and emit PressInteraction events, combined with Modifier.indication(source, ripple()) for the ripple effect. The Node-based pattern has been stable since Compose 1.5+ and is the modern approach. Composed still works, so this is deferable—happy to leave for a follow-up.

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In
`@stream-chat-android-compose/src/main/java/io/getstream/chat/android/compose/ui/util/ModifierUtils.kt`
around lines 121 - 134, The passiveRipple Modifier should be migrated from a
composed-based implementation to a Node-based implementation to avoid
subcomposition overhead: replace internal fun Modifier.passiveRipple(): Modifier
= composed { ... } with a ModifierNodeElement that provides a
SuspendingPointerInputModifierNode (or a custom Modifier.Node implementing
PointerInputModifier) which runs the gesture loop (awaitEachGesture,
awaitFirstDown, waitForUpOrCancellation) and emits PressInteraction events to a
remembered MutableInteractionSource via coroutine scope; keep using
Modifier.indication(source, ripple()) (or call indication from the node) to
attach the ripple; ensure the node remembers the MutableInteractionSource and
coroutine scope and properly launches
source.emit(PressInteraction.Press/Release/Cancel) to replicate the existing
behavior from passiveRipple.

stream-chat-android-compose/src/test/kotlin/io/getstream/chat/android/compose/ui/util/PassiveRippleTest.kt (2)

151-167: 💤 Low value

Consider asserting cleanup state in addition to no-crash.

The test verifies the gesture completes without crashing, which is valuable. An optional strengthening would be to attach a MutableInteractionSource you control to the passiveRipple (via a small testable overload, or by reading from the indication chain) and assert that a PressInteraction.Cancel is emitted when the pointer leaves bounds — that would lock in the cancel-vs-release branch as a behavior contract.

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In
`@stream-chat-android-compose/src/test/kotlin/io/getstream/chat/android/compose/ui/util/PassiveRippleTest.kt`
around lines 151 - 167, Update the test in PassiveRippleTest (`drag out of
bounds during gesture does not crash`) to also assert cleanup by supplying a
controllable MutableInteractionSource to the passiveRipple and verifying it
receives a PressInteraction.Cancel when the pointer is moved out of bounds;
specifically, create a MutableInteractionSource, pass it into passiveRipple (or
use a testable overload/wrapper), perform the same touch sequence via
composeTestRule.performTouchInput, then collect emissions from the interaction
source and assert that a PressInteraction.Cancel was emitted (and no
PressInteraction.Release), ensuring the cancel branch is validated.

---

112-149: 💤 Low value

Good coverage of the "consumed-down" branch.

This test confirms that an inner combinedClickable consumes the down so the outer combinedClickable does not fire — and implicitly that the parent's passiveRipple() (which uses awaitFirstDown(requireUnconsumed = true)) won't emit a press for that gesture either. Consider adding a complementary assertion (or a separate test) that verifies the parent's passiveRipple interaction source doesn't emit a PressInteraction in this scenario, since the propagation rule is the main contract beyond stock combinedClickable behavior.

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In
`@stream-chat-android-compose/src/test/kotlin/io/getstream/chat/android/compose/ui/util/PassiveRippleTest.kt`
around lines 112 - 149, Add an assertion that the parent's passiveRipple
interaction source emits no PressInteraction when the inner clickable consumes
the down: create a MutableInteractionSource instance (e.g.,
parentInteractionSource = MutableInteractionSource()), pass it into the outer
Modifier.passiveRipple(interactionSource = parentInteractionSource) so the test
can observe interactions, perform the same touch on the "consumer" node, and
then collect/inspect parentInteractionSource.interactions (or snapshot its
events) to verify no PressInteraction was emitted; update PassiveRippleTest (the
`inner consuming clickable does not trigger outer combinedClickable` test) to
include this check after performing the touch.

stream-chat-android-compose/src/test/kotlin/io/getstream/chat/android/compose/ui/components/messages/MessageTextTest.kt (1)

35-58: 🏗️ Heavy lift

Add one interaction test for the new pointer-input contract.

These snapshots lock down rendering, but the risky change in this PR is gesture routing: non-interactive presses should bubble to the cell, while interactive presses/long-presses must be consumed locally. A small compose interaction test around MessageText would cover the regression surface that snapshots and helper-unit tests miss.

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In
`@stream-chat-android-compose/src/test/kotlin/io/getstream/chat/android/compose/ui/components/messages/MessageTextTest.kt`
around lines 35 - 58, Add a Compose interaction test in MessageTextTest (next to
existing tests like `plain text`, `text with url`, etc.) that exercises the
pointer-input contract on the MessageText composable(s) (e.g., MessageTextPlain
or MessageTextWithUrl): use the Compose testing APIs to perform a tap and a
long-press on the MessageText node and assert that interactive targets
(links/mentions) consume the gestures locally while non-interactive areas allow
the gesture to bubble (e.g., to the surrounding cell). Name the new test clearly
(e.g., `pointer input contract`) and reuse the existing snapshot scaffolding
(`snapshotWithDarkModeRow`) to host the composable so the test focuses on
gesture routing assertions rather than rendering.