@cometchat/skills 4.4.2 → 5.0.1

package/skills/cometchat-android-v6-calls/references/ringing-integration.md

@@ -1,176 +0,0 @@
-# Ringing — call signaling with custom UI (Android V6 / Compose)
-
-V5 has the canonical Android ringing reference. V6 keeps the same SDK API; only the UI layer changes (Compose vs XML Views).
-
-**Read first:**
-- `cometchat-android-v5-calls/references/ringing-integration.md` — canonical Android (full SDK flow)
-- `cometchat-react-calls/references/ringing-integration.md` — architecture + hard rules
-
----
-
-## ViewModel
-
-```kotlin
-data class CallSignalingState(
-  val incoming: Call? = null,
-  val outgoing: Call? = null,
-  val activeSessionId: String? = null,
-)
-
-class CallSignalingViewModel : ViewModel(), CometChat.CallListener {
-  private val _state = MutableStateFlow(CallSignalingState())
-  val state: StateFlow<CallSignalingState> = _state
-
-  init {
-    CometChat.addCallListener("app", this)
-  }
-
-  override fun onIncomingCallReceived(call: Call) {
-    Handler(Looper.getMainLooper()).post {
-      _state.update { it.copy(incoming = call) }
-    }
-  }
-
-  override fun onOutgoingCallAccepted(call: Call) {
-    Handler(Looper.getMainLooper()).post {
-      _state.update { it.copy(outgoing = null, activeSessionId = call.sessionId) }
-    }
-  }
-
-  override fun onOutgoingCallRejected(call: Call) {
-    Handler(Looper.getMainLooper()).post {
-      _state.update { it.copy(outgoing = null) }
-    }
-  }
-
-  override fun onIncomingCallCancelled(call: Call) {
-    Handler(Looper.getMainLooper()).post {
-      _state.update { it.copy(incoming = null) }
-    }
-  }
-
-  override fun onCallEndedMessageReceived(call: Call) {
-    Handler(Looper.getMainLooper()).post {
-      _state.update { CallSignalingState() }
-    }
-  }
-
-  fun initiate(receiverUid: String, type: String) {
-    val call = Call(receiverUid, type, CometChatConstants.RECEIVER_TYPE_USER)
-    CometChat.initiateCall(call, object : CometChat.CallbackListener<Call>() {
-      override fun onSuccess(outgoing: Call) {
-        _state.update { it.copy(outgoing = outgoing) }
-      }
-      override fun onError(e: CometChatException) { Log.e("App", "Initiate failed", e) }
-    })
-  }
-
-  fun accept(call: Call) {
-    CometChat.acceptCall(call.sessionId, object : CometChat.CallbackListener<Call>() {
-      override fun onSuccess(accepted: Call) {
-        _state.update { it.copy(incoming = null, activeSessionId = accepted.sessionId) }
-      }
-      override fun onError(e: CometChatException) {}
-    })
-  }
-
-  fun reject(call: Call) {
-    CometChat.rejectCall(call.sessionId, CometChatConstants.CALL_STATUS_REJECTED, null)
-    _state.update { it.copy(incoming = null) }
-  }
-
-  override fun onCleared() {
-    CometChat.removeCallListener("app")
-  }
-}
-```
-
----
-
-## Compose incoming-call overlay
-
-```kotlin
-@Composable
-fun CallSignalingOverlay(viewModel: CallSignalingViewModel = viewModel()) {
-  val state by viewModel.state.collectAsStateWithLifecycle()
-
-  state.incoming?.let { call ->
-    Dialog(onDismissRequest = { viewModel.reject(call) }) {
-      Surface(
-        modifier = Modifier.fillMaxSize(),
-        color = Color.Black.copy(alpha = 0.85f),
-      ) {
-        Column(
-          modifier = Modifier.fillMaxSize(),
-          horizontalAlignment = Alignment.CenterHorizontally,
-          verticalArrangement = Arrangement.Center,
-        ) {
-          AsyncImage(
-            model = call.callInitiator?.avatar,
-            contentDescription = null,
-            modifier = Modifier.size(120.dp).clip(CircleShape),
-          )
-          Spacer(Modifier.height(16.dp))
-          Text(
-            call.callInitiator?.name ?: "Unknown",
-            style = MaterialTheme.typography.titleLarge,
-            color = Color.White,
-          )
-          Text("Incoming ${call.type} call", color = Color.White.copy(alpha = 0.7f))
-          Spacer(Modifier.height(32.dp))
-          Row(horizontalArrangement = Arrangement.spacedBy(32.dp)) {
-            FloatingActionButton(
-              onClick = { viewModel.reject(call) },
-              containerColor = Color.Red,
-              modifier = Modifier.semantics { contentDescription = "Decline call" },
-            ) { Icon(Icons.Default.CallEnd, contentDescription = null, tint = Color.White) }
-            FloatingActionButton(
-              onClick = { viewModel.accept(call) },
-              containerColor = Color.Green,
-              modifier = Modifier.semantics { contentDescription = "Accept call" },
-            ) { Icon(Icons.Default.Call, contentDescription = null, tint = Color.White) }
-          }
-        }
-      }
-    }
-  }
-}
-```
-
-Mount above your nav graph in `MainActivity.setContent` so it surfaces over any screen.
-
----
-
-## Backgrounded ring — ConnectionService + FCM (mandatory)
-
-The Compose overlay only fires when the app is foreground. For backgrounded/killed-app ring delivery, FCM data-message → ConnectionService → OS-level UI. See `cometchat-android-v6-calls/references/server-fcm-voip.md`.
-
----
-
-## Anti-patterns
-
-V5 sister rules apply, plus V6-specific:
-
-1. **`collectAsState()` instead of `collectAsStateWithLifecycle()`.** State updates while paused.
-2. **Listener registered in a Composable.** Disposes on recomposition; use a ViewModel or Application-scoped class.
-3. **Forgetting `Handler(Looper.getMainLooper()).post`.** SDK fires off main thread; StateFlow updates from background are fine but Compose recompositions need main.
-
----
-
-## Verification checklist
-
-- [ ] ViewModel implements `CometChat.CallListener` and registers in init
-- [ ] `onCleared` calls `removeCallListener`
-- [ ] All state updates dispatched to main thread
-- [ ] `Dialog`-based overlay mounts above nav graph in MainActivity
-- [ ] FCM + ConnectionService handles backgrounded ring (V5 sister)
-- [ ] Real-device smoke: foreground + backgrounded + killed-app ring
-
----
-
-## Pointers
-
-- `cometchat-android-v5-calls/references/ringing-integration.md` — canonical Android (V5 Views patterns)
-- `cometchat-android-v6-calls/SKILL.md` — V6 architecture
-- `cometchat-android-v6-calls/references/server-fcm-voip.md` — Compose IncomingCallActivity for backgrounded ring
-- Canonical docs: https://www.cometchat.com/docs/calls/android/ringing

