@cometchat/skills 4.2.0 → 4.3.0

package/skills/cometchat-android-v6-core/SKILL.md

@@ -90,14 +90,17 @@ Duplicate class android.support.v4.os.ResultReceiver$1 found in modules
   (com.android.support:support-compat:26.1.0)
 ```
 
-**Add these two lines to `gradle.properties` at the project root** before any UI Kit code is wired in:
+**Add these three lines to `gradle.properties` at the project root** before any UI Kit code is wired in:
 
 ```properties
+org.gradle.jvmargs=-Xmx4096m -XX:MaxMetaspaceSize=1024m
 android.useAndroidX=true
 android.enableJetifier=true
 ```
 
-Both are **mandatory**. Jetifier rewrites the legacy `android.support.*` references in the CometChat SDK's transitive deps to their `androidx.*` equivalents at build time, so the duplicate-class error doesn't happen.
+All three are **mandatory**. Jetifier rewrites the legacy `android.support.*` references in the CometChat SDK's transitive deps to their `androidx.*` equivalents at build time, so the duplicate-class error doesn't happen.
+
+**Why the heap setting matters (F47, 2026-05-22)**: a fresh Android Studio scaffold's default `org.gradle.jvmargs=-Xmx2048m` is **insufficient** when calls features are enabled — `com.cometchat:calls-sdk-android:4.+` transitively pulls `react-native` and other heavy deps that Jetifier has to rewrite. The first `assembleDebug` OOMs partway through with `OutOfMemoryError: Java heap space`. Bumping to `4096m` + `MaxMetaspaceSize=1024m` is the validated minimum. If you skip this, the customer sees a confusing mid-build crash with no actionable error.
 
 A freshly-created Android Studio project usually has `android.useAndroidX=true` already (Arctic Fox+) but **Jetifier is OFF by default** since it's deprecated in newer SDK landscapes. Both V5 and V6 CometChat SDKs still need it. If `gradle.properties` doesn't have either line, append both. If it has `useAndroidX=true` but no Jetifier line, add the Jetifier line. Idempotent.
 
@@ -352,3 +355,200 @@ All send methods automatically:
 - `compileSdk` should be 36 for full compatibility
 - Both UI stacks depend on `chatuikit-core` transitively — do NOT add core as a separate dependency when using a UI stack
 - `gradle.properties` MUST contain `android.useAndroidX=true` AND `android.enableJetifier=true` — see § 1.3a. Without Jetifier, the build fails with "Duplicate class android.support.v4.os.ResultReceiver$1" because the CometChat SDK's transitive `com.android.support:support-compat` collides with `androidx.core` in any modern Android Studio project
+
+## Visual Builder integration
+
+> **⚠ The Visual Builder emits V5-shaped code.** The canonical builder repo at the Android Visual Builder ZIP (download from https://preview.cometchat.com/downloads/cometchat-builder-android.zip) uses `com.cometchat:chat-uikit-android:5.2.6` — the **V5** Android UI Kit. There is no V6-native Visual Builder canonical from vendor side yet ([F22 finding, 2026-05-22](https://github.com/cometchat/cometchat-skills/issues)). When a V6 project picks the Visually path, skills emits V5 deps (`chat-uikit-android:5.+`) into `app/build.gradle` — your V6 Compose / Kotlin Views code in the rest of the project is untouched, but the Visual-Builder-emitted screens are V5-flavored. Treat as transitional until vendor publishes a V6 canonical. V6 customers preferring a single-version dep tree should use the In-code path.
+>
+> The recipe below is identical to what `cometchat-android-v5-core` §"Visual Builder integration" prescribes (both reference the same canonical). This page kept for V6 customers who still hit the Visually flow.
+
+When the dispatcher's Step 3.1 sets `customize=visual` and the platform resolves to `android`, skills runs **`cometchat builder export --platform android`** — a single CLI command that downloads the canonical static template ZIP from `preview.cometchat.com/downloads/cometchat-builder-android.zip`, fetches the per-builder settings JSON, applies F3 + F10 missing-field defaults, and writes 2 files to `--output` (default: `cometchat/`):
+
+- `BuilderSettingsHelper.kt` — verbatim helper (with original `package com.cometchat.builder` declaration; **skills patches the package to the customer's app package** before final placement at `app/src/main/java/<package>/cometchat/`)
+- `cometchat-builder-settings.json` — **envelope-shape JSON** `{ builderId, name, settings: {...} }` (no sentinel — JSON forbids `//` comments)
+
+### 1. Run `cometchat builder export`
+
+```bash
+cometchat builder export --platform android --json
+```
+
+Defaults to `--output cometchat/`. The CLI emits the helper with the original `com.cometchat.builder` package declaration. **You must then move the files** to the customer's project + rewrite the package, per the table below:
+
+### 2. Place + patch (after `builder export`)
+
+| Source (from `--output`) | Destination | Notes |
+|---|---|---|
+| `cometchat/cometchat-builder-settings.json` | `app/cometchat-builder-settings.json` | Move to app module root (sibling of `build.gradle.kts`). The Gradle plugin requires the envelope shape — already provided by the CLI. |
+| `cometchat/BuilderSettingsHelper.kt` | `app/src/main/java/<customer-package>/cometchat/BuilderSettingsHelper.kt` | **Move + 3 transforms** — see F50/F51 below. |
+| `cometchat/font/*` | `app/src/main/res/font/*` | 12 font files (Arial / Inter / Roboto / Times — regular/medium/bold). Auto-emitted by `builder export --platform android` since F48 (2026-05-22). Just move them. |
+| (skills-emitted, not from ZIP) | `app/src/main/java/<customer-package>/cometchat/CometChatApp.kt` | Compose wrapper that mounts kit View components via `AndroidView` and applies `BuilderSettingsHelper.applySettings*` to each |
+
+#### F50 + F51 — BuilderSettingsHelper.kt requires 3 transforms on move (NON-NEGOTIABLE)
+
+After moving `cometchat/BuilderSettingsHelper.kt` to
+`app/src/main/java/<customer-package>/cometchat/BuilderSettingsHelper.kt`,
+the file needs these 3 transforms before it compiles:
+
+**1. Rewrite the package line:**
+
+```kotlin
+package com.cometchat.builder            // before
+package com.example.myapp.cometchat      // after (match customer's applicationId + .cometchat suffix)
+```
+
+**2. Add 3 explicit imports** under the existing import block:
+
+```kotlin
+import com.cometchat.builder.CometChatBuilderSettings    // auto-generated constants class — stays at original package
+import com.example.myapp.BuildConfig                      // customer's BuildConfig — must use their applicationId
+import com.example.myapp.R                                // customer's R class — same applicationId
+```
+
+Without these, the file fails to compile with `Unresolved reference 'R'`, `Unresolved reference 'BuildConfig'`, `Unresolved reference 'CometChatBuilderSettings'`. (When the file was in the original `com.cometchat.builder` package, these resolved implicitly via same-package; after the rewrite, they need explicit imports.)
+
+**3. Strip the entire `applySettingsToBottomNavigationView` method** (per README option 2 — skills doesn't emit the bottom-nav shape). The method references `R.id.nav_chats`, `R.id.nav_calls`, `R.id.nav_users`, `R.id.nav_groups` which don't exist in the customer's `res/menu/`. Removing the method removes the references.
+
+```kotlin
+// Delete the entire function from `fun applySettingsToBottomNavigationView(...)` to its closing `}` —
+// roughly lines 27-54 in the canonical file. Leave a comment in its place so future readers
+// understand why:
+//
+//   // applySettingsToBottomNavigationView removed per cometchat-android-v6-core
+//   // SKILL.md (README option 2 — no bottom-nav module in app integration).
+```
+
+Validated on `/Users/swapnil/Downloads/builder-demo/my-android-app/` 2026-05-25 — after all 3 transforms, `./gradlew :app:assembleDebug` → `BUILD SUCCESSFUL in 6s`. F50 + F51 findings.
+
+The Gradle plugin REQUIRES the `{ builderId, settings: {...} }` envelope — writing the raw settings blob produces an empty `CometChatBuilderSettings` constants class and Kotlin compile fails with `Unresolved reference 'ChatFeatures'` / `'CallFeatures'`. The CLI always writes the envelope shape.
+
+Resync = re-run `cometchat builder export --platform android --force`. Re-apply the move+package-rewrite each time (Skills should automate this in a future release).
+
+### Files patched
+
+| Path | Patch |
+|---|---|
+| `settings.gradle.kts` | Add `maven("https://dl.cloudsmith.io/public/cometchat/cometchat/maven/")` to BOTH `pluginManagement.repositories` AND `dependencyResolutionManagement.repositories` |
+| `app/build.gradle.kts` | Add `id("com.cometchat.builder.settings") version "5.0.1"` to the `plugins { }` block. Add `implementation("com.cometchat:chat-uikit-android:5.1.+")`. Add `implementation("com.cometchat:calls-sdk-android:4.1.+")` if `cometchat-builder-settings.json` has any call feature enabled |
+| `gradle.properties` | `android.useAndroidX=true` + `android.enableJetifier=true` per §1.3a (non-negotiable) |
+| `AndroidManifest.xml` | Set `android:theme="@style/CometChat.Builder.Theme"` on `<application>`. Add `RECORD_AUDIO` + `CAMERA` permissions if any `CallFeatures.*` flag is true |
+| `Application` subclass | Call `CometChatUIKit.init(this, uiKitSettings)` in `onCreate()` per §2 — credentials from `BuildConfig.COMETCHAT_*` via §1.4 |
+
+### Init flow (build-time + runtime)
+
+**Build time** — the Gradle plugin:
+1. Reads `app/cometchat-builder-settings.json`
+2. Generates `com.cometchat.builder.CometChatBuilderSettings` (typed Kotlin constants: `ChatFeatures.CoreMessagingExperience.PHOTOSSHARING`, `Style.Color.BRANDCOLOR`, etc.)
+3. Injects style values into `@style/CometChat.Builder.Theme` so the kit's `CometChatTheme` resolves builder tokens automatically
+
+**Runtime** — customer code accesses both:
+```kotlin
+import com.cometchat.builder.CometChatBuilderSettings       // generated by plugin
+import <package>.cometchat.BuilderSettingsHelper            // copied helper
+
+if (CometChatBuilderSettings.ChatFeatures.CoreMessagingExperience.PHOTOSSHARING) {
+    // photo attachment enabled
+}
+BuilderSettingsHelper.applySettingsToMessageList(binding.messageList)
+```
+
+### The wrapper template
+
+```kotlin
+// app/src/main/java/<package>/cometchat/CometChatApp.kt
+package <package>.cometchat
+
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.viewinterop.AndroidView
+import com.cometchat.chat.models.Group
+import com.cometchat.chat.models.User
+import com.cometchat.chatuikit.conversations.CometChatConversations
+import com.cometchat.chatuikit.messagecomposer.CometChatMessageComposer
+import com.cometchat.chatuikit.messageheader.CometChatMessageHeader
+import com.cometchat.chatuikit.messagelist.CometChatMessageList
+
+/**
+ * Top-level chat surface emitted by the Visual Builder Visually path.
+ *
+ * Hosts the kit's View-based components via AndroidView; BuilderSettingsHelper
+ * (copied from the builder repo) wires CometChatBuilderSettings → component
+ * visibility on each instance.
+ *
+ * CometChatUIKit.init(...) must have been called in Application.onCreate()
+ * BEFORE this composable mounts — see §2.
+ */
+@Composable
+fun CometChatApp() {
+    var selectedUser by remember { mutableStateOf<User?>(null) }
+    var selectedGroup by remember { mutableStateOf<Group?>(null) }
+    val hasSelection = selectedUser != null || selectedGroup != null
+
+    if (!hasSelection) {
+        AndroidView(
+            modifier = Modifier.fillMaxSize(),
+            factory = { ctx ->
+                CometChatConversations(ctx).apply {
+                    BuilderSettingsHelper.applySettingsToConversations(this)
+                    setOnItemClickListener { _, conversation ->
+                        when (val entity = conversation.conversationWith) {
+                            is User -> { selectedUser = entity; selectedGroup = null }
+                            is Group -> { selectedUser = null; selectedGroup = entity }
+                        }
+                    }
+                }
+            },
+        )
+        return
+    }
+
+    Column(Modifier.fillMaxSize()) {
+        AndroidView(factory = { ctx ->
+            CometChatMessageHeader(ctx).apply {
+                user = selectedUser
+                group = selectedGroup
+                BuilderSettingsHelper.applySettingsToMessageHeader(this)
+            }
+        })
+        AndroidView(modifier = Modifier.weight(1f), factory = { ctx ->
+            CometChatMessageList(ctx).apply {
+                user = selectedUser
+                group = selectedGroup
+                BuilderSettingsHelper.applySettingsToMessageList(this)
+            }
+        })
+        AndroidView(factory = { ctx ->
+            CometChatMessageComposer(ctx).apply {
+                user = selectedUser
+                group = selectedGroup
+                BuilderSettingsHelper.applySettingsToMessageComposer(this)
+            }
+        })
+    }
+}
+```
+
+`BuilderSettingsHelper.kt` is copied verbatim from the builder repo. Methods used above:
+- `applySettingsToConversations(...)` → user-status / receipts / search-box visibility
+- `applySettingsToMessageHeader(...)` → voice/video call buttons + user-status visibility (group vs user-aware)
+- `applySettingsToMessageList(...)` → edit/delete/reply-in-thread/reactions/translation/conversation-starter/smart-replies/message-privately visibility
+- `applySettingsToMessageComposer(...)` → attachment/voice-note/poll/sticker/etc. visibility
+
+For a Compose-native stack (`chatuikit-compose-android` instead of `chatuikit-android` Views), skip the `AndroidView` + `BuilderSettingsHelper` indirection and read `CometChatBuilderSettings.ChatFeatures.*` constants directly into the Compose components' visibility/feature props — see `cometchat-android-v6-compose-components`. The Views-via-AndroidView path above matches the canonical builder repo, which is Views-based.
+
+### Calls + builder
+
+If any `CometChatBuilderSettings.CallFeatures.*` flag is true:
+1. Init Calls SDK in `Application.onCreate()` alongside UI Kit (see `cometchat-android-v6-calls`)
+2. Mount `CometChatIncomingCall` overlay — the builder repo's `BuilderApplication.kt` registers `ActivityLifecycleCallbacks` and shows a `Snackbar`-hosted incoming-call view at the top of the foreground activity. Copy that pattern verbatim from `chat-builder/src/main/java/com/cometchat/builder/utils/BuilderApplication.kt` (inside the Android Visual Builder ZIP at https://preview.cometchat.com/downloads/cometchat-builder-android.zip)
+3. FCM data-message wiring — defer to `cometchat-android-v6-push`
+
+### What is NOT honored in v1
+
+The builder repo's `HomeActivity` exposes a `BottomNavigationView` with up to 4 tabs (Chats / Calls / Users / Groups) driven by `CometChatBuilderSettings.Layout.TABS`. Skills emits a single Compose conversations surface, not the tabbed shape. The corresponding `applySettingsToBottomNavigationView` method is also **intentionally removed** when emitting `BuilderSettingsHelper.kt` (per README option 2). Theme + typography + chat-feature toggles ARE honored. For the full tabbed shape, copy the builder repo's `HomeActivity` + per-tab fragments alongside skills' emission (or use README option 1 — "Import as module").

package/skills/cometchat-android-v6-migration/SKILL.md

@@ -12,7 +12,7 @@ metadata:
 
 ## Purpose
 
-Migration recipes for moving from CometChat Android UIKit V5 (`chat-uikit-android:5.x`) to V6 (`chatuikit-{compose,kotlin}-android:6.0.0-beta2`). V6 is beta — most production apps should stay on V5 today; this skill is for teams evaluating V6 or planning the eventual migration.
+Migration recipes for moving from CometChat Android UIKit V5 (`chat-uikit-android:5.x`) to V6 (`chatuikit-{compose,kotlin}-android:6.0.0-beta2`). V6 is stable (GA 2026-05-25) — most production apps should stay on V5 today; this skill is for teams evaluating V6 or planning the eventual migration.
 
 V6 is a different SDK, not a drop-in replacement. The migration is roughly the size of jumping from React Native UIKit v5 to v6 — package coordinates, builder APIs, theme system, calls handling all change.
 

package/skills/cometchat-angular-core/SKILL.md

@@ -429,6 +429,28 @@ Use the MCP to verify prop names, callback signatures, theme token names, or err
 
 ---
 
+## 11. Visual Builder integration — not available for Angular
+
+When the dispatcher's Step 3.1 (Customization preference) runs on an Angular project, **it auto-routes to the code-driven path**. The dashboard's Visual Builder export pipeline at `https://preview.cometchat.com/downloads/cometchat-builder-{platform}.zip` ships ZIPs for `react`, `react-native`, `ios`, `android`, and `flutter` — there's no `angular` emitter. Skills can't bridge that gap by translating React/JSON output into Angular code because the kit's Angular package (`@cometchat/chat-uikit-angular`) has different selectors (`<cometchat-conversations>`), module shapes (`CometChatConversationsModule`), and content-projection slot APIs than React.
+
+For comparison, the other family core skills have a `## Visual Builder integration` section that documents per-platform copy-the-canonical-app recipes. Angular has no equivalent; this section is the intentional empty entry.
+
+**What the dispatcher does on an Angular project:**
+
+1. Skips the Visually-vs-In-code prompt entirely.
+2. Surfaces a one-time message in the chat:
+
+   > *"The Visual Builder doesn't ship Angular code yet (the dashboard's export covers React / React Native / iOS / Android / Flutter today). I'll set up the code-driven Angular integration instead — you can theme via `CometChatThemeService` later. Want to be notified when an Angular Visual Builder lands? Drop a 👍 on https://github.com/cometchat/cometchat-skills/discussions/categories/feature-requests."*
+
+3. Sets `customize=code` in `.cometchat/config.json` via `npx @cometchat/skills-cli config save --customize code --json`.
+4. Continues to the standard Angular flow (§3a intent → §3b recommendation → §3c placement → §5 code emission via this skill + `cometchat-angular-{components,placement,patterns,theming}`).
+
+If a customer arrives at an Angular project with a stale `customize=visual` value (carried over from a previous run on a React/Flutter/etc. project), the dispatcher OVERWRITES it to `code` before routing — calling `builder create --platform angular` would fail at the CLI layer (rejected: "Missing or invalid --platform"). The override prevents the customer from seeing a confusing error instead of the explanatory note above.
+
+**For when Visual Builder Angular support lands** — track [issue link TBD] on the public repo. At that point, this section gets a full canonical-app recipe (parallel to `cometchat-core` §11) and the dispatcher's §3.1 table flips `angular` from "not supported" to a `platform: angular` row.
+
+---
+
 ## Skill routing reference
 
 | Skill | When to load |