package/skills/cometchat-android-v6-calls/references/server-fcm-voip.md

@@ -1,127 +0,0 @@
-# Server-side FCM HTTP v1 for Android V6 VoIP push
-
-V5 has the canonical server template; V6 adds Compose-specific receiver patterns. The FCM payload + HTTP v1 API are unchanged from V5.
-
-**Canonical docs:** https://firebase.google.com/docs/cloud-messaging/migrate-v1
-**Read first:** `cometchat-android-v5-calls/references/server-fcm-voip.md` — full Node + Python templates, hard rules, webhook shape.
-
----
-
-## V6 receiver-side delta
-
-V5 patterns work on V6 (Compose calls bundle into chatuikit-{compose,kotlin}-android, but the FCM data-message reception is in a regular Service so Compose doesn't change anything there). One V6 nicety: surface the incoming-call UI through a Compose Activity that's launched in the foreground.
-
-```kotlin
-class VoipMessagingService : FirebaseMessagingService() {
-  override fun onMessageReceived(message: RemoteMessage) {
-    val data = message.data
-    if (data["type"] != "incoming_call") return
-
-    // V6: launch IncomingCallActivity (a Compose Activity) directly when the
-    // app is in the foreground; otherwise route through ConnectionService
-    // for the OS-level UI.
-    val isAppInForeground = ProcessLifecycleOwner.get().lifecycle.currentState
-      .isAtLeast(Lifecycle.State.STARTED)
-
-    if (isAppInForeground) {
-      val intent = Intent(this, IncomingCallActivity::class.java).apply {
-        addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TASK)
-        putExtra("sessionId", data["sessionId"])
-        putExtra("callerName", data["callerName"])
-        putExtra("callType", data["callType"])
-      }
-      startActivity(intent)
-    } else {
-      // V5 ConnectionService path — see V5 sister doc
-      val telecom = getSystemService(Context.TELECOM_SERVICE) as TelecomManager
-      // ... addNewIncomingCall flow
-    }
-  }
-}
-```
-
----
-
-## Compose IncomingCallActivity (V6 specific)
-
-```kotlin
-class IncomingCallActivity : ComponentActivity() {
-  override fun onCreate(savedInstanceState: Bundle?) {
-    super.onCreate(savedInstanceState)
-
-    // Allow showing over lock screen
-    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O_MR1) {
-      setShowWhenLocked(true)
-      setTurnScreenOn(true)
-      val keyguard = getSystemService(KEYGUARD_SERVICE) as KeyguardManager
-      keyguard.requestDismissKeyguard(this, null)
-    } else {
-      window.addFlags(
-        WindowManager.LayoutParams.FLAG_SHOW_WHEN_LOCKED or
-        WindowManager.LayoutParams.FLAG_TURN_SCREEN_ON or
-        WindowManager.LayoutParams.FLAG_DISMISS_KEYGUARD
-      )
-    }
-
-    val sessionId = intent.getStringExtra("sessionId") ?: return finish()
-    val callerName = intent.getStringExtra("callerName") ?: ""
-    val callType = intent.getStringExtra("callType") ?: "audio"
-
-    setContent {
-      AppTheme {
-        IncomingCallScreen(
-          callerName = callerName,
-          callType = callType,
-          onAccept = {
-            // Hand off to the kit's call surface
-            val callIntent = Intent(this, ActiveCallActivity::class.java).apply {
-              putExtra("sessionId", sessionId)
-            }
-            startActivity(callIntent)
-            finish()
-          },
-          onReject = {
-            // Notify CometChat backend
-            CometChat.rejectCall(sessionId, ...)
-            finish()
-          },
-        )
-      }
-    }
-  }
-}
-```
-
-Key V6 deltas vs V5:
-- `setShowWhenLocked(true)` instead of `FLAG_SHOW_WHEN_LOCKED` (V5 uses the deprecated flag)
-- `setContent { ... }` for Compose UI vs XML layout
-- Compose Activity transitions are smoother — no XML inflation lag
-
----
-
-## Anti-patterns
-
-V5 sister rules apply, plus V6-specific:
-
-1. **Calling `setContent` before `setShowWhenLocked`.** UI flashes briefly before the keyguard layer applies.
-2. **Forgetting `requestDismissKeyguard`.** Lock screen still shows behind your call UI.
-3. **Mixing `IncomingCallActivity` (foreground path) and `ConnectionService` (background path).** Pick the right one based on app state — V6 still benefits from V5's ConnectionService path for true background.
-
----
-
-## Verification checklist
-
-- [ ] V5 server template (Node/Python) — see V5 sister
-- [ ] FCM data message lands at `VoipMessagingService.onMessageReceived` regardless of app state
-- [ ] Foreground: `IncomingCallActivity` launches with show-when-locked
-- [ ] Background/killed: ConnectionService path surfaces OS-level UI
-- [ ] Real-device smoke: 3 cohorts (foreground, backgrounded, killed) all ring
-
----
-
-## Pointers
-
-- `cometchat-android-v5-calls/references/server-fcm-voip.md` — V5 sister (canonical server template)
-- `cometchat-android-v6-calls/SKILL.md` — V6 architecture
-- `cometchat-android-v6-calls/references/incoming-call-overlay.md` — Compose overlay patterns
-- FCM HTTP v1: https://firebase.google.com/docs/cloud-messaging/migrate-v1

package/skills/cometchat-android-v6-calls/references/share-invite.md

@@ -1,105 +0,0 @@
-# Share invite on Android V6 (Compose)
-
-Same SDK + Intent pattern as V5; Compose adds an idiomatic LocalContext-based share trigger and ViewModel state for in-flight indication.
-
-**Canonical docs:** https://www.cometchat.com/docs/calls/android/share-invite
-**Read first:** `cometchat-android-v5-calls/references/share-invite.md` — App Links setup + Intent.createChooser pattern.
-
----
-
-## ViewModel
-
-```kotlin
-class ShareInviteViewModel : ViewModel() {
-  private val _sharing = MutableStateFlow(false)
-  val sharing: StateFlow<Boolean> = _sharing
-
-  fun share(context: Context, sessionId: String) {
-    if (_sharing.value) return
-    _sharing.value = true
-    try {
-      val url = "https://yourapp.com/call/$sessionId"
-      val intent = Intent(Intent.ACTION_SEND).apply {
-        type = "text/plain"
-        putExtra(Intent.EXTRA_SUBJECT, "Join my call")
-        putExtra(Intent.EXTRA_TEXT, "I'm on a call — tap to join.\n$url")
-      }
-      context.startActivity(Intent.createChooser(intent, "Share call invite"))
-    } finally {
-      _sharing.value = false
-    }
-  }
-}
-```
-
-`Context` is short-lived per call — pass via composable arg, don't keep in the ViewModel field.
-
----
-
-## Compose share button
-
-```kotlin
-@Composable
-fun ShareInviteButton(
-  sessionId: String,
-  viewModel: ShareInviteViewModel = viewModel(),
-) {
-  val context = LocalContext.current
-  val sharing by viewModel.sharing.collectAsStateWithLifecycle()
-
-  IconButton(
-    onClick = { viewModel.share(context, sessionId) },
-    enabled = !sharing,
-  ) {
-    if (sharing) {
-      CircularProgressIndicator(modifier = Modifier.size(24.dp), strokeWidth = 2.dp)
-    } else {
-      Icon(Icons.Default.Share, contentDescription = "Share invite")
-    }
-  }
-}
-```
-
----
-
-## Bridge from SDK event
-
-```kotlin
-override fun onShareInviteButtonClicked() {
-  val ctx = activityRef.get() ?: return
-  Handler(Looper.getMainLooper()).post {
-    shareInviteViewModel.share(ctx, sessionId)
-  }
-}
-```
-
-`activityRef` should be a `WeakReference<Activity>` set when the call starts and cleared in onPause/onDestroy.
-
----
-
-## Anti-patterns
-
-V5 sister rules apply, plus Compose-specific:
-
-1. **Storing `Context` in ViewModel field.** Leak after rotation; ViewModels survive config changes but Activities don't.
-2. **`collectAsState()` instead of `collectAsStateWithLifecycle()`.** Wasted work while paused.
-3. **Strong activity reference in CallsEventsListener.** Use `WeakReference` or pass via `LocalContext.current` from the composable.
-
----
-
-## Verification checklist
-
-- [ ] `Context` passed via composable arg, not stored in ViewModel
-- [ ] `WeakReference<Activity>` for SDK callback bridge
-- [ ] `collectAsStateWithLifecycle` for sharing state
-- [ ] `Intent.createChooser` (not raw ACTION_SEND)
-- [ ] App URL via `BuildConfig.APP_URL`
-- [ ] Real-device smoke: same as V5
-
----
-
-## Pointers
-
-- `cometchat-android-v5-calls/references/share-invite.md` — V5 sister (Views patterns)
-- `cometchat-android-v6-calls` SKILL.md
-- Canonical docs: https://www.cometchat.com/docs/calls/android/share-invite

package/skills/cometchat-android-v6-compose-theming/SKILL.md

@@ -1,250 +0,0 @@
----
-name: cometchat-android-v6-compose-theming
-description: "CometChat Android UIKit v6 Jetpack Compose theming — CometChatTheme, CompositionLocal color schemes, typography, shapes, and dark mode"
-license: "MIT"
-compatibility: "Android 9.0+ (API 28); Kotlin 1.9+; com.cometchat:chatuikit-compose-android:6.x"
-metadata:
-  author: "CometChat"
-  version: "3.0.0"
-  tags: "cometchat, android, compose, theming, colors, typography, dark-mode"
----
-
-> **Ground truth:** `com.cometchat:chatuikit-{compose,kotlin}-android:6.x` (+ `calls-sdk-android:5.x`) — resolved AAR (javap) + `ui-kit/android/v6`. **Official docs:** https://www.cometchat.com/docs/ui-kit/android/v6/overview · **Docs MCP:** `claude mcp add --transport http cometchat-docs https://www.cometchat.com/docs/mcp` (or fetch the URL directly without MCP). Verify symbols against the installed package/source before relying on them.
-
-> **Companion skills:** cometchat-android-v6-kotlin-theming (Views equivalent), cometchat-android-v6-compose-components, cometchat-android-v6-compose-customization
-
-## Purpose
-
-Apply and customize the CometChat theme in Jetpack Compose — color schemes, typography, shapes, dark mode, and per-component style overrides using the `CompositionLocal`-based theme system.
-
-## Use this skill when
-
-- Wrapping CometChat components in `CometChatTheme {}`
-- Changing the primary color or color scheme
-- Implementing dark mode support
-- Customizing typography or shapes
-- Accessing theme tokens in custom composables
-
-## Do not use this skill when
-
-- Working with Kotlin Views theming (use `cometchat-android-v6-kotlin-theming`)
-- Customizing bubble rendering (use `cometchat-android-v6-compose-customization`)
-
-## 1. CometChatTheme Wrapper
-
-All CometChat Compose components must be wrapped in `CometChatTheme {}`:
-
-```kotlin
-import com.cometchat.uikit.compose.theme.CometChatTheme
-
-setContent {
-    CometChatTheme {
-        // CometChat components go here
-        CometChatConversations()
-    }
-}
-```
-
-`CometChatTheme` is a composable that provides theme values via `CompositionLocalProvider`:
-- `LocalColorScheme` → `CometChatColorScheme`
-- `LocalTypography` → `CometChatTypography`
-- `LocalShapes` → `Shapes`
-
-## 2. Color Scheme
-
-### 2.1 Default Light/Dark Schemes
-
-```kotlin
-import com.cometchat.uikit.compose.theme.*
-
-// Light mode (default)
-CometChatTheme(colorScheme = lightColorScheme()) {
-    // ...
-}
-
-// Dark mode
-CometChatTheme(colorScheme = darkColorScheme()) {
-    // ...
-}
-
-// Auto based on system setting
-CometChatTheme(
-    colorScheme = if (isSystemInDarkTheme()) darkColorScheme() else lightColorScheme()
-) {
-    // ...
-}
-```
-
-### 2.2 Custom Primary Color
-
-```kotlin
-CometChatTheme(
-    colorScheme = lightColorScheme(primary = Color(0xFF6851D6))
-) {
-    // All extended primary colors (50-900) auto-generate from the primary
-}
-```
-
-### 2.3 CometChatColorScheme Token Reference
-
-The `CometChatColorScheme` class contains these token groups:
-
-**Primary Colors:**
-- `primary` — Main brand color
-
-**Extended Primary (auto-generated from primary):**
-- `extendedPrimaryColor50` through `extendedPrimaryColor900` — 10 shades blended with white (light) or black (dark)
-
-**Neutral Colors:**
-- `neutralColor50` through `neutralColor900` — 10 neutral shades
-
-**Alert Colors:**
-- `infoColor`, `successColor`, `warningColor`, `errorColor`, `messageReadColor`
-
-**Background Colors:**
-- `backgroundColor1` (lightest) through `backgroundColor4` (darkest)
-
-**Stroke/Border Colors:**
-- `strokeColorDefault`, `strokeColorLight`, `strokeColorDark`, `strokeColorHighlight`
-- Aliases: `borderColorLight`, `borderColorDefault`, `borderColorDark`, `borderColorHighlight`
-
-**Text Colors:**
-- `textColorPrimary`, `textColorSecondary`, `textColorTertiary`, `textColorDisabled`, `textColorWhite`, `textColorHighlight`
-
-**Icon Tint Colors:**
-- `iconTintPrimary`, `iconTintSecondary`, `iconTintTertiary`, `iconTintWhite`, `iconTintHighlight`
-
-**Button Colors:**
-- `primaryButtonBackgroundColor`, `primaryButtonIconTint`, `primaryButtonTextColor`
-- `secondaryButtonBackgroundColor`, `secondaryButtonIconTint`, `secondaryButtonTextColor`
-- `linkButtonColor`, `fabButtonBackgroundColor`, `fabButtonIconTint`, `whiteButtonPressed`
-
-**Static Colors:**
-- `colorWhite`, `colorBlack`
-
-### 2.4 Fully Custom Color Scheme
-
-```kotlin
-val customScheme = lightColorScheme(
-    primary = Color(0xFF6851D6),
-    neutralColor50 = Color(0xFFFAFAFA),
-    neutralColor900 = Color(0xFF141414),
-    errorColor = Color(0xFFFF3B30),
-    successColor = Color(0xFF34C759),
-    // ... override any token
-)
-
-CometChatTheme(colorScheme = customScheme) {
-    // ...
-}
-```
-
-## 3. Typography
-
-```kotlin
-// Access typography in composables
-val style: TextStyle = CometChatTheme.typography.heading1Bold
-val bodyStyle: TextStyle = CometChatTheme.typography.bodyRegular
-val titleStyle: TextStyle = CometChatTheme.typography.titleRegular
-```
-
-Custom typography:
-
-```kotlin
-CometChatTheme(
-    typography = CometChatTypography(/* custom TextStyles */)
-) {
-    // ...
-}
-```
-
-## 4. Shapes
-
-```kotlin
-// Access shapes
-val shapes: Shapes = CometChatTheme.shapes
-
-// Custom shapes
-CometChatTheme(
-    shapes = Shapes(/* custom corner radii */)
-) {
-    // ...
-}
-```
-
-## 5. Accessing Theme in Custom Composables
-
-```kotlin
-@Composable
-fun MyCustomView() {
-    val colors = CometChatTheme.colorScheme
-    val typography = CometChatTheme.typography
-
-    Text(
-        text = "Hello",
-        color = colors.textColorPrimary,
-        style = typography.bodyRegular
-    )
-
-    Box(
-        modifier = Modifier.background(colors.backgroundColor1)
-    )
-}
-```
-
-## 6. Extended Primary Color Generation
-
-Extended primary colors are auto-generated by blending the primary color with white (light mode) or black (dark mode):
-
-```kotlin
-// Light mode: primary blended with white at various percentages
-// extendedPrimaryColor50 = blend(primary, white, 0.96)  // lightest
-// extendedPrimaryColor500 = blend(primary, white, 0.44) // mid
-// extendedPrimaryColor900 = blend(primary, black, 0.08) // darkest
-
-// Dark mode: primary blended with black at various percentages
-// extendedPrimaryColor50 = blend(primary, black, 0.80)  // lightest
-// extendedPrimaryColor900 = blend(primary, white, 0.11) // lightest in dark
-```
-
-You can override individual extended colors:
-
-```kotlin
-lightColorScheme(
-    primary = Color(0xFF6851D6),
-    extendedPrimaryColor500 = Color(0xFF9B8AE0) // manual override
-)
-```
-
-## Localization
-
-To translate the UI, switch the active language, or override individual strings, route to the dedicated **`cometchat-i18n`** skill — the canonical cross-family localization reference. Android uses `CometChatLocalize.setLocale(context, Language.Code.<lang>)` / `getLocale(context)` (a separate method, **not** an `init` object — unlike web/RN). `cometchat-i18n` covers bundled languages, custom translations, and RTL. Docs: https://www.cometchat.com/docs/ui-kit/android/localize
-
-## Sound Manager — custom notification & call sounds
-
-Sounds are a **behavioral** customization — driven by `CometChatSoundManager`, an **instance** class that needs a `Context`. The UI Kit plays the built-in cues automatically; use this to override a cue with your own raw resource. V6 package (NOT the V5 `com.cometchat.chatuikit.*` path):
-
-```kotlin
-import com.cometchat.uikit.core.resources.soundmanager.CometChatSoundManager
-import com.cometchat.uikit.core.resources.soundmanager.Sound
-
-val soundManager = CometChatSoundManager(context)
-
-// Play a default cue — Sound enum is SCREAMING_SNAKE_CASE: INCOMING_CALL |
-//   OUTGOING_CALL | INCOMING_MESSAGE | INCOMING_MESSAGE_FROM_OTHER | OUTGOING_MESSAGE
-soundManager.play(Sound.INCOMING_CALL)
-
-// Override with your own raw resource (R.raw.*)
-soundManager.play(Sound.INCOMING_MESSAGE, R.raw.my_ping)
-
-// Stop whatever is playing
-soundManager.pause()
-```
-
-## Hard rules
-
-- ALWAYS wrap CometChat Compose components in `CometChatTheme {}` — components will crash or look wrong without it
-- NEVER use Material `MaterialTheme` tokens inside CometChat components — use `CometChatTheme.colorScheme` / `.typography` / `.shapes`
-- `CometChatTheme` does NOT extend `MaterialTheme` — they are separate theme systems
-- When overriding just the primary color, extended primary colors auto-regenerate — you don't need to set all 10 shades
-- `lightColorScheme()` and `darkColorScheme()` are factory functions, not data class constructors — use named parameters to override specific tokens