package/skills/cometchat-astro-patterns/SKILL.md

@@ -685,3 +685,23 @@ const handleClose = () => console.log("closed");
 1. Always `client:only="react"` -- never `client:load`
 2. CSS imports go INSIDE the React component -- never in `.astro` files
 3. Each island wraps its own `CometChatProvider` -- there is no global provider at the Astro level
+
+## 11. Visual Builder integration (v4.3)
+
+If the customer picks **Visually** in dispatcher Step 3.1, skills runs `cometchat builder export --platform react --output src/CometChat --json` to download the canonical + patch settings in one step.
+
+**Full recipe lives in `cometchat-core` §11 "Visual Builder integration".** This section is a pointer + Astro-specific gotchas:
+
+- Run `cometchat builder export --platform react --output src/CometChat --json`.
+- Create a React island wrapper at `src/components/CometChatIsland.tsx` (or similar) that does init + login + renders `<CometChatProvider><CometChatApp /></CometChatProvider>`.
+- Mount in `src/pages/chat.astro` as `<CometChatIsland client:only="react" />` — **never** `client:load`. The canonical CometChat/ uses `window` / `document` at module scope; `client:load` will SSR the import resolution and crash.
+- Use `import.meta.env.PUBLIC_COMETCHAT_*` (Astro's public-env prefix).
+- Astro's Vite-based build uses rollup (not Rolldown), so it tolerates the canonical's type-as-value imports as warning — Astro is **the most reliable Visual Builder host** in the v4.3.0 web matrix (validated 2026-05-22).
+
+### Both Astro and other Vite hosts
+
+- Pin `@cometchat/chat-uikit-react@6.4.3` + `@cometchat/calls-sdk-javascript@4.2.5`.
+- `package.json` needs `cometChatCustomConfig` block (Finding F2).
+- Vite 7+ `tsconfig.app.json` requires the relaxation set from `cometchat-core` §11.2.
+
+If the customer picks **In code**, ignore this section.

package/skills/cometchat-core/SKILL.md

@@ -645,3 +645,166 @@ CometChat.TextMessage  // A text message specifically
 CometChat.getUser(uid: string): Promise<CometChat.User>
 CometChat.getGroup(guid: string): Promise<CometChat.Group>
 ```
+
+## 11. Visual Builder integration
+
+When the dispatcher's Step 3.1 sets `customize=visual`, skills runs **`cometchat builder export --platform react`** — a single CLI command that mirrors the dashboard's Export-button workflow. It downloads the canonical static template ZIP from `preview.cometchat.com/downloads/cometchat-builder-react.zip`, fetches the per-builder settings JSON via `GET /vcb/builders/{id}`, unzips the template, patches `CometChatSettings.ts` with the fetched JSON + missing-field defaults + a sentinel comment, and writes the result to `--output` (default: `src/CometChat/`).
+
+The `src/CometChat/` directory contains `CometChatApp.tsx`, the repo's own `CometChatProvider`-style context, `CometChatHome` with tabs (Chats / Calls / Users / Groups), theme hooks (`useThemeStyles`, `useSystemColorScheme`), login listener wiring, and 13 supporting components. Skills does NOT hand-roll a wrapper — the canonical app IS the wrapper.
+
+This is the same pattern iOS (verbatim `MessagesVC.swift`), Android v6 (verbatim `BuilderSettingsHelper.kt`), and Flutter v6 (verbatim `chat_builder/` package) use. React just happens to copy a directory of TSX files instead of a single class.
+
+### 11.1 Run `cometchat builder export`
+
+After Step 3.1.v step 4 (customer says "Done" + skills caches the builderId in `.cometchat/builder.json`), run:
+
+```bash
+cometchat builder export --platform react --json
+```
+
+This produces the full per-builder integration in one shot:
+
+| What | Where |
+|---|---|
+| Downloads static template ZIP | `https://preview.cometchat.com/downloads/cometchat-builder-react.zip` |
+| Fetches per-builder settings | `GET /vcb/builders/{builderId}` via the same `Bearer` token used elsewhere |
+| Applies F3 + F10 missing-field defaults | `chatFeatures.inAppSounds` + `chatFeatures.deeperUserEngagement.mentionAll` |
+| Unzips template into temp dir | `/tmp/cometchat-builder-export-XXXX/extracted/` |
+| Patches `CometChatSettings.ts` | Per-builder JSON + sentinel comment ("SKILLS-AUTO-GENERATED — do not edit by hand. Last sync: <ISO>") |
+| Copies to `--output` | Default `src/CometChat/` |
+| Reports JSON | `{ status: "exported", builderId, appId, platform, output, settings_file, builder_name }` |
+
+**For Next.js App Router**, pass `--output src/app/CometChat`. For React Router v7 framework mode, pass `--output app/CometChat`. The CLI's F25 case-collision pre-check warns if a lowercase `src/cometchat/` exists with In-code-shape files (init.ts / CometChatProvider.tsx).
+
+**For resync** (Step 7 iteration menu → Re-sync visual builder), re-run the SAME command with `--force`. This re-downloads the latest canonical template + re-fetches the latest settings + replaces the `--output` directory entirely. Customer hand-edits inside the `CometChat/` directory are lost — matches the "SKILLS-AUTO-GENERATED" contract on the sentinel.
+
+### 11.2 Files patched (after export)
+
+The `builder export` command writes the canonical files. Skills then patches the customer's existing project to wire it in:
+
+| Path | Patch |
+|---|---|
+| `package.json` | (1) `npm install @cometchat/chat-uikit-react@6.4.3 @cometchat/calls-sdk-javascript@4.2.5` — **pinned versions from the canonical repo's README**. Older/newer versions of `chat-uikit-react` may drift from the exported `src/CometChat/` directory's expected API surface. (2) **Add a top-level `cometChatCustomConfig` block** — the canonical context reads it via `import packageJson from "../../../package.json"` and accesses `packageJson.cometChatCustomConfig.name` / `.version` / `.production` for init wiring. Without it, the build fails with `TS2339: Property 'cometChatCustomConfig' does not exist`. Shape: `"cometChatCustomConfig": { "name": "<your-app-name>", "version": "<your-app-version>", "production": true }`. |
+| Entry file — `src/main.tsx` (Vite) / `src/index.tsx` (CRA) / new client component (Next.js) / route file (React Router) / `.astro` page (Astro) | Init UI Kit + render `<CometChatProvider><App /></CometChatProvider>`. Pattern below — varies by framework. |
+| `tsconfig.app.json` (Vite 7+) or `tsconfig.json` (CRA / older Vite) | **Multiple non-negotiable adjustments** beyond `resolveJsonModule` + `jsx`. The canonical `src/CometChat/` was authored under CRA's looser TS settings; Vite 7+ template defaults are too strict and will fail the build with dozens of `TS6133` / `TS1484` errors:<br>• `"resolveJsonModule": true` — non-negotiable (`utils/utils.ts` imports a JSON locale)<br>• `"jsx": "react-jsx"` — non-negotiable<br>• `"verbatimModuleSyntax": false` — Vite 7+ default is `true`; canonical code uses mixed value + type imports without the `type` modifier<br>• `"noUnusedLocals": false` — Vite 7+ default is `true`; canonical code has many unused-by-default destructured listener args (e.g. `({ groupOwner, kickedUser, ... })`)<br>• `"noUnusedParameters": false` — same rationale<br>• `"erasableSyntaxOnly": false` — Vite 7+ template flag; canonical code uses const enums / namespace patterns<br>• `"allowJs": true` — canonical app's tsconfig sets this; some kit internals may rely on JS fallthrough<br>Validated 2026-05-21 against `create-vite@8` + canonical `uikit-builder-app-master` + `@cometchat/chat-uikit-react@6.4.3`. |
+| `.env` (framework-prefixed) | Already written by Step 2c provision. Skip if present; warn if missing. |
+
+The `builder export` command handles the JSON patching + sentinel comment automatically. Skills only needs to patch the four files above (package.json, entry file, tsconfig, .env).
+
+### 11.3 Entry-file init pattern (Vite + React)
+
+```tsx
+// src/main.tsx
+import { createRoot } from "react-dom/client";
+import "./index.css";
+import App from "./App.tsx";
+import {
+  UIKitSettingsBuilder,
+  CometChatUIKit,
+} from "@cometchat/chat-uikit-react";
+import { CometChat } from "@cometchat/chat-sdk-javascript";
+import { setupLocalization } from "./CometChat/utils/utils.ts";
+import { CometChatProvider } from "./CometChat/context/CometChatContext.tsx";
+
+export const COMETCHAT_CONSTANTS = {
+  APP_ID: import.meta.env.VITE_COMETCHAT_APP_ID!,
+  REGION: import.meta.env.VITE_COMETCHAT_REGION!,
+  AUTH_KEY: import.meta.env.VITE_COMETCHAT_AUTH_KEY!,
+};
+
+const uiKitSettings = new UIKitSettingsBuilder()
+  .setAppId(COMETCHAT_CONSTANTS.APP_ID)
+  .setRegion(COMETCHAT_CONSTANTS.REGION)
+  .setAuthKey(COMETCHAT_CONSTANTS.AUTH_KEY)
+  .subscribePresenceForAllUsers()
+  .build();
+
+CometChatUIKit.init(uiKitSettings)?.then(() => {
+  setupLocalization();
+  createRoot(document.getElementById("root")!).render(
+    <CometChatProvider>
+      <App />
+    </CometChatProvider>
+  );
+});
+```
+
+Then in `src/App.tsx`:
+
+```tsx
+import CometChatApp from "./CometChat/CometChatApp";
+
+export default function App() {
+  return (
+    // CometChatApp requires an explicit width and height to render. Adjust as needed
+    // for your Step 3c placement (full route, drawer, modal, embedded panel).
+    <div style={{ width: "100vw", height: "100dvh" }}>
+      <CometChatApp />
+    </div>
+  );
+}
+```
+
+**Critical:**
+
+- `CometChatProvider` is the **repo's own context** from `./CometChat/context/CometChatContext`, NOT the kit's `CometChatUIKit` export. It manages the builder's `styleFeatures` / `chatFeatures` state and is required for `CometChatHome`, `useThemeStyles`, and the customization toggles to work.
+- `setupLocalization()` from `./CometChat/utils/utils` is required before render — it wires the builder's i18n catalog into the kit. Skipping it leaves UI strings empty.
+- `CometChatUIKit.init(...)` returns a Promise — render only AFTER it resolves. Rendering before init resolves causes `CometChatHome` to throw on first listener attach.
+- Login is handled by `CometChatApp` itself (the canonical component uses `CometChat.addLoginListener` + `CometChatUIKit.getLoggedinUser`). For dev mode, the customer's `App.tsx` should call `CometChatUIKit.login("cometchat-uid-1")` after init resolves but BEFORE rendering — see §2's login order. The canonical app shows a `LoginPlaceholder` until a user is present.
+
+### 11.4 Per-framework variants
+
+| Framework | Where to put `CometChat/` | Entry-file pattern | SSR notes |
+|---|---|---|---|
+| **Vite + React** | `src/CometChat/` | `src/main.tsx` (above) | N/A |
+| **Create React App** | `src/CometChat/` | `src/index.tsx` — same as Vite but use `ReactDOM.createRoot` from `react-dom/client` | N/A |
+| **Next.js App Router** | `src/app/CometChat/` | Create `src/app/CometChatNoSSR/CometChatNoSSR.tsx` (client component) that does init + login + renders `<CometChatProvider><CometChatApp /></CometChatProvider>`. Then create `src/app/CometChatAppWrapper.tsx` with `"use client"` + `dynamic(() => import("../app/CometChatNoSSR/CometChatNoSSR"), { ssr: false })`. Import the wrapper in `src/app/page.tsx`. | The canonical `src/CometChat/` uses `window` / `document` / WebSocket APIs at module scope. `{ ssr: false }` on the wrapper is **non-negotiable** — direct import from a server component causes hydration errors. Use `process.env.NEXT_PUBLIC_COMETCHAT_*` instead of `import.meta.env.*`. |
+| **Next.js Pages Router** | `src/CometChat/` | `pages/chat.tsx` — `const CometChatApp = dynamic(() => import("../src/CometChat/CometChatApp"), { ssr: false });` Init in `pages/_app.tsx` inside `useEffect`. | Same SSR rationale as App Router. |
+| **React Router v7** | `app/CometChat/` (framework mode) or `src/CometChat/` (data mode) | Framework mode: use a `.client.tsx` suffix or `<ClientOnly>` from `remix-utils/client-only`. Data mode: same as Vite. | Framework mode SSRs by default — `.client.tsx` suffix OR `<ClientOnly>` is the only safe pattern. |
+| **Astro** | `src/CometChat/` | `<CometChatApp client:only="react" />` inside an `.astro` page. Init runs in a sibling `.tsx` component that mounts before `CometChatApp`. | `client:only="react"` — never `client:load` (Astro will still SSR the import resolution and crash). |
+
+### 11.5 Calls + builder
+
+If `CometChatSettings.callFeatures` has any `true` value (`oneOnOneVoiceCalling`, `oneOnOneVideoCalling`, `groupVideoConference`, `groupVoiceConference`):
+
+1. The canonical `src/CometChat/` already wires `CometChatIncomingCall` inside `CometChatHome` — no extra mount required.
+2. Skills patches `package.json` to add `@cometchat/calls-sdk-javascript@4.2.5` (already in the canonical install command above) and the Cloudsmith-hosted `@cometchat/calls-lib-webrtc` per `cometchat-react-calls`.
+3. Calls SDK init runs alongside UI Kit init — pattern in `cometchat-react-calls § 2`.
+
+Invoke `cometchat-react-calls` after this section with `{ mode: "additive" }` so it adds Calls SDK init + lib-webrtc without duplicating the kit-level wiring already present in the copied `src/CometChat/`.
+
+### 11.6 Resync flow
+
+The "Re-sync visual builder" iteration menu option (see `cometchat/SKILL.md § Step 7`) is a **one-command re-run**:
+
+```bash
+cometchat builder export --platform react --force
+```
+
+The `--force` flag is mandatory: it explicitly authorizes replacing the existing `src/CometChat/` directory. Without it, the CLI bails with *"--output directory \`src/CometChat\` already exists. Pass --force to replace it (full re-download per the resync flow), or pick a different --output path."*
+
+This matches the product contract for step 7 of the UI Kit Builder workflow:
+
+1. Re-download the canonical static template ZIP (in case vendor has shipped fixes)
+2. Re-fetch the customer's current settings JSON (in case they tweaked in browser)
+3. Apply the F3 + F10 missing-field defaults
+4. Replace the `src/CometChat/` directory entirely
+
+**Customer hand-edits inside `src/CometChat/` are lost on resync.** This is intentional — the SKILLS-AUTO-GENERATED sentinel comment on `CometChatSettings.ts` documents the "do not edit by hand" contract.
+
+If a customer needs to override beyond what the Visual Builder exposes, the supported escape hatches are:
+- Edit the entry file (e.g., `src/main.tsx`) — outside `src/CometChat/`, never touched by resync
+- Edit `src/App.tsx` to wrap `<CometChatApp />` with additional providers / styling
+- Use `cometchat apply-feature <id>` for extension toggles (server-side, survives resync)
+- For one-off CSS overrides, edit `src/index.css` or equivalent — also outside `src/CometChat/`
+
+The `cometchat-core` §11.7 "Override hook pattern" documents the recommended places to override without touching the canonical.
+
+`verify --builder` runs after resync to confirm the new export is structurally sound.
+
+### 11.7 What this section does NOT emit
+
+The canonical `src/CometChat/` honors every Builder setting it supports — theme colors, typography, dark/light, sidebar toggle, layout tabs, `chatFeatures.*`, `callFeatures.*`, `agent.*` (per the repo's `CometChatHome` + `styleConfig.ts`). The only setting that isn't auto-applied is `noCode.docked` (the floating-widget shape) — that's a runtime DOM injection that requires the customer to mount `<CometChatApp />` inside a docked overlay container. Surface this in the post-emit summary:
+
+> Builder settings honored: theme, typography, layout/tabs, sidebar, chat features (mentions/reactions/threads/media/etc.), call features, agent UI.
+> Builder settings deferred: `noCode.docked` floating-widget mode — requires manual mount inside a positioned overlay; see `cometchat-placement § Floating widget`.

package/skills/cometchat-flutter-v5-core/SKILL.md

@@ -219,3 +219,20 @@ void dispose() {
 - [ ] SDK listeners registered with unique ID, removed in `dispose()`
 - [ ] Colors from `CometChatThemeHelper`, never hardcoded
 - [ ] Imports: `package:cometchat_chat_uikit/cometchat_chat_uikit.dart` always; ADD `package:cometchat_calls_uikit/cometchat_calls_uikit.dart` if you use voice/video
+
+## Visual Builder integration
+
+**Flutter V5 is the primary home for Visual Builder integration.** The canonical repo at the `chat_builder/` directory inside the Flutter Visual Builder ZIP (download from https://preview.cometchat.com/downloads/cometchat-builder-flutter.zip) ships **V5-shaped code** — `cometchat_chat_uikit: ^5.2.12` + `cometchat_calls_uikit: ^5.0.13`. The integration copies the entire `chat_builder/` directory as a `path:` dependency, then `BuilderSettingsHelper.loadFromAsset()` reads `chat_builder/assets/sample_app/cometchat-builder-settings.json` and configures the bundled chat UI accordingly.
+
+**The full recipe lives in `cometchat-flutter-v6-core` §"Visual Builder integration"** because that's where the V6-prep restructure originally landed the validated content. Both skills reference the same canonical; the V6 page carries a "V5-shaped code" warning at the top. V5 customers should follow that recipe AS-IS — the canonical IS V5-targeted.
+
+Validated 2026-05-21 against Flutter 3.38.3: `flutter build apk --debug` produces `app-debug.apk` after applying:
+- Envelope-wrapped JSON at `chat_builder/assets/sample_app/cometchat-builder-settings.json` (`{ builderId, name, settings: {...} }`)
+- Two missing-field defaults injected pre-write (mentionAll + inAppSounds — same as Android)
+- `android.enableJetifier=true` in `android/gradle.properties` (the chat SDK pulls `com.android.support` transitively)
+- `await BuilderSettingsHelper.loadFromAsset()` in `lib/main.dart` before `runApp()`
+- `chat_builder: { path: ./chat_builder }` in host `pubspec.yaml`
+
+Differences from the V6 page's recipe text:
+- V5 host code uses `StatefulWidget` with direct listener management (V6 uses BLoC pattern); both work with the embedded chat_builder package since it owns its own state.
+- V5 calls work via the standard `cometchat-flutter-v5-calls` flow — no [[project_v6_flutter_calls_partial]] navigatorKey workaround needed (that's a V6-beta-specific issue).

package/skills/cometchat-flutter-v6-calls/SKILL.md

@@ -1,8 +1,8 @@
 ---
 name: cometchat-flutter-v6-calls
-description: CometChat Calls integration for Flutter UIKit v6 (Bloc-based, beta). ⚠️ Partially working at v6.0.0-beta2 (2026-05-13) — chat + calls init OK, outgoing call API succeeds, but TWO vendor bugs block end-to-end calling: (1) MaterialApp MUST set `navigatorKey: CallNavigationContext.navigatorKey` or the outgoing-call screen never renders ("Context is not mounted for navigation" — undocumented hard requirement); (2) even with the navigatorKey wired, the outgoing-call screen does NOT transition to the in-call view when peer accepts — call goes to `ongoing` at server level but UI stays on "Calling…" indefinitely, no client-side workaround. Customers shipping calls on Flutter today must stay on V5 cohort (cometchat_calls_uikit ^5.0.+). Covers UIKitSettings calling block, CometChatUIKitCalls.init() after CometChatUIKit.init() (CALLS_INIT_AFTER_CHAT_INIT), the kit's Bloc-driven CometChatCallButtons / CometChatIncomingCall / CometChatOutgoingCall / CometChatOngoingCall / CometChatCallLogs / CometChatCallBubble widgets, CallingConfiguration, native_call_kit module (iOS CallKit + Android ConnectionService), CallOperationsServiceLocator lifecycle, FCM + PushKit VoIP push, and additive-vs-standalone modes.
+description: "CometChat Calls integration for Flutter UIKit v6 (Bloc-based, stable). Production-ready at v6.0.1 GA (validated 2026-05-27 on Pixel 3) with ONE explicit MaterialApp wiring requirement still active from v6.0.0-beta2 — MaterialApp MUST wire navigatorKey to CallNavigationContext.navigatorKey or the outgoing-call screen never renders. (Vendor's own 6.0.1 sample is missing this line and broken out-of-the-box — file a vendor ticket if you find that sample first.) The earlier outgoing-to-in-call BLoC transition bug from beta2 is FIXED in 6.0.1 GA per the v6.0.0 changelog's 'Refreshed BLoC implementations across ongoing call flows' entry. Customers can now use V6 for calls. Covers UIKitSettings calling block, CometChatUIKitCalls.init() after CometChatUIKit.init() (CALLS_INIT_AFTER_CHAT_INIT), the kit's Bloc-driven CometChatCallButtons / CometChatIncomingCall / CometChatOutgoingCall / CometChatOngoingCall / CometChatCallLogs / CometChatCallBubble widgets, CallingConfiguration, native_call_kit module (iOS CallKit + Android ConnectionService), CallOperationsServiceLocator lifecycle, FCM + PushKit VoIP push, and additive-vs-standalone modes."
 license: "MIT"
-compatibility: "Flutter >= 2.5, Dart >= 3.0; cometchat_chat_uikit ^6.0.0-beta2 (calls bundled in); minSdk 26+ on Android; iOS 13+"
+compatibility: "Flutter >= 2.5, Dart >= 3.0; cometchat_chat_uikit ^6.0.1 (calls bundled in); minSdk 26+ on Android; iOS 13+"
 allowed-tools: "shell, file-read, file-search, file-list, ask-user"
 metadata:
   author: "CometChat"
@@ -12,7 +12,7 @@ metadata:
 
 ## Purpose
 
-Production-grade voice + video calling for Flutter UIKit v6 (beta, Bloc-based). Loaded by `cometchat-calls` when `framework === "flutter"` and `flutter_version === "v6"`. Operates in two modes:
+Production-grade voice + video calling for Flutter UIKit v6 (stable, Bloc-based). Loaded by `cometchat-calls` when `framework === "flutter"` and `flutter_version === "v6"`. Operates in two modes:
 
 - **Standalone** — calls is the product. Chat SDK + Calls SDK without the v6 UI Kit (rare today, since the UI Kit ships calling bundled). Custom call screens on the SDKs.
 - **Additive** — calls layered onto an existing v6 chat integration. The v6 UI Kit ships call widgets in the same package (`cometchat_chat_uikit`) — no extra dependency. The skill enables calling on `UIKitSettings`, calls `CometChatUIKitCalls.init()` in the chat-init success callback, mounts the global incoming-call overlay at app root.
@@ -29,7 +29,7 @@ Production-grade voice + video calling for Flutter UIKit v6 (beta, Bloc-based).
 - V6 `CometChatUIKitCalls.init(appId, region)` must run AFTER `CometChatUIKit.init()` succeeds; V5 hides this via `CometChatCallingExtension`
 
 **Ground truth:**
-- SDK source — installed `cometchat_chat_uikit@6.0.0-beta2` artifacts under `~/.pub-cache/`
+- SDK source — installed `cometchat_chat_uikit@6.0.1` artifacts under `~/.pub-cache/`
 - Sample app — `~/Downloads/calls-sdk/calls-sdk-flutter-5/sample-apps/` (V5 sample; V6 sample app may not exist yet — verify before citing)
 - Public docs — https://www.cometchat.com/docs/calls/flutter/overview (note: V6 docs may still reference V5 module split)
 
@@ -167,11 +167,11 @@ MaterialApp(
 );
 ```
 
-**⚠️ `navigatorKey: CallNavigationContext.navigatorKey` is REQUIRED on MaterialApp at v6.0.0-beta2.** The kit's `CometChatCallButtons` and outgoing-call flow navigate via `CallNavigationContext.navigatorKey.currentContext`. Without this line, `CometChat.initiateCall` succeeds but the outgoing-call screen never renders — kit logs `"Context is not mounted for navigation"` and silently drops the navigation. Symptom: user taps call button, peer rings, but the Flutter app shows nothing.
+**⚠️ `navigatorKey: CallNavigationContext.navigatorKey` is REQUIRED on MaterialApp — still active in v6.0.1 GA.** The kit's `CometChatCallButtons` and outgoing-call flow navigate via `CallNavigationContext.navigatorKey.currentContext`. Without this line, `CometChat.initiateCall` succeeds (CALL-TRAP confirms `onSuccess` fires with a valid sessionId) but `currentContext` is null so `CometChatOutgoingCall` never mounts. Symptom: user taps call button, peer rings, but the Flutter app shows nothing. **Note: the vendor's own 6.0.1 sample app (`examples/sample_app`) is missing this line and is broken out-of-the-box** — its `user_info_screen.dart` reads `CallNavigationContext.navigatorKey.currentContext` but `main.dart`'s MaterialApp never sets the key. Don't copy the vendor sample's `main.dart` verbatim; add the navigatorKey.
 
 Import: `import 'package:cometchat_chat_uikit/cometchat_calls_uikit.dart' show CallNavigationContext;` (use `show` to avoid a name collision with kit-exported `IncomingCallOverlay`).
 
-**⚠️ Outgoing → in-call screen transition is broken at v6.0.0-beta2.** When the peer accepts, the call's status moves to `ongoing` at the server level — but the kit's outgoing-call screen does NOT transition to the in-call view. Users see the "Calling…" ring spinner indefinitely while the call is actually live. Pressing the reject button fires `CometChat.rejectCall` which the server rejects with `"The call status cannot be updated from ongoing to cancelled"`. **No client-side workaround known** — vendor needs to fix the outgoing-call BLoC's `onOutgoingCallAccepted` handler to push the in-call route. Validated on 2026-05-13 against a Next.js web peer.
+**✅ Outgoing → in-call screen transition is FIXED in v6.0.1 GA.** (It was broken in v6.0.0-beta2 — the outgoing-call screen stayed on "Calling…" indefinitely after the peer accepted.) Validated end-to-end 2026-05-27 on Pixel 3 with full CALL-TRAP instrumentation: with the navigatorKey wired (above), when the peer accepts, the kit's `OutgoingCallBloc` fires `pushReplacement` and the screen transitions automatically from `CometChatOutgoingCall` ("Calling…") to the in-call surface — observed call-duration timer ticking + WebRTC rendering frames @ ~27 fps. The v6.0.0 changelog's "Refreshed BLoC implementations across … call buttons, and ongoing call flows" was the fix. No client-side workaround needed beyond the navigatorKey wiring.
 
 In standalone mode, `native_call_kit` owns the OS-level ring UI; the in-app overlay only fires when the app is foregrounded.
 
@@ -184,7 +184,7 @@ In standalone mode, `native_call_kit` owns the OS-level ring UI; the in-app over
 dependencies:
   flutter:
     sdk: flutter
-  cometchat_chat_uikit: ^6.0.0-beta2     # calls bundled in
+  cometchat_chat_uikit: ^6.0     # calls bundled in
   permission_handler: ^11.0.0
   flutter_callkit_incoming: ^2.0.0       # standalone — VoIP UI bridge
   firebase_messaging: ^14.0.0            # standalone — Android FCM
@@ -195,7 +195,7 @@ If pub.dev resolution lags, use the Cloudsmith hosted pin:
 ```yaml
   cometchat_chat_uikit:
     hosted: https://dart.cloudsmith.io/cometchat/cometchat/
-    version: ^6.0.0-beta2
+    version: ^6.0.1
 ```
 
 Init (additive mode):
@@ -337,7 +337,7 @@ Dual-SDK + UIKit. Scaffold:
 
 When chat is already integrated. The skill:
 
-1. Confirms `cometchat_chat_uikit` is on `^6.0.0-beta2` — calls are already bundled.
+1. Confirms `cometchat_chat_uikit` is on `^6.0.1` — calls are already bundled.
 2. Patches the `CometChatUIKit.init` call to add `CometChatUIKitCalls.init` in the success callback (rule 1.1).
 3. Adds `CometChatDisplayIncomingCallOverlay` to `MaterialApp.builder` (rule 1.7).
 4. Confirms `CometChatMessageHeader` shows call buttons by default (`hideVoiceCallButton: false`, `hideVideoCallButton: false`).
@@ -359,7 +359,7 @@ When chat is already integrated. The skill:
 
 **Static:**
 
-- [ ] `cometchat_chat_uikit ^6.0.0-beta2` in pubspec.yaml (V6 bundles calls — no separate calls package)
+- [ ] `cometchat_chat_uikit ^6.0.1` in pubspec.yaml (V6 bundles calls — no separate calls package)
 - [ ] `CometChatUIKitCalls.init` called inside `CometChatUIKit.init`'s `onSuccess` (rule 1.1)
 - [ ] `CometChatUIKitCalls.init` called exactly once per app lifecycle
 - [ ] `CometChatDisplayIncomingCallOverlay` mounted in `MaterialApp.builder` (rule 1.7)

package/skills/cometchat-flutter-v6-calls/references/add-calls-to-existing-chat.md

@@ -1,6 +1,6 @@
 # Adding calls to an existing chat integration (Flutter V6 / Bloc)
 
-V6 calls are **bundled** into `cometchat_chat_uikit: ^6.0.0-beta2` — no separate calls package. Toggle on by enabling calling in the UIKit settings.
+V6 calls are **bundled** into `cometchat_chat_uikit: ^6.0` — no separate calls package. Toggle on by enabling calling in the UIKit settings.
 
 **Read first:** `cometchat-flutter-v6-calls/SKILL.md` — V6 architecture (Bloc).
 
@@ -11,7 +11,7 @@ V6 calls are **bundled** into `cometchat_chat_uikit: ^6.0.0-beta2` — no separa
 ```yaml
 # pubspec.yaml
 dependencies:
-  cometchat_chat_uikit: ^6.0.0-beta2   # V6 — calls bundled
+  cometchat_chat_uikit: ^6.0   # V6 — calls bundled
 ```
 
 If you see `cometchat_calls_uikit` separately listed, you're on V5 cohort — see `cometchat-flutter-v5-calls/references/add-calls-to-existing-chat.md`.
@@ -118,7 +118,7 @@ class CallBloc extends Bloc<CallEvent, CallState> {
 
 ## Verification checklist
 
-- [ ] `cometchat_chat_uikit: ^6.0.0-beta2` (or higher V6) in pubspec
+- [ ] `cometchat_chat_uikit: ^6.0` (or higher V6) in pubspec
 - [ ] `..enableCalling()` chained in UIKitSettingsBuilder
 - [ ] Native config (iOS + Android) same as V5
 - [ ] `CometChatIncomingCall` sibling-overlay at root