diff --git a/.claude/skills/perf-benchmarking/SKILL.md b/.claude/skills/perf-benchmarking/SKILL.md
index 5c74b3fe4f..728e28492f 100644
--- a/.claude/skills/perf-benchmarking/SKILL.md
+++ b/.claude/skills/perf-benchmarking/SKILL.md
@@ -5,6 +5,8 @@ description: Measure React Native performance on-device for stream-chat-react-na
 
 # Perf benchmarking (on-device, stream-chat-react-native)
 
+> For a full multi-hour base-vs-head comparison of every major flow (release builds, FlatList and FlashList, statistics), use the `perf-gauntlet` skill instead.
+
 How to measure SDK performance for real, against the **SampleApp running on a physical Android device**, using the committed `perf/` toolkit. This skill exists because the methodology is full of traps that produce confidently-wrong numbers; follow the rules and recipes here instead of improvising.
 
 Prerequisites for almost everything below:
diff --git a/.claude/skills/perf-gauntlet/SKILL.md b/.claude/skills/perf-gauntlet/SKILL.md
new file mode 100644
index 0000000000..c1e7519ce0
--- /dev/null
+++ b/.claude/skills/perf-gauntlet/SKILL.md
@@ -0,0 +1,272 @@
+---
+name: perf-gauntlet
+description: Full on-device performance gauntlet for stream-chat-react-native - a multi-hour, base-vs-head comparison of every major SDK flow (channel list, channel open with 100 messages, live events, composer, scroll, threads, context menu, cold start) on FlatList AND FlashList, in RELEASE builds with React's profiling renderer, with per-component render/re-render numbers, CPU per thread, frames, and statistics that survive emulator noise. Use when asked for "a full gauntlet", "perf smoke tests", "does this regress performance", "compare develop and this branch", "performance before release", or "run the perf thing again". Not for quick single-change checks (use perf-benchmarking for those).
+---
+
+# Perf gauntlet (base vs head, release builds, every major flow)
+
+This is the procedure behind the October 2026 develop-vs-V10 comparison. It produces a table of "JS work" per
+scenario for two builds (base = usually `origin/develop`, head = usually the working tree), with mount and
+re-render numbers per major component, FlatList vs FlashList, CPU per thread, frame stats, and confidence
+intervals. The harness lives in `perf/gauntlet/` (see its README for the file map). Read this whole file before
+starting: almost every rule below exists because breaking it produced confidently wrong numbers once.
+
+## 0. Before touching anything: tell the user what this costs, and ask two things
+
+Say this up front (adjust numbers if the plan differs):
+
+| Step | Time |
+|---|---|
+| Export base tree + install deps | 2-5 min |
+| First release build of the native project | 10-15 min (later builds: 1-2 min each, JS only) |
+| Seed one fresh user per session (~700 API calls each) | ~5 min per user, 4-8 users |
+| Dry runs (1 run per scenario, both sides) | ~30 min |
+| Main gauntlet: 4 sessions, ABBA, 5 runs per scenario | ~3.5 h (~50 min per session) |
+| Extra samples for small row/scroll deltas (12 short sessions) | ~1.6 h |
+| Diagnostic builds + root-causing | 0.5-2 h |
+| **Total** | **~5-7 h**, the emulator is busy the whole time |
+
+Ask (or default and say so):
+1. **What is base and what is head?** Default: base = `origin/develop`, head = the current working tree.
+2. **Which device?** Default: the Pixel 7 AVD (1080x2400; the driver's taps assume this size).
+
+Nothing in the repo is edited: every source change the measurement needs is applied at bundle time by the Metro
+config/transformer, and all output goes to `perf/gauntlet/out/` (gitignored). Never commit, never stash, never
+check out other refs in the user's tree (base is exported with `git archive`).
+
+## 1. The non-negotiable rules (each one cost hours once)
+
+1. **Release builds with React's profiling renderer, never debug.** Debug React is 3-4x slower and does dev-only
+   work that differs between versions; an attached CDP profiler doubles dev work again. The Metro config swaps
+   `ReactFabric-prod` for `ReactFabric-profiling`, which keeps `fiber.actualDuration` and Profiler commit hooks
+   in an otherwise normal release bundle.
+2. **The emulator's speed depends on the HOST, and it can silently drop 5-7x for React work.** Confirmed
+   mechanism: host memory pressure (gradle builds, yarn install, Metro/hermesc, a big IDE) makes macOS compress the
+   emulator's RAM (3.3 GB compressed right after two builds); memory-heavy work (React rendering, Fabric) then runs
+   5-7x slower until the emulator is cold-booted, while tight CPU loops look almost normal. It can also flip
+   mid-session. Therefore:
+   - do ALL builds first, `./gradlew --stop`, then COLD-BOOT the emulator, then measure; never build during a run;
+   - start the emulator from the user's Terminal panel (`run_in_terminal`), never from a background Bash task
+     (that gives it nice 5); `ps -o nice -p $(pgrep -f qemu-system | head -1)` must be 0;
+   - `preflight.sh` (run by `run.sh` before every session) waits for host load < 6 and refuses to measure when the
+     host has < 20% free memory, > 512 MB of the emulator is compressed, or an on-device CPU loop is > 1.4x its
+     calibration. When it stops a run: free memory, cold-boot the emulator, resume with the remaining users;
+   - inside the data, the per-window speed indices (`arith`, `mem` in `report.py main`) FLAG a mode change (they
+     rise ~60-70% when React work is 7x slower) but do not scale with it: never "normalize" across modes. If a
+     scenario's windows split into two clusters (e.g. cold start 230 ms vs 1550 ms with the same mounts), compare
+     only within one mode, and say so.
+3. **One native binary for both sides.** Build both APKs from THIS checkout's Android project; only the JS bundle
+   differs (`build.sh` points the RN gradle plugin at each side's SampleApp). `check-native-parity.cjs` must pass;
+   if native modules differ, each side needs its own native build and you must say the comparison includes native
+   changes.
+4. **A fresh, identically seeded user per session; ABBA side order; nothing else running.** Sessions mutate the
+   user's channels (new messages, reorders, unread counts), so a reused user is a different dataset. `run.sh`
+   alternates base/head as ABBA so slow drift cancels. Never seed, build or run Metro/gradle while a session runs.
+5. **Nothing that touches the UI hierarchy inside a measurement window.** `uiautomator dump` is slow and can hang
+   for minutes; all dumps happen before a window opens. Waits inside windows are fixed `settle` sleeps.
+6. **Never edit a script bash is executing.** Bash reads scripts incrementally; an edit mid-run corrupts the run.
+   `run.sh` freezes `session.sh` into `out/<name>/frozen/` first. To change scripts mid-gauntlet, write a new
+   file and `mv` it over (the running bash keeps the old inode).
+7. **Grant notifications after `pm clear`** (`session.sh` does). The Android 13+ permission dialog pauses the
+   activity AND the JS timers; a cold start behind it measures a paused app.
+8. **Cold start is `am force-stop; am start` back to back, with the window opened BEFORE the stop.** A plain
+   force-stop + wait lets Firebase's datatransport job restart the process ~0.4 s later, so the launch lands in a
+   half-initialized background process and cold starts become bimodal (1x vs 7x CPU).
+9. **Counts first, time second.** Render counts, mounts, hook counts and context changes are deterministic and
+   immune to emulator speed. Time on an emulator varies +/-10-15% between sessions; that is bigger than most real
+   effects. A timing claim of a few percent needs: (a) the session-level CI (`report.py ci`), (b) the result
+   normalized by the speed index, (c) JS-thread CPU agreeing. If they disagree, say the effect is below what the
+   emulator can resolve.
+10. **Before naming a cause, check the code is actually different.** If the "slower" components are unchanged
+    code with identical hook counts, the difference is the runtime, not the code. Use diagnostic builds (section
+    6) to prove a cause; never report a correlation as a cause.
+11. **FlatList windowing pollutes event windows.** About 3 in 10 FlatList event windows coincide with VirtualizedList
+    mounting a batch of ~30 cells (~1 s). `report.py` splits those out as `<scenario>~batch`; report them
+    separately, never in the event's median.
+12. **Don't flip-flop in front of the user.** Report interim numbers as interim ("not significant yet"), and only
+    give a verdict once the counts, CPU and the session-level CI agree. Say how big an effect the data can and
+    cannot rule out.
+
+## 2. How the harness measures (so you can interpret and extend it)
+
+`perf/gauntlet/runtime/probe.js` loads before anything else in the bundle (the Metro config replaces index.js's
+first import with `runtime/entry-shim.js`). It installs a fake `__REACT_DEVTOOLS_GLOBAL_HOOK__` before the renderer
+loads, so React reports every commit:
+
+| Metric | Source | Meaning |
+|---|---|---|
+| `render_ms` | HostRoot `actualDuration` | render phase incl. host-node creation |
+| `wall_ms` | hook time - HostRoot `actualStartTime` | render + Fabric commit (Yoga layout on the JS thread) + layout effects |
+| `layout_fx_ms` / `passive_fx_ms` | root `<Profiler onCommit/onPostCommit>` (AppRegistry patch) | effect time |
+| **`js_react_ms`** | `wall + passive` | **"JS work", the headline number** |
+| per component | fiber walk over reconciled subtrees | self ms, inclusive ms (outermost instance), renders (PerformedWork), mounts |
+| `dispatch_ms` | `client.dispatchEvent` wrapper (`probe-llc.js`, ES import so it hits the app's stream-chat build) | LLC event handling, per event type |
+| `cpu_js/main/rt/proc_ms` | `/proc/<pid>/task/*/stat` via `devmark.sh` at window edges | thread CPU (10 ms ticks), immune to preemption |
+| `speed_ms`, `mem_speed_ms` | a fixed arithmetic loop and a fixed allocate-and-walk loop, timed once a second | runtime state during the window; a jump flags a mode change (rule 2); lower = faster |
+| `frames` | `dumpsys gfxinfo` reset/dump per window | UI-thread frames, jank %, p50/p90/p99 (rough on emulators) |
+| `gc_n` | `HermesInternal.getInstrumentedStats()` once a second | GC count (coarse) |
+| counts | probe `M` lines | loaded messages per Bench channel: proves "100 loaded" on both sides |
+
+Everything is buffered and flushed to logcat once a second (`BENCH <kind> <json>`, < 3.5k chars per line). Windows
+are opened/closed by `devmark.sh` (`PERFMARK S|E <label> <device ms> <thread ticks>`); `analyze.py` matches by
+device clock. Commit ids and name ids restart per app process: everything is keyed by pid.
+
+Bundle-time changes (`gauntlet-transformer.js`, Metro config), identical on both sides:
+- SampleApp `ChannelListScreen` `message_limit: 25` -> `100` (so an opened channel has 100 loaded messages without
+  a network round trip; the bundle FAILS if the pattern disappears: update `MESSAGE_LIMIT_FROM`).
+- static tokens for the bench users replace `src/ChatUsers` (`runtime/generated/`, gitignored, 7-day validity).
+- `keep_fnames`/`keep_classnames`: without it the minifier mangles component names and attribution is wrong.
+- Diagnostic builds only (`GAUNTLET_DIAG=1`): hook counts per mount, context-value changes per commit, and which
+  `Message` `areEqual` check failed. Diag builds have their own Metro cache key; never take timings from them.
+
+## 3. Data and scenarios
+
+`seed.cjs <prefix>_sN` creates, for one device user: `Bench Mount` (160 mixed messages: text of every length,
+markdown, links with previews, mentions, 1-3 image galleries, voice recordings, files, quotes, reactions, 4 thread
+parents incl. one with 40 replies, edits, a pin, deletions; the latest 100 are what the list loads), `Bench Live`
+(same content, receives the events), 26 `Team NN` group channels and 2 DMs (some unread, some with image
+avatars). Other users (`bench_ana/ben/cleo/dan`) act through `actor.cjs` (HTTP on :9356, WS-connected so the device
+gets real events).
+
+| Scenario | Window | Notes |
+|---|---|---|
+| `cold_start` | force-stop + launch, 15 s | app start + channel list (offline DB first, then network) |
+| `list_msg_top`, `list_msg_reorder` | message into the top channel / into the channel at the bottom of the first page (10 channels) | reorder targets Team 21, 22, ... |
+| `list_reaction`, `list_typing`, `list_read`, `list_presence_on/off` | channel list events | presence = `bench_dan` connects/disconnects |
+| `open_channel_<impl>`, `close_channel_<impl>` | tap Bench Mount, 6 s / back, 3 s | mount of the 100-message list |
+| `ch_msg_new`, `ch_reaction`, `ch_edit`, `ch_typing`, `ch_read`, `ch_thread_reply` `_<impl>` | events into the open Bench Live | list settled 8 s first |
+| `composer_type_<impl>`, `ch_own_send_<impl>` | 16 chars typed / send tap | |
+| `scroll_<impl>` | 6 fixed swipes up through the 100 messages | |
+| `thread_open/close_<impl>`, `thread_reply_event_<impl>` | the 40-reply thread | parent found by scrolling before the window |
+| `menu_open`, `menu_close` | long-press newest message / back | FlatList phase only |
+| `x_open_flat`, `x_scroll_flat` | phase `rowcost`: open + scroll only | extra samples for small row-mount deltas |
+
+`<impl>` = `flat` (FlatList) or `flash` (FlashList); the session switches through the SampleApp secret menu
+(7+ taps on the drawer user name) and restarts the app.
+
+## 4. Procedure (exact commands; `G=perf/gauntlet`)
+
+**4.1 Environment** (do 4.2 builds FIRST if the emulator is already up, then cold-boot it before measuring)
+1. One device: `adb devices`. Start the emulator via `run_in_terminal`:
+   `~/Library/Android/sdk/emulator/emulator -avd Android16_Pixel7 -port 5556 -dns-server 8.8.8.8,1.1.1.1 -no-snapshot-load -no-snapshot-save -no-audio`
+   Wait for `getprop sys.boot_completed` = 1; `adb shell svc wifi enable`; check rule 2 (nice 0). Record the
+   original device settings (wifi, `debug_http_host`, animation scales, installed app) to restore afterwards.
+2. Stop anything that loads the host: Metro servers, old harness daemons, gradle daemons (`./gradlew --stop`)
+   after builds.
+
+**4.2 Builds**
+1. `bash $G/export-ref.sh origin/develop base-tree` (base; skip for the working tree).
+2. `GAUNTLET_USER_PREFIX=g<yyyymmdd> node $G/tokens.cjs 12` (fresh users each gauntlet: 4 main + 4 spare + 4
+   for extra runs). Tokens expire after 7 days: regenerate and REBUILD (the APK embeds them).
+3. `bash $G/build.sh base $G/out/trees/base-tree` and `bash $G/build.sh head .` (from the repo root). Each verifies
+   the probe is in the bundle and records the APK md5.
+4. `(cd examples/SampleApp/android && ./gradlew --stop)`, then COLD-BOOT the emulator (rule 2) and run
+   `bash $G/preflight.sh` until it passes. The first pass stores the device calibration for this gauntlet
+   (`out/device-calibration.txt`; delete it when you switch devices).
+
+**4.3 Seed** (sequentially, nothing measuring meanwhile): `for n in 1 2 3 4 5 6; do node $G/seed.cjs g<date>_s$n; done`
+in a background task. Start the actor: `nohup node $G/actor.cjs > $G/out/actor.log 2>&1 &` and check
+`curl -s 127.0.0.1:9356/x` returns `{"ok":true,"r":"unknown"}`.
+
+**4.4 Dry runs** (mandatory; cheap compared to a wasted session): `RUNS=1 bash $G/session.sh base base <user1>
+$G/out/dry-base` and the same for head (a separate spare user, or reuse user1 since dry data is thrown away).
+Then `python3 $G/analyze.py <dir>` and check:
+- no `WARN` in `session.log`; every expected scenario label present;
+- probe `M` lines: Bench Mount = 100 on both sides (`grep "BENCH M" logcat.txt`);
+- `report.py diff open_channel_flat <dirs>`: names are real component names (no `?NN`), `Message` mounts ~57
+  on FlatList, FlatList scenarios contain `VirtualizedList`/`CellRenderer`, FlashList ones contain `FlashList`;
+- speed index reasonable (1-3 ms) and stable.
+If the base SampleApp differs (testIDs, labels, secret menu), fix the driver now.
+
+**4.5 Main gauntlet** (background task; ~3.5 h):
+`RUNS=5 bash $G/run.sh main "setup warm cold list flat flash" base head g<date>_s1 g<date>_s2 g<date>_s3 g<date>_s4`
+Check progress every ~10 min (`out/main/progress.log`, `WARN` counts). After the first session, look at its
+speed index (`report.py main out/main` shows it per scenario): if it jumps between ~1x and ~5x+, rule 2 is broken.
+
+**4.6 Extra samples where the main table shows a small (< 10%) timing delta on mounts/scroll:**
+`RUNS=10 bash $G/run.sh rowcost "setup warm rowcost" base head u5 u5 u6 u6 u7 u7 u8 u8 u5 u5 u6 u6`
+(each user on both sides, so user state cancels; ~8 min per session).
+
+**4.7 Analyze**
+- `python3 $G/report.py main $G/out/main` (headline table), `lists` (FlatList vs FlashList), `comps` (major
+  components), `ci $G/out/main $G/out/rowcost` (session-level CIs), `diff <scenario> $G/out/main` (what moved).
+- For every "SLOWER" row and every surprising "faster" row, find the mechanism (section 5) before reporting it.
+
+## 5. Root-causing a delta (in this order)
+
+1. **Is it real?** `report.py ci`: does the CI exclude 0 on JS CPU AND on render/speed? If raw time moves but
+   render/speed does not, it is runtime speed, not code.
+2. **Is it more work or slower work?** `report.py diff <scenario>`: compare renders and mounts first. Different
+   counts = a real behavioural difference (deterministic). Same counts, more self time = check whether the code
+   of those components differs (`git diff <base> -- <file>`); identical code that got "slower" = runtime, not code.
+3. **Why does a row re-render?** Build diag APKs (`build.sh base-diag <root> diag`, `build.sh head-diag . diag`),
+   run `session.sh ... setup warm diagthread` (or add a phase for your scenario), then:
+   - `diag.py areequal <dir> <window>`: which `areEqual` check fails. EMPTY while rows re-render => they re-render
+     from a context/store they read themselves (memo bypassed), not from props.
+   - `diag.py ctx <dir> <window>`: which context values changed and which keys changed.
+   - `diag.py hooks <base-dir> <head-dir>`: hooks per mount per component and per message row.
+   Then read the consumer chain in code (who calls `useXContext()` inside the row?).
+4. **Write the cause with its evidence** (counts, the failing check, the changed context key, the code line).
+
+Worked examples from the first gauntlet: thread close re-rendered all 97 rows past the memo because rows read
+`useMessageInputContext()` (for `inputBoxRef`) and that context is rebuilt on `threadId` change; presence changes
+re-rendered every channel preview containing the user (the client fans the user object into every channel's
+members); "rows 5-7% slower" turned out to be runtime speed (unchanged code with identical hook counts got
+slower; normalized by the speed index it was +0.9%).
+
+## 6. Report format for the user
+
+Lead with the verdict in one sentence, then:
+1. **How it was measured** (2-4 lines: release + profiling renderer, same native binary, fresh seeded users,
+   N runs x sessions, JS work definition, what "significant" means). Mention anything discarded and why.
+2. **Main table** grouped by area (Channel list / Channel FlatList / Channel FlashList / Thread / Context menu /
+   Cold start): base ms, head ms, delta %, marking only significant changes, "same" otherwise.
+3. **Regressions, each with its mechanism and evidence** (counts, failing check, code location) and whether it
+   is fixable in SCRN or needs the LLC.
+4. **FlatList vs FlashList** table for head.
+5. **What the data cannot resolve** (e.g. "differences below ~5% on mounts are within emulator noise").
+6. **Follow-ups** with size (S/M/L) and confidence; ask which to do. Add them to the team's follow-up list if
+   asked (in this repo the misc list lives in the `scrn_state_cleanup_audit` memory).
+Offer to publish the report as a page. Keep raw tables in `out/`.
+
+## 7. Troubleshooting (symptom -> cause -> fix)
+
+| Symptom | Cause | Fix |
+|---|---|---|
+| Same work (same mounts) 5-7x faster/slower between runs or sessions; bimodal everything | host memory pressure compressed the emulator's RAM (builds, IDE) or emulator at nice 5 | builds first, then cold-boot the emulator from `run_in_terminal`; `preflight.sh` must pass; compare within one mode only |
+| `preflight: ... compressed` / `device loop ... >1.4x` | host compressed the emulator's RAM / device CPU starved | free host memory, `./gradlew --stop`, cold-boot the emulator, resume |
+| Cold starts bimodal; process exists with CPU before the window | Firebase job restarted the app after force-stop | `cold` phase (stop+start back to back) |
+| JS timers stop, flush lines stop, app looks frozen after login | notification permission dialog pausing the activity | `pm grant ... POST_NOTIFICATIONS` after `pm clear` |
+| No `BENCH E` lines (dispatch) | probe patched stream-chat via `require` (CJS build) while the app imports the ESM build | keep the LLC patch in `probe-llc.js` (ES `import`) |
+| No `BENCH M` lines on v10 | channels live in `client.channelManager`, not `activeChannels` | probe handles both |
+| Component names like `FlashList` inside FlatList windows, `?NN` names | name ids differ per process / mangled names | analyzer keys names by pid; keep `keep_fnames` |
+| Counts doubled after cold starts | commit ids restart per process | analyzer keys commits by pid |
+| `uiautomator dump` takes minutes | UI not idle / two dumps colliding | never run a manual dump while a session runs; `ui.py` kills a dump after 25 s |
+| Script did random things mid-run | it was edited while bash executed it | frozen copies; `mv` a new file over |
+| Thread step finds no parent / taps the header | label near the top or FlashList overshoot | `find.py` y-range; replay + look-down logic in `session.sh` |
+| A tap opened a Google sign-in / system screen | stray taps after a failed step | back out with `keyevent 4`; never interact with account screens |
+| `diag.py hooks` says no data for one side | the probe's DIAG switch did not apply | transformer matches `runtime/probe.js`; rebuild the diag APK |
+| zsh word-splitting breaks loops (`set -- $spec`, `$D` lists) | the tool shell is zsh | put loops in bash scripts (`run.sh`), or `bash -c` |
+| Report shows huge "typing" or "msg new" deltas on FlatList | VirtualizedList batch mounts in some windows | read the non-`~batch` rows; report batch frequency separately |
+
+## 8. Cleanup (always, and say what you did)
+
+Stop the actor (`pkill -f "node .*actor.cjs"`) and any `adb logcat` readers; `./gradlew --stop`; restore the
+device settings you recorded (wifi, `debug_http_host`, animation scales) and tell the user which APK is now
+installed (a release/diag gauntlet build replaces their debug app). Leave the emulator running in its terminal tab
+unless asked. Keep `out/` (gitignored) for the report; mention its size if large (exported trees with
+node_modules are ~1-2 GB).
+
+## 9. Adapting the harness
+
+- New SampleApp version changes the channel list query: update `MESSAGE_LIMIT_FROM` in `gauntlet-transformer.js`.
+- New testIDs/labels: `session.sh` uses `channel-list-view`, `channel-preview-button` (content-desc contains the
+  channel name), `message-flat-list`, `auto-complete-text-input`, `scroll-to-bottom-button`, `message-content-wrapper`,
+  text `NN Replies`, header text `Thread Reply`, secret-menu entries `FlatList`/`FlashList`.
+- Different screen size: the drawer/secret-menu taps (72,220 and 255,210), swipes and the composer y-limit (2100)
+  assume 1080x2400.
+- New scenario: add a window in `session.sh` (open the window right before the action, settle, close), give it a
+  stable `<scenario>#<run>` label, keep UI dumps outside the window, then add it to `report.py` groups if needed.
+- `seed.cjs`/`actor.cjs` use the stream-chat **v10** node API from this checkout (`package/node_modules`). Running
+  the harness from a v9 checkout needs the v9 signatures (`partialUpdateUser`, channel `name` vs `custom.name`).
+- Physical device: same flow; skip the emulator priority rule but keep everything else. Results will be tighter.
diff --git a/.prettierignore b/.prettierignore
index c4f36f8ee4..87842e38c5 100644
--- a/.prettierignore
+++ b/.prettierignore
@@ -28,6 +28,10 @@ yarn.lock
 package/src/components/docs/
 package/src/theme/generated/
 
+# Perf gauntlet output and generated tokens (gitignored)
+perf/gauntlet/out/
+perf/gauntlet/runtime/generated/
+
 # Workflow / tooling configs not owned by this project's Prettier
 .github/
 .husky/
diff --git a/AGENTS.md b/AGENTS.md
index a3ad572300..a0c4c35545 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -349,6 +349,7 @@ This repo ships three project skills — load the relevant one **before** touchi
 
 - `.claude/skills/accessibility` — VoiceOver/TalkBack work: interactive components, gestures, modals, lists, media controls, focus behavior, live announcements
 - `.claude/skills/rtl` — anything with a horizontal or directional axis: styles, positioning, flex, swipe gestures, animated transforms, icons, text alignment
+- `.claude/skills/perf-gauntlet` — the full multi-hour base-vs-head performance gauntlet (release builds with React's profiling renderer, every major flow on FlatList and FlashList, per-component mount/re-render numbers, session-level statistics). Harness in `perf/gauntlet/`.
 - `.claude/skills/perf-benchmarking` — on-device measurement: Hermes CPU profiles, render profiling, deterministic call counting, memory/jank capture. Drives `examples/SampleApp` on a connected Android device via the `perf/` toolkit (`scenario-lib.sh`, `capture-hermes-profile.js`, `analyze-react-profile.js`, `analyze-cpuprofile.js`, `android-heap-dump.sh`; see `perf/README.md`).
 
 Accessibility is **opt-in** — see `ai-docs/accessibility.md` for the full contract. New interactive UI should reuse the primitives in `package/src/a11y/`.
@@ -456,7 +457,7 @@ Never commit API keys or real user data. Example code must use obvious placehold
 ## References
 
 - **Agent deep dives:** `ai-docs/ai-migration.md` (v8 → v9) and `ai-docs/ai-migration-v9-to-v10.md` (v9 → v10) — load these instead of the prose upgrade guides for agent-driven migrations; `ai-docs/accessibility.md` (opt-in a11y layer); `ai-docs/i18n-v10-migration.md` + `ai-docs/i18n-v10-key-map.json` (English-only i18n, and the reviewed old-key → dotted-key map)
-- **Repo skills:** `.claude/skills/{accessibility,rtl,perf-benchmarking}`, `perf/README.md`
+- **Repo skills:** `.claude/skills/{accessibility,rtl,perf-benchmarking,perf-gauntlet}`, `perf/README.md`, `perf/gauntlet/README.md`
 - **Contributing / process:** `CONTRIBUTING.md`, `RELEASE_PROCESS.md`, `PULL_REQUEST_TEMPLATE.md`, `SECURITY.md`
 - **Component docs:** https://getstream.io/chat/docs/sdk/reactnative/
 - **Stream Chat API:** https://getstream.io/chat/docs/javascript/
diff --git a/ai-docs/accessibility.md b/ai-docs/accessibility.md
index 5bb42114b5..30c2da41c9 100644
--- a/ai-docs/accessibility.md
+++ b/ai-docs/accessibility.md
@@ -57,7 +57,8 @@ Integrators override per key:
 const i18n = new Streami18n({ language: 'nl' });
 i18n.registerTranslation('nl', {
   'avatar.accessibilityLabel': 'Avatar van {{name}}',
-  'messageList.scrollToBottom.withCount.accessibilityLabel': '{{count}} nieuwe berichten',
+  'messageList.scrollToBottom.withCount.accessibilityLabel_one': '{{count}} nieuw bericht',
+  'messageList.scrollToBottom.withCount.accessibilityLabel_other': '{{count}} nieuwe berichten',
 });
 <OverlayProvider accessibility={{ enabled: true }} i18nInstance={i18n}>
   <Chat client={client} i18nInstance={i18n}>
diff --git a/ai-docs/ai-migration-v9-to-v10.md b/ai-docs/ai-migration-v9-to-v10.md
index 1deee82024..8df3bc31ee 100644
--- a/ai-docs/ai-migration-v9-to-v10.md
+++ b/ai-docs/ai-migration-v9-to-v10.md
@@ -2519,6 +2519,84 @@ which is an older reply once the thread has been scrolled back.
 
 ---
 
+# Part Q — Bug fixes after the state cleanup
+
+## Q.1 Count strings are plural keys (breaking for translations)
+
+Five strings that take a `{{count}}` read "1 new messages" for a count of 1. They are plural keys now,
+like every other count string in the SDK. A translation dictionary has to provide the `_one` /
+`_other` forms (plus `_few`, `_many` and so on where the language needs them). i18next looks up the
+bundled English plural before an override of the bare key, so an override of the bare key no longer
+applies.
+
+| Key | Where |
+| --- | --- |
+| `messageList.newMessages.text` | the unread separator in a message list |
+| `messageList.scrollToBottom.withCount.accessibilityLabel` | the scroll-to-bottom button |
+| `channelPreview.unreadCount.accessibilityLabel` | a channel row's unread badge |
+| `message.reactionList.more.accessibilityLabel` | the clustered reaction list |
+| `avatar.channel.group.accessibilityLabel` | a group channel's avatar |
+
+```ts
+// Before
+'messageList.newMessages.text': '{{count}} neue Nachrichten',
+// After
+'messageList.newMessages.text_one': '{{count}} neue Nachricht',
+'messageList.newMessages.text_other': '{{count}} neue Nachrichten',
+```
+
+`TranslationDictionary` rejects the bare key, so a typed dictionary fails to compile until it is
+updated.
+
+## Q.2 Behaviour fixes
+
+- **Reactions sheet** (`MessageUserReactions` / `useFetchReactions`):
+  - reactions added to other messages no longer appear in an open sheet;
+  - the sheet no longer refetches, and briefly empties, on every reaction to its message;
+  - offline, the sheet shows the reactions stored in the offline database again, through
+    `client.queryReactionsAndHydrate` (as in v9);
+  - the counts come from `reaction_groups`, so a reaction added offline or not yet confirmed is
+    counted.
+- **Reminder header:** setting or clearing the time of an existing reminder switches the message
+  header between "Saved for later" and the reminder right away.
+- **`useHandleLiveLocationEvents`:** another message's ended share no longer marks the watched
+  location as stopped.
+- **`usePollAnswersPagination` / `usePollOptionVotesPagination`:** votes and answers that arrive
+  together are all kept. Only the last one used to survive.
+- **Thread list:** a failed refresh from the "new threads" banner shows "Couldn't load new threads. Tap
+  to retry", and tapping it retries. The tile could not appear before, and was not pressable.
+- **Channel list swipe sheet:** a direct chat shows "Online" when the other member is online. It used to
+  read the watcher count, which includes the current user, so the label was inverted.
+- **Sticky date header:** it shows again after scrolling back down from the oldest message.
+- **`MessageFlashList`:** a channel whose messages fit on screen no longer shows the date twice (the
+  sticky header over the inline separator).
+
+## Q.3 `isMessageAIGenerated` lives on `<Chat>` only (breaking)
+
+`<Chat isMessageAIGenerated>` is the only place to set it, and it defaults to a function that returns
+`false`. `<Channel>` no longer accepts the prop: `<Chat>`'s value always overrode it, in v9 as well, so
+it never had an effect. The message components read it from `useChatContext()`, and it is no longer on
+the message contexts.
+
+| Removed | Use instead |
+| --- | --- |
+| `<Channel isMessageAIGenerated={…}>` | `<Chat isMessageAIGenerated={…}>` |
+| `useMessagesContext().isMessageAIGenerated` | `useChatContext().isMessageAIGenerated` |
+| `useMessageContext().isMessageAIGenerated` | `useChatContext().isMessageAIGenerated` |
+| `MessageContent`'s `isMessageAIGenerated` prop | `<Chat isMessageAIGenerated={…}>` |
+
+```diff
+- <Channel channel={channel} isMessageAIGenerated={isAIMessage}>
++ <Chat client={client} isMessageAIGenerated={isAIMessage}>
+```
+
+```diff
+- const { isMessageAIGenerated } = useMessageContext();
++ const { isMessageAIGenerated } = useChatContext();
+```
+
+---
+
 # Part I — i18n
 
 ## 19. English-only bundle, dotted keys, shared runtime
diff --git a/ai-docs/i18n-v10-key-map.json b/ai-docs/i18n-v10-key-map.json
index 47f9e16257..6a4e3edbee 100644
--- a/ai-docs/i18n-v10-key-map.json
+++ b/ai-docs/i18n-v10-key-map.json
@@ -1320,7 +1320,7 @@
     "a11y/Channel with {{count}} members": {
       "key": "avatar.channel.group.accessibilityLabel",
       "prose": true,
-      "plural": false
+      "plural": true
     },
     "a11y/Clear search": {
       "key": "uiComponents.searchInput.clear.accessibilityLabel",
@@ -1630,7 +1630,7 @@
     "a11y/Scroll to bottom, {{count}} new messages": {
       "key": "messageList.scrollToBottom.withCount.accessibilityLabel",
       "prose": true,
-      "plural": false
+      "plural": true
     },
     "a11y/Search members": {
       "key": "channelDetails.memberList.search.accessibilityLabel",
@@ -1715,7 +1715,7 @@
     "a11y/and {{count}} more reactions": {
       "key": "message.reactionList.more.accessibilityLabel",
       "prose": true,
-      "plural": false
+      "plural": true
     },
     "a11y/you reacted": {
       "key": "message.reactionList.youReacted.accessibilityLabel",
@@ -1730,7 +1730,7 @@
     "a11y/{{count}} unread messages": {
       "key": "channelPreview.unreadCount.accessibilityLabel",
       "prose": true,
-      "plural": false
+      "plural": true
     },
     "a11y/{{name}} is already a member": {
       "key": "channelDetails.addMembers.alreadyMember.accessibilityLabel",
@@ -1925,7 +1925,7 @@
     "{{count}} new messages": {
       "key": "messageList.newMessages.text",
       "prose": true,
-      "plural": false
+      "plural": true
     },
     "{{count}} new threads": {
       "key": "threadList.unreadBanner.newThreads.label",
diff --git a/eslint.config.mjs b/eslint.config.mjs
index 97425a89b6..dfb9fea9ef 100644
--- a/eslint.config.mjs
+++ b/eslint.config.mjs
@@ -68,6 +68,10 @@ export default tsEslint.config(
       'package/native-package/',
       'package/expo-package/',
 
+      // Perf gauntlet: Node CommonJS scripts, an ES5 probe loaded ahead of the app, and
+      // exported baseline trees (with their own sources) under out/
+      'perf/gauntlet/',
+
       // Repo metadata
       '.github/',
       '.husky/',
diff --git a/examples/SampleApp/src/i18n/de.ts b/examples/SampleApp/src/i18n/de.ts
index 35d0418e1c..619e6b4695 100644
--- a/examples/SampleApp/src/i18n/de.ts
+++ b/examples/SampleApp/src/i18n/de.ts
@@ -81,7 +81,8 @@ export const de: TranslationDictionary = {
   // Avatars
   'avatar.accessibilityLabel': 'Avatar von {{name}}',
   'avatar.channel.direct.accessibilityLabel': 'Direktchat mit {{name}}',
-  'avatar.channel.group.accessibilityLabel': 'Kanal mit {{count}} Mitgliedern',
+  'avatar.channel.group.accessibilityLabel_one': 'Kanal mit {{count}} Mitglied',
+  'avatar.channel.group.accessibilityLabel_other': 'Kanal mit {{count}} Mitgliedern',
 
   // Channel screen, system messages and errors
   'channel.addMembersFailed.error': 'Mitglieder konnten nicht hinzugefügt werden',
@@ -216,7 +217,8 @@ export const de: TranslationDictionary = {
   'channelPreview.typing.withTwoUsers.label': '{{ firstUser }} und {{ secondUser }} tippen',
   'channelPreview.typing.withUser.label': '{{ user }} tippt',
   'channelPreview.typing.withUserCount.label': '{{ numberOfUsers }} Personen tippen',
-  'channelPreview.unreadCount.accessibilityLabel': '{{count}} ungelesene Nachrichten',
+  'channelPreview.unreadCount.accessibilityLabel_one': '{{count}} ungelesene Nachricht',
+  'channelPreview.unreadCount.accessibilityLabel_other': '{{count}} ungelesene Nachrichten',
 
   // Shared labels reused across screens
   'common.anonymousUser.label': 'Anonym',
@@ -305,7 +307,8 @@ export const de: TranslationDictionary = {
   'message.pinMessage.label': 'An Unterhaltung anheften',
   'message.pinned.text': 'Nachricht angeheftet',
   'message.pinnedBy.text': 'Angeheftet von',
-  'message.reactionList.more.accessibilityLabel': 'und {{count}} weitere Reaktionen',
+  'message.reactionList.more.accessibilityLabel_one': 'und {{count}} weitere Reaktion',
+  'message.reactionList.more.accessibilityLabel_other': 'und {{count}} weitere Reaktionen',
   'message.reactionList.viewHint.accessibilityLabel':
     'Doppelt tippen, um die Reaktionen anzuzeigen',
   'message.reactionList.youReacted.accessibilityLabel': 'du hast reagiert',
@@ -359,9 +362,12 @@ export const de: TranslationDictionary = {
 
   // Message list
   'messageList.dismissUnread.accessibilityLabel': 'Ungelesene Nachrichten ausblenden',
-  'messageList.newMessages.text': '{{count}} neue Nachrichten',
+  'messageList.newMessages.text_one': '{{count}} neue Nachricht',
+  'messageList.newMessages.text_other': '{{count}} neue Nachrichten',
   'messageList.scrollToBottom.accessibilityLabel': 'Nach unten scrollen',
-  'messageList.scrollToBottom.withCount.accessibilityLabel':
+  'messageList.scrollToBottom.withCount.accessibilityLabel_one':
+    'Nach unten scrollen, {{count}} neue Nachricht',
+  'messageList.scrollToBottom.withCount.accessibilityLabel_other':
     'Nach unten scrollen, {{count}} neue Nachrichten',
   'messageList.typing.withMoreUsers.label':
     '{{ firstUser }} und {{ nonSelfUserLength }} weitere tippen',
diff --git a/examples/SampleApp/src/i18n/it.ts b/examples/SampleApp/src/i18n/it.ts
index 329c9af405..7949c4c73a 100644
--- a/examples/SampleApp/src/i18n/it.ts
+++ b/examples/SampleApp/src/i18n/it.ts
@@ -76,7 +76,8 @@ export const it: TranslationDictionary = {
   // Avatars
   'avatar.accessibilityLabel': 'Avatar di {{name}}',
   'avatar.channel.direct.accessibilityLabel': 'Chat diretta con {{name}}',
-  'avatar.channel.group.accessibilityLabel': 'Canale con {{count}} membri',
+  'avatar.channel.group.accessibilityLabel_one': 'Canale con {{count}} membro',
+  'avatar.channel.group.accessibilityLabel_other': 'Canale con {{count}} membri',
 
   // Channel screen, system messages and errors
   'channel.addMembersFailed.error': 'Impossibile aggiungere membri',
@@ -210,7 +211,8 @@ export const it: TranslationDictionary = {
   'channelPreview.typing.withTwoUsers.label': '{{ firstUser }} e {{ secondUser }} stanno scrivendo',
   'channelPreview.typing.withUser.label': '{{ user }} sta scrivendo',
   'channelPreview.typing.withUserCount.label': '{{ numberOfUsers }} persone stanno scrivendo',
-  'channelPreview.unreadCount.accessibilityLabel': '{{count}} messaggi non letti',
+  'channelPreview.unreadCount.accessibilityLabel_one': '{{count}} messaggio non letto',
+  'channelPreview.unreadCount.accessibilityLabel_other': '{{count}} messaggi non letti',
 
   // Shared labels reused across screens
   'common.anonymousUser.label': 'Anonimo',
@@ -301,7 +303,8 @@ export const it: TranslationDictionary = {
   'message.pinMessage.label': 'Metti in evidenza',
   'message.pinned.text': 'Messaggio fissato',
   'message.pinnedBy.text': 'Fissato da',
-  'message.reactionList.more.accessibilityLabel': 'e altre {{count}} reazioni',
+  'message.reactionList.more.accessibilityLabel_one': "e un'altra reazione",
+  'message.reactionList.more.accessibilityLabel_other': 'e altre {{count}} reazioni',
   'message.reactionList.viewHint.accessibilityLabel': 'Tocca due volte per vedere le reazioni',
   'message.reactionList.youReacted.accessibilityLabel': 'hai reagito',
   'message.reminderOverdue.text': 'Promemoria scaduto',
@@ -355,9 +358,12 @@ export const it: TranslationDictionary = {
 
   // Message list
   'messageList.dismissUnread.accessibilityLabel': 'Ignora i messaggi non letti',
-  'messageList.newMessages.text': '{{count}} nuovi messaggi',
+  'messageList.newMessages.text_one': '{{count}} nuovo messaggio',
+  'messageList.newMessages.text_other': '{{count}} nuovi messaggi',
   'messageList.scrollToBottom.accessibilityLabel': 'Vai in fondo',
-  'messageList.scrollToBottom.withCount.accessibilityLabel':
+  'messageList.scrollToBottom.withCount.accessibilityLabel_one':
+    'Vai in fondo, {{count}} nuovo messaggio',
+  'messageList.scrollToBottom.withCount.accessibilityLabel_other':
     'Vai in fondo, {{count}} nuovi messaggi',
   'messageList.typing.withMoreUsers.label':
     '{{ firstUser }} e altri {{ nonSelfUserLength }} stanno scrivendo',
diff --git a/package/src/components/Channel/Channel.tsx b/package/src/components/Channel/Channel.tsx
index 261ae9c42c..fb97c36da8 100644
--- a/package/src/components/Channel/Channel.tsx
+++ b/package/src/components/Channel/Channel.tsx
@@ -36,7 +36,6 @@ import { ChannelContextValue, ChannelProvider } from '../../contexts/channelCont
 import { ChatContextValue, useChatContext } from '../../contexts/chatContext/ChatContext';
 import { useComponentsContext } from '../../contexts/componentsContext/ComponentsContext';
 import { MessageComposerProvider } from '../../contexts/messageComposerContext/MessageComposerContext';
-import { MessageContextValue } from '../../contexts/messageContext/MessageContext';
 import {
   InputMessageInputContextValue,
   MessageInputProvider,
@@ -231,7 +230,6 @@ export type ChannelPropsWithContext = Pick<ChannelContextValue, 'channel'> &
       | 'hasCreatePoll'
     >
   > &
-  Partial<Pick<MessageContextValue, 'isMessageAIGenerated'>> &
   Partial<
     Pick<ThreadContextValue, 'allowThreadMessagesInChannel' | 'onAlsoSentToChannelHeaderPress'>
   > & {
@@ -375,7 +373,6 @@ const ChannelWithContext = (props: PropsWithChildren<ChannelPropsWithContext>) =
     hideStickyDateHeader = false,
     initialScrollToFirstUnreadMessage = false,
     isAttachmentEqual,
-    isMessageAIGenerated = () => false,
     keyboardBehavior,
     keyboardVerticalOffset,
     markdownRules,
@@ -737,7 +734,6 @@ const ChannelWithContext = (props: PropsWithChildren<ChannelPropsWithContext>) =
     hasCreatePoll:
       hasCreatePoll === undefined ? pollCreationEnabled : hasCreatePoll && pollCreationEnabled,
     isAttachmentEqual,
-    isMessageAIGenerated,
     markdownRules,
     messageActions,
     messageContentOrder,
@@ -837,7 +833,7 @@ export type ChannelProps = Partial<Omit<ChannelPropsWithContext, 'channel' | 'th
  * @example ./Channel.md
  */
 export const Channel = (props: PropsWithChildren<ChannelProps>) => {
-  const { client, isMessageAIGenerated } = useChatContext();
+  const { client } = useChatContext();
   const { t } = useTranslationContext();
   const channel = useSupersededChannelSwap(props.channel);
   const notificationHostId =
@@ -866,10 +862,7 @@ export const Channel = (props: PropsWithChildren<ChannelProps>) => {
       {...props}
       channel={channel}
       shouldSyncChannel={shouldSyncChannel}
-      {...{
-        isMessageAIGenerated,
-        thread,
-      }}
+      thread={thread}
     />
   );
 
diff --git a/package/src/components/Channel/hooks/useCreateMessagesContext.ts b/package/src/components/Channel/hooks/useCreateMessagesContext.ts
index e9f10f61d9..dab7ad3ec6 100644
--- a/package/src/components/Channel/hooks/useCreateMessagesContext.ts
+++ b/package/src/components/Channel/hooks/useCreateMessagesContext.ts
@@ -30,7 +30,6 @@ export const useCreateMessagesContext = ({
   handleBlockUser,
   hasCreatePoll,
   isAttachmentEqual,
-  isMessageAIGenerated,
   markdownRules,
   messageActions,
   messageContentOrder,
@@ -86,7 +85,6 @@ export const useCreateMessagesContext = ({
       handleBlockUser,
       hasCreatePoll,
       isAttachmentEqual,
-      isMessageAIGenerated,
       markdownRules,
       messageActions,
       messageContentOrder,
diff --git a/package/src/components/ChannelPreview/ChannelDetailsBottomSheet.tsx b/package/src/components/ChannelPreview/ChannelDetailsBottomSheet.tsx
index 26e7348a03..dfcabd70c3 100644
--- a/package/src/components/ChannelPreview/ChannelDetailsBottomSheet.tsx
+++ b/package/src/components/ChannelPreview/ChannelDetailsBottomSheet.tsx
@@ -10,6 +10,7 @@ import { ChannelPreviewMutedStatus } from './ChannelPreviewMutedStatus';
 import { ChannelPreviewTitle } from './ChannelPreviewTitle';
 
 import { useBottomSheetContext } from '../../contexts/bottomSheetContext/BottomSheetContext';
+import { useChatContext } from '../../contexts/chatContext/ChatContext';
 import { useComponentsContext } from '../../contexts/componentsContext/ComponentsContext';
 import { useSwipeRegistryContext } from '../../contexts/swipeableContext/SwipeRegistryContext';
 import { useTheme } from '../../contexts/themeContext/ThemeContext';
@@ -34,11 +35,20 @@ export type ChannelDetailsBottomSheetProps = {
 
 export const ChannelDetailsHeader = ({ channel }: ChannelDetailsHeaderProps) => {
   const styles = useStyles();
+  const { client } = useChatContext();
   const { t } = useTranslationContext();
   const members = useChannelMembersState(channel);
   const memberCount = useMemo(() => Object.keys(members).length, [members]);
   const onlineCount = useChannelOnlineMemberCount(channel);
   const isDirectChat = useIsDirectChat(channel);
+  // The watcher count includes the current user, so a DM reads the other member's presence.
+  const isOtherMemberOnline = useMemo(
+    () =>
+      Object.values(members).some(
+        (member) => member.user?.id !== client.userID && member.user?.online,
+      ),
+    [client, members],
+  );
   const muted = useChannelMuteActive(channel);
   const displayedMemberCount = memberCount > 9 ? '9+' : `${memberCount}`;
   const displayedOnlineCount = onlineCount > 9 ? '9+' : `${onlineCount}`;
@@ -64,7 +74,7 @@ export const ChannelDetailsHeader = ({ channel }: ChannelDetailsHeaderProps) =>
         </View>
         <Text style={styles.headerMeta}>
           {isDirectChat
-            ? onlineCount === 1
+            ? isOtherMemberOnline
               ? t('common.presence.online.label', 'Online')
               : t('common.presence.offline.label', 'Offline')
             : membersAndOnlineLabel}
diff --git a/package/src/components/ChannelPreview/__tests__/ChannelDetailsBottomSheet.test.tsx b/package/src/components/ChannelPreview/__tests__/ChannelDetailsBottomSheet.test.tsx
index 337bb57300..e00e47deff 100644
--- a/package/src/components/ChannelPreview/__tests__/ChannelDetailsBottomSheet.test.tsx
+++ b/package/src/components/ChannelPreview/__tests__/ChannelDetailsBottomSheet.test.tsx
@@ -1,15 +1,19 @@
 import React, { type ComponentProps } from 'react';
 import { Text } from 'react-native';
 
-import { render } from '@testing-library/react-native';
+import { render, screen } from '@testing-library/react-native';
 import type { Channel } from 'stream-chat';
 
 import { ThemeProvider, defaultTheme } from '../../../contexts';
 import { WithComponents } from '../../../contexts/componentsContext/ComponentsContext';
 import type { ChannelActionItem } from '../../../hooks/actions/useChannelActionItems';
+import { initiateClientWithChannels } from '../../../mock-builders/api/initiateClientWithChannels';
+import { generateMember } from '../../../mock-builders/generator/member';
+import { generateUser } from '../../../mock-builders/generator/user';
+import { Chat } from '../../Chat/Chat';
 import { StreamBottomSheetModalFlatList } from '../../UIComponents/StreamBottomSheetModalFlatList';
 import type { ChannelDetailsHeaderProps } from '../ChannelDetailsBottomSheet';
-import { ChannelDetailsBottomSheet } from '../ChannelDetailsBottomSheet';
+import { ChannelDetailsBottomSheet, ChannelDetailsHeader } from '../ChannelDetailsBottomSheet';
 
 type StreamBottomSheetModalFlatListProps = ComponentProps<typeof StreamBottomSheetModalFlatList>;
 
@@ -91,3 +95,34 @@ describe('ChannelDetailsBottomSheet', () => {
     );
   });
 });
+
+describe('ChannelDetailsHeader', () => {
+  const me = generateUser({ id: 'me' });
+
+  const renderDirectChat = async (otherOnline: boolean, watcherCount: number) => {
+    const other = generateUser({ id: 'other', online: otherOnline });
+    const {
+      channels: [channel],
+      client,
+    } = await initiateClientWithChannels({
+      channelsData: [{ members: [generateMember({ user: me }), generateMember({ user: other })] }],
+      customUser: me,
+    });
+    channel.state.watcher_count = watcherCount;
+    render(
+      <Chat client={client}>
+        <ChannelDetailsHeader channel={channel} />
+      </Chat>,
+    );
+  };
+
+  it('shows a direct chat as offline while only the current user watches it', async () => {
+    await renderDirectChat(false, 1);
+    expect(await screen.findByText('Offline')).toBeTruthy();
+  });
+
+  it('shows a direct chat as online when the other member is online', async () => {
+    await renderDirectChat(true, 2);
+    expect(await screen.findByText('Online')).toBeTruthy();
+  });
+});
diff --git a/package/src/components/Chat/Chat.tsx b/package/src/components/Chat/Chat.tsx
index 72472dd8d8..01d6b73f87 100644
--- a/package/src/components/Chat/Chat.tsx
+++ b/package/src/components/Chat/Chat.tsx
@@ -170,6 +170,8 @@ export type ChatProps = Pick<ChatContextValue, 'client'> &
     style?: ThemeStyle;
   };
 
+const isNeverAIGenerated = () => false;
+
 const selector = (nextValue: OfflineDBState) =>
   ({
     initialized: nextValue.initialized,
@@ -184,7 +186,7 @@ const ChatWithContext = (props: PropsWithChildren<ChatProps>) => {
     enableOfflineSupport = false,
     getOfflineDbEncryptionKey,
     i18nInstance,
-    isMessageAIGenerated,
+    isMessageAIGenerated = isNeverAIGenerated,
     maxSyncEventsLimit = DEFAULT_MAX_SYNC_EVENTS_LIMIT,
     style,
     useNativeMultipartUpload = false,
diff --git a/package/src/components/Message/Message.tsx b/package/src/components/Message/Message.tsx
index d61e3a69ab..90cf83d8d4 100644
--- a/package/src/components/Message/Message.tsx
+++ b/package/src/components/Message/Message.tsx
@@ -211,10 +211,8 @@ export type MessagePropsWithContext = Pick<
   'channel' | 'enforceUniqueReaction'
 > &
   Pick<KeyboardContextValue, 'dismissKeyboard'> &
-  Partial<
-    Omit<MessageContextValue, 'groupStyles' | 'handleReaction' | 'message' | 'isMessageAIGenerated'>
-  > &
-  Pick<MessageContextValue, 'groupStyles' | 'message' | 'isMessageAIGenerated'> &
+  Partial<Omit<MessageContextValue, 'groupStyles' | 'handleReaction' | 'message'>> &
+  Pick<MessageContextValue, 'groupStyles' | 'message'> &
   Pick<
     MessageOperations,
     | 'sendReaction'
@@ -279,7 +277,7 @@ const MessageWithContext = (props: MessagePropsWithContext) => {
   const [showMessageReactions, setShowMessageReactions] = useState<boolean>(false);
   const [selectedReaction, setSelectedReaction] = useState<string | undefined>(undefined);
   const [isBounceDialogOpen, setIsBounceDialogOpen] = useState(false);
-  const { client } = useChatContext();
+  const { client, isMessageAIGenerated } = useChatContext();
 
   const {
     channel,
@@ -340,7 +338,6 @@ const MessageWithContext = (props: MessagePropsWithContext) => {
   } = useComponentsContext();
   // TODO: V9: Reconsider using safe area insets in every message.
   const insets = useSafeAreaInsets();
-  const isMessageAIGenerated = messagesContext.isMessageAIGenerated;
   const isAIGenerated = useMemo(
     () => isMessageAIGenerated(message),
     [message, isMessageAIGenerated],
@@ -731,7 +728,6 @@ const MessageWithContext = (props: MessagePropsWithContext) => {
     handleToggleReaction,
     hasReactions,
     images: attachments.images,
-    isMessageAIGenerated,
     isMyMessage,
     lastGroupMessage: groupStyles?.[0] === 'single' || groupStyles?.[0] === 'bottom',
     message: overlayActive ? frozenMessage.current : message,
diff --git a/package/src/components/Message/MessageItemView/MessageContent.tsx b/package/src/components/Message/MessageItemView/MessageContent.tsx
index ee4bb1a1d0..773177b978 100644
--- a/package/src/components/Message/MessageItemView/MessageContent.tsx
+++ b/package/src/components/Message/MessageItemView/MessageContent.tsx
@@ -65,7 +65,6 @@ export type MessageContentPropsWithContext = Pick<
   | 'otherAttachments'
   | 'preventPress'
   | 'threadList'
-  | 'isMessageAIGenerated'
 > &
   Pick<
     MessagesContextValue,
@@ -113,7 +112,6 @@ const MessageContentWithContext = (props: MessageContentPropsWithContext) => {
     groupStyles,
     goToMessage,
     hasInteractiveAccessibilityContent,
-    isMessageAIGenerated,
     isMyMessage,
     isVeryLastMessage,
     message,
@@ -129,7 +127,7 @@ const MessageContentWithContext = (props: MessageContentPropsWithContext) => {
     hidePaddingHorizontal,
     hidePaddingBottom,
   } = props;
-  const { client } = useChatContext();
+  const { client, isMessageAIGenerated } = useChatContext();
   const accessibilityHint = useA11yLabel('message.content.contextMenuHint.accessibilityLabel');
   const a11ySenderLabel = useA11yLabel(
     isMyMessage
@@ -615,7 +613,6 @@ export const MessageContent = (props: MessageContentProps) => {
     groupStyles,
     hasInteractiveAccessibilityContent,
     images,
-    isMessageAIGenerated,
     isMyMessage,
     message,
     messageContentOrder,
@@ -681,7 +678,6 @@ export const MessageContent = (props: MessageContentProps) => {
         groupStyles,
         hasInteractiveAccessibilityContent,
         isAttachmentEqual,
-        isMessageAIGenerated,
         isMyMessage,
         message,
         messageContentOrder,
diff --git a/package/src/components/Message/MessageItemView/MessageFooter.tsx b/package/src/components/Message/MessageItemView/MessageFooter.tsx
index fae1adf2bd..772d1b6adc 100644
--- a/package/src/components/Message/MessageItemView/MessageFooter.tsx
+++ b/package/src/components/Message/MessageItemView/MessageFooter.tsx
@@ -4,6 +4,7 @@ import { StyleSheet, Text, View } from 'react-native';
 import type { Attachment, LocalMessage } from 'stream-chat';
 
 import { useChannelContext } from '../../../contexts/channelContext/ChannelContext';
+import { useChatContext } from '../../../contexts/chatContext/ChatContext';
 import { useComponentsContext } from '../../../contexts/componentsContext/ComponentsContext';
 import {
   Alignment,
@@ -34,21 +35,14 @@ const isDirectChannelSelector = (state: { memberCount: number }) => ({
 
 type MessageFooterPropsWithContext = Pick<
   MessageContextValue,
-  'alignment' | 'message' | 'showMessageStatus' | 'lastGroupMessage' | 'isMessageAIGenerated'
+  'alignment' | 'message' | 'showMessageStatus' | 'lastGroupMessage'
 > &
   MessageFooterComponentProps;
 
 const MessageFooterWithContext = (props: MessageFooterPropsWithContext) => {
-  const {
-    alignment,
-    date,
-    formattedDate,
-    isMessageAIGenerated,
-    lastGroupMessage,
-    message,
-    showMessageStatus,
-  } = props;
+  const { alignment, date, formattedDate, lastGroupMessage, message, showMessageStatus } = props;
   const { channel } = useChannelContext();
+  const { isMessageAIGenerated } = useChatContext();
   const { isDirectChannel } = useStateStore(channel.state, isDirectChannelSelector) ?? {
     isDirectChannel: false,
   };
@@ -173,14 +167,12 @@ export type MessageFooterProps = MessageFooterComponentProps & {
 };
 
 export const MessageFooter = (props: MessageFooterProps) => {
-  const { alignment, isMessageAIGenerated, lastGroupMessage, message, showMessageStatus } =
-    useMessageContext();
+  const { alignment, lastGroupMessage, message, showMessageStatus } = useMessageContext();
 
   return (
     <MemoizedMessageFooter
       {...{
         alignment,
-        isMessageAIGenerated,
         lastGroupMessage,
         message,
         showMessageStatus,
diff --git a/package/src/components/Message/MessageItemView/MessageHeader.tsx b/package/src/components/Message/MessageItemView/MessageHeader.tsx
index 28ef164112..4b9478831d 100644
--- a/package/src/components/Message/MessageItemView/MessageHeader.tsx
+++ b/package/src/components/Message/MessageItemView/MessageHeader.tsx
@@ -2,35 +2,36 @@ import React, { useMemo } from 'react';
 
 import { View, ViewStyle } from 'react-native';
 
+import type { Reminder, ReminderState } from 'stream-chat';
+
 import { useComponentsContext } from '../../../contexts/componentsContext/ComponentsContext';
 import {
   MessageContextValue,
   useMessageContext,
 } from '../../../contexts/messageContext/MessageContext';
 import { useMessageReminder } from '../../../hooks/useMessageReminder';
+import { useStateStore } from '../../../hooks/useStateStore';
 
 type MessageHeaderPropsWithContext = Pick<MessageContextValue, 'alignment' | 'message'> & {
-  shouldShowSavedForLaterHeader?: boolean;
+  reminder?: Reminder;
   shouldShowPinnedHeader: boolean;
-  shouldShowReminderHeader: boolean;
   shouldShowSentToChannelHeader: boolean;
 };
 
+// Setting or clearing the time of an existing reminder publishes only on the reminder's own state.
+const hasRemindAtSelector = (state: ReminderState) => ({ hasRemindAt: state.remind_at != null });
+
+// Mounted only for a message with a reminder, so other messages never subscribe to one.
+const MessageReminderHeaderSwitch = ({ reminder }: { reminder: Reminder }) => {
+  const { MessageReminderHeader, MessageSavedForLaterHeader } = useComponentsContext();
+  const { hasRemindAt } = useStateStore(reminder.state, hasRemindAtSelector);
+  return hasRemindAt ? <MessageReminderHeader /> : <MessageSavedForLaterHeader />;
+};
+
 const MessageHeaderWithContext = (props: MessageHeaderPropsWithContext) => {
-  const {
-    alignment,
-    message,
-    shouldShowSavedForLaterHeader,
-    shouldShowPinnedHeader,
-    shouldShowReminderHeader,
-    shouldShowSentToChannelHeader,
-  } = props;
-  const {
-    MessagePinnedHeader,
-    MessageReminderHeader,
-    MessageSavedForLaterHeader,
-    SentToChannelHeader,
-  } = useComponentsContext();
+  const { alignment, message, reminder, shouldShowPinnedHeader, shouldShowSentToChannelHeader } =
+    props;
+  const { MessagePinnedHeader, SentToChannelHeader } = useComponentsContext();
 
   const containerStyle: ViewStyle = useMemo(() => {
     return {
@@ -40,8 +41,7 @@ const MessageHeaderWithContext = (props: MessageHeaderPropsWithContext) => {
 
   return (
     <View style={containerStyle}>
-      {shouldShowReminderHeader && <MessageReminderHeader />}
-      {shouldShowSavedForLaterHeader && <MessageSavedForLaterHeader />}
+      {reminder ? <MessageReminderHeaderSwitch reminder={reminder} /> : null}
       {shouldShowPinnedHeader && <MessagePinnedHeader message={message} />}
       {shouldShowSentToChannelHeader && <SentToChannelHeader />}
     </View>
@@ -54,16 +54,14 @@ const areEqual = (
 ) => {
   const {
     alignment: prevAlignment,
-    shouldShowSavedForLaterHeader: prevShouldShowSavedForLaterHeader,
+    reminder: prevReminder,
     shouldShowPinnedHeader: prevShouldShowPinnedHeader,
-    shouldShowReminderHeader: prevShouldShowReminderHeader,
     shouldShowSentToChannelHeader: prevShouldShowSentToChannelHeader,
   } = prevProps;
   const {
     alignment: nextAlignment,
-    shouldShowSavedForLaterHeader: nextShouldShowSavedForLaterHeader,
+    reminder: nextReminder,
     shouldShowPinnedHeader: nextShouldShowPinnedHeader,
-    shouldShowReminderHeader: nextShouldShowReminderHeader,
     shouldShowSentToChannelHeader: nextShouldShowSentToChannelHeader,
   } = nextProps;
 
@@ -72,9 +70,8 @@ const areEqual = (
     return false;
   }
 
-  const shouldShowSavedForLaterHeaderEqual =
-    prevShouldShowSavedForLaterHeader === nextShouldShowSavedForLaterHeader;
-  if (!shouldShowSavedForLaterHeaderEqual) {
+  const reminderEqual = prevReminder === nextReminder;
+  if (!reminderEqual) {
     return false;
   }
 
@@ -83,12 +80,6 @@ const areEqual = (
     return false;
   }
 
-  const shouldShowReminderHeaderEqual =
-    prevShouldShowReminderHeader === nextShouldShowReminderHeader;
-  if (!shouldShowReminderHeaderEqual) {
-    return false;
-  }
-
   const shouldShowSentToChannelHeaderEqual =
     prevShouldShowSentToChannelHeader === nextShouldShowSentToChannelHeader;
   if (!shouldShowSentToChannelHeaderEqual) {
@@ -109,17 +100,10 @@ export const MessageHeader = (props: MessageHeaderProps) => {
   const { alignment, message } = useMessageContext();
   const reminder = useMessageReminder(message.id);
 
-  const shouldShowSavedForLaterHeader = reminder != null && reminder.remindAt == null;
-  const shouldShowReminderHeader = reminder?.remindAt != null;
   const shouldShowPinnedHeader = !!message?.pinned;
   const shouldShowSentToChannelHeader = !!message?.show_in_channel;
 
-  if (
-    !shouldShowPinnedHeader &&
-    !shouldShowSavedForLaterHeader &&
-    !shouldShowReminderHeader &&
-    !shouldShowSentToChannelHeader
-  ) {
+  if (!shouldShowPinnedHeader && !reminder && !shouldShowSentToChannelHeader) {
     return null;
   }
 
@@ -127,9 +111,8 @@ export const MessageHeader = (props: MessageHeaderProps) => {
     <MemoizedMessageHeader
       alignment={alignment}
       message={message}
-      shouldShowSavedForLaterHeader={shouldShowSavedForLaterHeader}
+      reminder={reminder}
       shouldShowPinnedHeader={shouldShowPinnedHeader}
-      shouldShowReminderHeader={shouldShowReminderHeader}
       shouldShowSentToChannelHeader={shouldShowSentToChannelHeader}
       {...props}
     />
diff --git a/package/src/components/Message/MessageItemView/__tests__/MessageHeader.test.tsx b/package/src/components/Message/MessageItemView/__tests__/MessageHeader.test.tsx
new file mode 100644
index 0000000000..7fd7f22c9c
--- /dev/null
+++ b/package/src/components/Message/MessageItemView/__tests__/MessageHeader.test.tsx
@@ -0,0 +1,78 @@
+import React from 'react';
+import { Text } from 'react-native';
+
+import { act, render, screen } from '@testing-library/react-native';
+
+import { nowNs } from 'stream-chat';
+import type { StreamChat } from 'stream-chat';
+
+import { ChatProvider } from '../../../../contexts/chatContext/ChatContext';
+import { WithComponents } from '../../../../contexts/componentsContext/ComponentsContext';
+import { MessageProvider } from '../../../../contexts/messageContext/MessageContext';
+import { generateMessage } from '../../../../mock-builders/generator/message';
+import { getTestClientWithUser } from '../../../../mock-builders/mock';
+import { MessageHeader } from '../MessageHeader';
+
+describe('MessageHeader', () => {
+  let client: StreamChat;
+  const message = generateMessage({ id: 'message-1' });
+  const reminderData = (remindAt: number | null) =>
+    ({
+      channel_cid: 'messaging:general',
+      created_at: nowNs(),
+      message_id: 'message-1',
+      remind_at: remindAt,
+      updated_at: nowNs(),
+      user_id: 'me',
+    }) as never;
+
+  beforeEach(async () => {
+    client = await getTestClientWithUser({ id: 'me' });
+  });
+
+  afterEach(() => {
+    client.reminders.clearTimers();
+  });
+
+  const renderHeader = (headerMessage = message) =>
+    render(
+      <ChatProvider value={{ client } as never}>
+        <WithComponents
+          overrides={{
+            MessagePinnedHeader: () => <Text>pinned</Text>,
+            MessageReminderHeader: () => <Text>reminder</Text>,
+            MessageSavedForLaterHeader: () => <Text>saved for later</Text>,
+          }}
+        >
+          <MessageProvider value={{ alignment: 'left', message: headerMessage } as never}>
+            <MessageHeader />
+          </MessageProvider>
+        </WithComponents>
+      </ChatProvider>,
+    );
+
+  it('renders no reminder header for a message without a reminder', () => {
+    renderHeader({ ...message, pinned: true });
+    expect(screen.getByText('pinned')).toBeTruthy();
+    expect(screen.queryByText('reminder')).toBeNull();
+    expect(screen.queryByText('saved for later')).toBeNull();
+  });
+
+  it('switches between saved for later and reminder when the reminder time changes', () => {
+    client.reminders.upsertToState({ data: reminderData(null) });
+    renderHeader();
+    expect(screen.getByText('saved for later')).toBeTruthy();
+
+    act(() => {
+      client.reminders.upsertToState({ data: reminderData(nowNs() + 60_000_000_000) });
+    });
+    expect(screen.getByText('reminder')).toBeTruthy();
+    expect(screen.queryByText('saved for later')).toBeNull();
+
+    act(() => {
+      client.reminders.upsertToState({ data: reminderData(null) });
+    });
+    expect(screen.getByText('saved for later')).toBeTruthy();
+    expect(screen.queryByText('reminder')).toBeNull();
+  });
+});
diff --git a/package/src/components/Message/hooks/__tests__/useShouldUseOverlayStyles.test.tsx b/package/src/components/Message/hooks/__tests__/useShouldUseOverlayStyles.test.tsx
index 7ade6d0428..4e8cc6d260 100644
--- a/package/src/components/Message/hooks/__tests__/useShouldUseOverlayStyles.test.tsx
+++ b/package/src/components/Message/hooks/__tests__/useShouldUseOverlayStyles.test.tsx
@@ -26,7 +26,6 @@ const createMessageContextValue = (overrides: Partial<MessageContextValue>): Mes
     hasAttachmentActions: false,
     hasReactions: false,
     images: [],
-    isMessageAIGenerated: jest.fn(),
     isMyMessage: false,
     lastGroupMessage: false,
     members: {},
diff --git a/package/src/components/Message/hooks/useCreateMessageContext.ts b/package/src/components/Message/hooks/useCreateMessageContext.ts
index dfbeb5d92e..74107c7a26 100644
--- a/package/src/components/Message/hooks/useCreateMessageContext.ts
+++ b/package/src/components/Message/hooks/useCreateMessageContext.ts
@@ -31,7 +31,6 @@ export const useCreateMessageContext = ({
   hasReactions,
   messageHasOnlySingleAttachment,
   images,
-  isMessageAIGenerated,
   isMyMessage,
   lastGroupMessage,
   message,
@@ -93,7 +92,6 @@ export const useCreateMessageContext = ({
       hasReactions,
       messageHasOnlySingleAttachment,
       images,
-      isMessageAIGenerated,
       isMyMessage,
       lastGroupMessage,
       message,
diff --git a/package/src/components/MessageList/InlineUnreadIndicator.tsx b/package/src/components/MessageList/InlineUnreadIndicator.tsx
index a3e93916e9..a5d79c0768 100644
--- a/package/src/components/MessageList/InlineUnreadIndicator.tsx
+++ b/package/src/components/MessageList/InlineUnreadIndicator.tsx
@@ -18,7 +18,11 @@ export const InlineUnreadIndicator = (props: InlineUnreadIndicatorProps) => {
     <View accessibilityLabel='Inline unread indicator' style={styles.container}>
       <Text style={styles.text}>
         {unreadCount
-          ? t('messageList.newMessages.text', '{{count}} new messages', { count: unreadCount })
+          ? t('messageList.newMessages.text', {
+              count: unreadCount,
+              defaultValue_one: '{{count}} new message',
+              defaultValue_other: '{{count}} new messages',
+            })
           : t('messageList.unreadMessages.label', 'Unread Messages')}
       </Text>
     </View>
diff --git a/package/src/components/MessageList/MessageFlashList.tsx b/package/src/components/MessageList/MessageFlashList.tsx
index 23ee827e6e..6f17796212 100644
--- a/package/src/components/MessageList/MessageFlashList.tsx
+++ b/package/src/components/MessageList/MessageFlashList.tsx
@@ -517,10 +517,16 @@ const MessageFlashListWithContext = (props: MessageFlashListPropsWithContext) =>
     const viewableMessages = viewableItems.map((viewable) => viewable.item);
     // Not inverted: the first viewable item is the topmost one on screen.
     const topVisibleMessage = viewableMessages[0];
+    // Content shorter than the window cannot scroll, so FlashList keeps the offset of its initial
+    // scroll and misses the oldest message on screen. Short content shows every message.
+    const list = flashListRef.current;
+    const contentFitsWindow = list
+      ? list.getChildContainerDimensions().height <= list.getWindowSize().height
+      : false;
     const isAtOldestMessage =
       topVisibleMessage !== undefined &&
       !paginator?.hasMoreTail &&
-      processedMessageList[0]?.id === topVisibleMessage.id;
+      (contentFitsWindow || processedMessageList[0]?.id === topVisibleMessage.id);
 
     if (!hideStickyDateHeader && topVisibleMessage) {
       updateStickyHeaderDate({ isAtOldestMessage, topVisibleMessage });
diff --git a/package/src/components/MessageList/__tests__/InlineUnreadIndicator.test.tsx b/package/src/components/MessageList/__tests__/InlineUnreadIndicator.test.tsx
new file mode 100644
index 0000000000..b57956957e
--- /dev/null
+++ b/package/src/components/MessageList/__tests__/InlineUnreadIndicator.test.tsx
@@ -0,0 +1,26 @@
+import React from 'react';
+
+import { render, screen } from '@testing-library/react-native';
+
+import { ThemeProvider } from '../../../contexts/themeContext/ThemeContext';
+import { TranslationProvider } from '../../../contexts/translationContext/TranslationContext';
+import { Streami18n } from '../../../utils/i18n/Streami18n';
+import { InlineUnreadIndicator } from '../InlineUnreadIndicator';
+
+describe('InlineUnreadIndicator', () => {
+  it.each([
+    [1, '1 new message'],
+    [3, '3 new messages'],
+  ])('labels %i unread messages as "%s"', async (unreadCount, label) => {
+    const translators = await new Streami18n().init();
+    render(
+      <ThemeProvider>
+        <TranslationProvider value={{ ...translators, userLanguage: 'en' }}>
+          <InlineUnreadIndicator unreadCount={unreadCount} />
+        </TranslationProvider>
+      </ThemeProvider>,
+    );
+
+    expect(screen.getByText(label)).toBeTruthy();
+  });
+});
diff --git a/package/src/components/MessageList/__tests__/MessageFlashList.test.tsx b/package/src/components/MessageList/__tests__/MessageFlashList.test.tsx
new file mode 100644
index 0000000000..45f9f2e4a5
--- /dev/null
+++ b/package/src/components/MessageList/__tests__/MessageFlashList.test.tsx
@@ -0,0 +1,130 @@
+import React from 'react';
+import { Text, View } from 'react-native';
+
+import { act, render, screen, waitFor } from '@testing-library/react-native';
+import type { Channel as ChannelType, LocalMessage, StreamChat } from 'stream-chat';
+
+import { WithComponents } from '../../../contexts/componentsContext/ComponentsContext';
+import { OverlayProvider } from '../../../contexts/overlayContext/OverlayProvider';
+import { initiateClientWithChannels } from '../../../mock-builders/api/initiateClientWithChannels';
+import { generateMessage } from '../../../mock-builders/generator/message';
+import { Channel } from '../../Channel/Channel';
+import { Chat } from '../../Chat/Chat';
+import { MessageFlashList } from '../MessageFlashList';
+
+type ViewableItemsChanged = (info: {
+  viewableItems: { index: number; isViewable: boolean; item: LocalMessage; key: string }[];
+}) => void;
+
+const mockFlashList: {
+  containerHeight: number;
+  onViewableItemsChanged?: ViewableItemsChanged;
+  windowHeight: number;
+} = { containerHeight: 0, windowHeight: 700 };
+
+// Renders nothing but captures the viewability callback; the two sizes drive the "content fits" check
+// and every other ref method is a no-op.
+jest.mock('@shopify/flash-list', () => {
+  const ReactModule = jest.requireActual<typeof React>('react');
+  const { View: MockView } = jest.requireActual<typeof import('react-native')>('react-native');
+  return {
+    FlashList: ReactModule.forwardRef(
+      (
+        props: { onViewableItemsChanged: ViewableItemsChanged; testID?: string },
+        ref: React.Ref<unknown>,
+      ) => {
+        ReactModule.useImperativeHandle(
+          ref,
+          () =>
+            new Proxy(
+              {
+                getChildContainerDimensions: () => ({
+                  height: mockFlashList.containerHeight,
+                  width: 400,
+                }),
+                getWindowSize: () => ({ height: mockFlashList.windowHeight, width: 400 }),
+              },
+              {
+                get: (target, key) =>
+                  key in target ? target[key as keyof typeof target] : () => undefined,
+              },
+            ),
+        );
+        mockFlashList.onViewableItemsChanged = props.onViewableItemsChanged;
+        return <MockView testID={props.testID} />;
+      },
+    ),
+  };
+});
+
+describe('MessageFlashList sticky date header', () => {
+  let chatClient: StreamChat;
+  let channel: ChannelType;
+  let messages: LocalMessage[];
+
+  beforeEach(async () => {
+    ({
+      channels: [channel],
+      client: chatClient,
+    } = await initiateClientWithChannels());
+    messages = [generateMessage({ id: 'oldest' }), generateMessage({ id: 'newest' })].map(
+      (message) => channel.state.formatMessage(message as never),
+    );
+    channel.messagePaginator.setItems({
+      isFirstPage: true,
+      isLastPage: true,
+      valueOrFactory: messages,
+    });
+  });
+
+  const renderList = () =>
+    render(
+      <OverlayProvider>
+        <Chat client={chatClient}>
+          <WithComponents
+            overrides={{
+              StickyHeader: ({ date }) => (
+                <View testID='sticky-header'>
+                  <Text>{date ? 'shown' : 'hidden'}</Text>
+                </View>
+              ),
+            }}
+          >
+            <Channel channel={channel}>
+              <MessageFlashList />
+            </Channel>
+          </WithComponents>
+        </Chat>
+      </OverlayProvider>,
+    );
+
+  // FlashList reports only the newest message on short content: it keeps the offset of its initial
+  // scroll, which puts the oldest one above the window.
+  const reportOnlyNewestViewable = () =>
+    act(() => {
+      mockFlashList.onViewableItemsChanged?.({
+        viewableItems: [{ index: 1, isViewable: true, item: messages[1], key: 'newest' }],
+      });
+    });
+
+  it('stays hidden when every message fits on screen', async () => {
+    mockFlashList.containerHeight = 200;
+    renderList();
+    await waitFor(() => expect(mockFlashList.onViewableItemsChanged).toBeDefined());
+    expect(channel.messagePaginator.hasMoreTail).toBe(false);
+
+    reportOnlyNewestViewable();
+
+    expect(screen.getByText('hidden', { includeHiddenElements: true })).toBeTruthy();
+  });
+
+  it('shows the date of the topmost message when the content scrolls', async () => {
+    mockFlashList.containerHeight = 2000;
+    renderList();
+    await waitFor(() => expect(mockFlashList.onViewableItemsChanged).toBeDefined());
+
+    reportOnlyNewestViewable();
+
+    expect(screen.getByText('shown', { includeHiddenElements: true })).toBeTruthy();
+  });
+});
diff --git a/package/src/components/MessageList/__tests__/ScrollToBottomButton.test.tsx b/package/src/components/MessageList/__tests__/ScrollToBottomButton.test.tsx
index dab1e4b551..83e6a421f7 100644
--- a/package/src/components/MessageList/__tests__/ScrollToBottomButton.test.tsx
+++ b/package/src/components/MessageList/__tests__/ScrollToBottomButton.test.tsx
@@ -3,6 +3,7 @@ import React from 'react';
 import { cleanup, fireEvent, render, waitFor } from '@testing-library/react-native';
 import { nowNs } from 'stream-chat';
 
+import { AccessibilityProvider } from '../../../contexts/accessibilityContext/AccessibilityContext';
 import type { ChannelContextValue } from '../../../contexts/channelContext/ChannelContext';
 import { ChannelProvider } from '../../../contexts/channelContext/ChannelContext';
 import type { ChatContextValue } from '../../../contexts/chatContext/ChatContext';
@@ -125,4 +126,33 @@ describe('ScrollToBottomButton', () => {
       expect(toJSON()).toMatchSnapshot();
     });
   });
+
+  it.each([
+    [1, 'Scroll to bottom, 1 new message'],
+    [3, 'Scroll to bottom, 3 new messages'],
+  ])('labels the button for %i unread messages as "%s"', async (unreadMessages, label) => {
+    const translators = await new Streami18n().init();
+    const channel = {
+      state: generateChannelState({
+        read: { me: { last_read: nowNs(), unread_messages: unreadMessages, user: { id: 'me' } } },
+      }),
+    };
+    const { getByTestId } = render(
+      <ThemeProvider>
+        <AccessibilityProvider value={{ enabled: true }}>
+          <TranslationProvider value={{ ...translators, userLanguage: 'en' }}>
+            <ChatProvider value={{ client: { userID: 'me' } } as unknown as ChatContextValue}>
+              <ChannelProvider
+                value={{ channel, threadList: false } as unknown as ChannelContextValue}
+              >
+                <ScrollToBottomButton onPress={() => null} showNotification={true} />
+              </ChannelProvider>
+            </ChatProvider>
+          </TranslationProvider>
+        </AccessibilityProvider>
+      </ThemeProvider>,
+    );
+
+    expect(getByTestId('scroll-to-bottom-button').props.accessibilityLabel).toBe(label);
+  });
 });
diff --git a/package/src/components/MessageList/hooks/__tests__/useStickyHeaderDate.test.ts b/package/src/components/MessageList/hooks/__tests__/useStickyHeaderDate.test.ts
new file mode 100644
index 0000000000..1f4568a0e7
--- /dev/null
+++ b/package/src/components/MessageList/hooks/__tests__/useStickyHeaderDate.test.ts
@@ -0,0 +1,31 @@
+import { act, renderHook } from '@testing-library/react-native';
+
+import type { LocalMessage } from 'stream-chat';
+
+import { generateMessage } from '../../../../mock-builders/generator/message';
+import { convertDateToTimestamp } from '../../../../mock-builders/generator/time';
+import { useStickyHeaderDate } from '../useStickyHeaderDate';
+
+describe('useStickyHeaderDate', () => {
+  it('shows the date again after scrolling back down from the oldest message', () => {
+    const topVisibleMessage = generateMessage({
+      created_at: convertDateToTimestamp('2025-07-09T10:00:00.000Z'),
+    }) as unknown as LocalMessage;
+    const { result } = renderHook(() => useStickyHeaderDate());
+
+    act(() =>
+      result.current.updateStickyHeaderDate({ isAtOldestMessage: false, topVisibleMessage }),
+    );
+    expect(result.current.stickyHeaderDate?.toDateString()).toBe('Wed Jul 09 2025');
+
+    act(() =>
+      result.current.updateStickyHeaderDate({ isAtOldestMessage: true, topVisibleMessage }),
+    );
+    expect(result.current.stickyHeaderDate).toBeUndefined();
+
+    act(() =>
+      result.current.updateStickyHeaderDate({ isAtOldestMessage: false, topVisibleMessage }),
+    );
+    expect(result.current.stickyHeaderDate?.toDateString()).toBe('Wed Jul 09 2025');
+  });
+});
diff --git a/package/src/components/MessageList/hooks/useStickyHeaderDate.ts b/package/src/components/MessageList/hooks/useStickyHeaderDate.ts
index ba491476b5..204c0df967 100644
--- a/package/src/components/MessageList/hooks/useStickyHeaderDate.ts
+++ b/package/src/components/MessageList/hooks/useStickyHeaderDate.ts
@@ -22,6 +22,7 @@ export const useStickyHeaderDate = () => {
       topVisibleMessage: LocalMessage;
     }) => {
       if (isAtOldestMessage) {
+        stickyHeaderDateRef.current = undefined;
         setStickyHeaderDate(undefined);
         return;
       }
diff --git a/package/src/components/MessageMenu/MessageUserReactions.tsx b/package/src/components/MessageMenu/MessageUserReactions.tsx
index 34e5290bcb..d1751395b6 100644
--- a/package/src/components/MessageMenu/MessageUserReactions.tsx
+++ b/package/src/components/MessageMenu/MessageUserReactions.tsx
@@ -137,13 +137,13 @@ export const MessageUserReactions = (props: MessageUserReactionsProps) => {
             ...reactionData,
             onSelectReaction,
             selectedReaction,
-            count: (message?.reaction_counts?.[reactionData.type] ?? 0).toString(),
+            count: (message?.reaction_groups?.[reactionData.type]?.count ?? 0).toString(),
           });
         }
         return acc;
       }, []),
     [
-      message?.reaction_counts,
+      message?.reaction_groups,
       onSelectReaction,
       reactionTypes,
       selectedReaction,
@@ -194,11 +194,11 @@ export const MessageUserReactions = (props: MessageUserReactionsProps) => {
 
   const totalReactionCount = useMemo(
     () =>
-      Object.values(message?.reaction_counts ?? {}).reduce(
-        (acc, reactionCount) => acc + reactionCount,
+      Object.values(message?.reaction_groups ?? {}).reduce(
+        (acc, reactionGroup) => acc + reactionGroup.count,
         0,
       ),
-    [message?.reaction_counts],
+    [message?.reaction_groups],
   );
 
   const reactions = useMemo(
diff --git a/package/src/components/MessageMenu/__tests__/MessageUserReactions.test.tsx b/package/src/components/MessageMenu/__tests__/MessageUserReactions.test.tsx
index a9b5f08198..5e98d29159 100644
--- a/package/src/components/MessageMenu/__tests__/MessageUserReactions.test.tsx
+++ b/package/src/components/MessageMenu/__tests__/MessageUserReactions.test.tsx
@@ -148,6 +148,23 @@ describe('MessageUserReactions when the supportedReactions are defined', () => {
     expect(getByText('2 love')).toBeDefined();
   });
 
+  it('counts reactions from reaction_groups, which optimistic reactions update', () => {
+    const { getByText } = renderComponent({
+      message: {
+        ...generateMessage(),
+        reaction_counts: { like: 1, love: 1 },
+        reaction_groups: { like: { count: 3, sum_scores: 3 }, love: { count: 2, sum_scores: 2 } },
+      },
+    });
+
+    expect(getByText('3')).toBeTruthy();
+    expect(getByText('2')).toBeTruthy();
+    expect(mockTranslations.t).toHaveBeenLastCalledWith(
+      'messageMenu.userReactions.title',
+      expect.objectContaining({ count: 5 }),
+    );
+  });
+
   it('uses provided reactions when passed as a prop', () => {
     const propReactions = [{ id: '3', image: 'user3.jpg', name: 'User 3', type: 'wow' }];
     const { getByText } = renderComponent({ reactions: propReactions });
diff --git a/package/src/components/MessageMenu/hooks/__tests__/useFetchReactions.test.ts b/package/src/components/MessageMenu/hooks/__tests__/useFetchReactions.test.ts
index b3718bd5a4..ae39941883 100644
--- a/package/src/components/MessageMenu/hooks/__tests__/useFetchReactions.test.ts
+++ b/package/src/components/MessageMenu/hooks/__tests__/useFetchReactions.test.ts
@@ -1,9 +1,18 @@
-import { ReactionResponse } from 'stream-chat';
+import React, { PropsWithChildren } from 'react';
 
+import { act, renderHook, waitFor } from '@testing-library/react-native';
+
+import { LocalMessage, ReactionResponse, StreamChat } from 'stream-chat';
+
+import { ChatProvider } from '../../../../contexts/chatContext/ChatContext';
+import { generateMessage } from '../../../../mock-builders/generator/message';
+import { generateReaction } from '../../../../mock-builders/generator/reaction';
+import { getTestClientWithUser } from '../../../../mock-builders/mock';
 import {
   reconcileUpdatedReactionInList,
   removeReactionFromList,
   upsertReactionInList,
+  useFetchReactions,
 } from '../useFetchReactions';
 
 const makeReaction = (
@@ -54,3 +63,100 @@ describe('useFetchReactions helpers', () => {
     expect(result).toEqual([]);
   });
 });
+
+describe('useFetchReactions', () => {
+  let client: StreamChat;
+  let queryReactions: jest.SpyInstance;
+  const message = generateMessage({ id: 'message-1' }) as unknown as LocalMessage;
+  const fetched = generateReaction({ message_id: 'message-1', type: 'like' });
+
+  const wrapper = ({ children }: PropsWithChildren) =>
+    React.createElement(ChatProvider, { value: { client } as never }, children);
+
+  const renderUseFetchReactions = () =>
+    renderHook((props: { message: LocalMessage }) => useFetchReactions(props), {
+      initialProps: { message },
+      wrapper,
+    });
+
+  beforeEach(async () => {
+    client = await getTestClientWithUser({ id: 'me' });
+    queryReactions = jest
+      .spyOn(client, 'queryReactionsAndHydrate')
+      .mockResolvedValue({ duration: '1ms', reactions: [fetched] } as never);
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  it('queries through the offline-hydrating client method', async () => {
+    const { result } = renderUseFetchReactions();
+
+    await waitFor(() => expect(result.current.reactions).toEqual([fetched]));
+    expect(queryReactions).toHaveBeenCalledWith({ id: 'message-1' }, expect.anything());
+  });
+
+  it('applies reaction events for its own message only', async () => {
+    const { result } = renderUseFetchReactions();
+    await waitFor(() => expect(result.current.reactions).toEqual([fetched]));
+
+    const otherMessageReaction = generateReaction({ message_id: 'message-2', type: 'love' });
+    const ownMessageReaction = generateReaction({ message_id: 'message-1', type: 'love' });
+
+    act(() => {
+      client.dispatchEvent({ reaction: otherMessageReaction, type: 'reaction.new' } as never);
+    });
+    expect(result.current.reactions).toEqual([fetched]);
+
+    act(() => {
+      client.dispatchEvent({ reaction: ownMessageReaction, type: 'reaction.new' } as never);
+    });
+    expect(result.current.reactions).toEqual([ownMessageReaction, fetched]);
+
+    act(() => {
+      client.dispatchEvent({
+        reaction: { ...fetched, message_id: 'message-2' },
+        type: 'reaction.deleted',
+      } as never);
+    });
+    expect(result.current.reactions).toEqual([ownMessageReaction, fetched]);
+  });
+
+  it('applies offline reactions queried for its own message only', async () => {
+    const { result } = renderUseFetchReactions();
+    await waitFor(() => expect(result.current.reactions).toEqual([fetched]));
+
+    const otherMessageReaction = generateReaction({ message_id: 'message-2', type: 'love' });
+    const ownMessageReaction = generateReaction({ message_id: 'message-1', type: 'love' });
+
+    act(() => {
+      client.dispatchEvent({
+        offlineReactions: [otherMessageReaction],
+        type: 'offline_reactions.queried',
+      });
+    });
+    expect(result.current.reactions).toEqual([fetched]);
+
+    act(() => {
+      client.dispatchEvent({
+        offlineReactions: [ownMessageReaction],
+        type: 'offline_reactions.queried',
+      });
+    });
+    expect(result.current.reactions).toEqual([ownMessageReaction]);
+  });
+
+  it('does not refetch when the message object changes', async () => {
+    const { rerender, result } = renderUseFetchReactions();
+    await waitFor(() => expect(result.current.reactions).toEqual([fetched]));
+
+    rerender({ message: { ...message, reaction_groups: { like: { count: 2 } } } as never });
+    await act(async () => {
+      await Promise.resolve();
+    });
+
+    expect(queryReactions).toHaveBeenCalledTimes(1);
+    expect(result.current.reactions).toEqual([fetched]);
+  });
+});
diff --git a/package/src/components/MessageMenu/hooks/useFetchReactions.ts b/package/src/components/MessageMenu/hooks/useFetchReactions.ts
index b60fe60035..168e53ff63 100644
--- a/package/src/components/MessageMenu/hooks/useFetchReactions.ts
+++ b/package/src/components/MessageMenu/hooks/useFetchReactions.ts
@@ -4,6 +4,7 @@ import { LocalMessage, ReactionResponse, SortParamRequest } from 'stream-chat';
 
 import { useChatContext } from '../../../contexts/chatContext/ChatContext';
 import { useTranslationContext } from '../../../contexts/translationContext/TranslationContext';
+import { useStableCallback } from '../../../hooks/useStableCallback';
 import { useNotificationApi } from '../../Notifications';
 
 export type UseFetchReactionParams = {
@@ -105,13 +106,28 @@ export const useFetchReactions = ({
 
   const sortString = useMemo(() => JSON.stringify(sort), [sort]);
 
+  const notifyFetchFailed = useStableCallback((error: unknown) => {
+    addNotification({
+      message: t('messageMenu.userReactions.fetchFailed.error', 'Error fetching reactions'),
+      options: {
+        ...(error instanceof Error ? { originalError: error } : {}),
+        severity: 'error',
+        type: 'api:message:reactions:fetch:failed',
+      },
+      origin: {
+        ...(message ? { context: { message } } : {}),
+        emitter: 'Reactions',
+      },
+    });
+  });
+
   const fetchReactions = useCallback(
     async (next: string | undefined) => {
       if (!messageId) {
         return;
       }
       try {
-        const response = await client.queryReactions(
+        const response = await client.queryReactionsAndHydrate(
           { id: messageId },
           { filter: reactionType ? { type: reactionType } : undefined, limit, next, sort },
         );
@@ -124,21 +140,10 @@ export const useFetchReactions = ({
           setLoading(false);
         }
       } catch (error) {
-        addNotification({
-          message: t('messageMenu.userReactions.fetchFailed.error', 'Error fetching reactions'),
-          options: {
-            ...(error instanceof Error ? { originalError: error } : {}),
-            severity: 'error',
-            type: 'api:message:reactions:fetch:failed',
-          },
-          origin: {
-            ...(message ? { context: { message } } : {}),
-            emitter: 'Reactions',
-          },
-        });
+        notifyFetchFailed(error);
       }
     },
-    [addNotification, client, limit, message, messageId, reactionType, sort, t],
+    [client, limit, messageId, notifyFetchFailed, reactionType, sort],
   );
 
   const loadNextPage = useCallback(async () => {
@@ -158,7 +163,12 @@ export const useFetchReactions = ({
     listeners.push(
       client.on('offline_reactions.queried', (event) => {
         const { offlineReactions } = event;
-        if (offlineReactions) {
+        // The event does not say which message was queried.
+        const isForThisQuery = offlineReactions?.every(
+          (reaction) =>
+            reaction.message_id === messageId && (!reactionType || reaction.type === reactionType),
+        );
+        if (offlineReactions && isForThisQuery) {
           setReactions(offlineReactions);
           setLoading(false);
           setNext(undefined);
@@ -170,7 +180,7 @@ export const useFetchReactions = ({
       client.on('reaction.new', (event) => {
         const { reaction } = event;
 
-        if (reaction) {
+        if (reaction && reaction.message_id === messageId) {
           setReactions((prevReactions) =>
             upsertReactionInList({
               prevReactions,
@@ -186,7 +196,7 @@ export const useFetchReactions = ({
       client.on('reaction.updated', (event) => {
         const { reaction } = event;
 
-        if (reaction) {
+        if (reaction && reaction.message_id === messageId) {
           setReactions((prevReactions) =>
             reconcileUpdatedReactionInList({
               prevReactions,
@@ -202,7 +212,7 @@ export const useFetchReactions = ({
       client.on('reaction.deleted', (event) => {
         const { reaction } = event;
 
-        if (reaction) {
+        if (reaction && reaction.message_id === messageId) {
           setReactions((prevReactions) =>
             removeReactionFromList({
               prevReactions,
@@ -219,7 +229,7 @@ export const useFetchReactions = ({
         listener?.unsubscribe();
       });
     };
-  }, [client, reactionType]);
+  }, [client, messageId, reactionType]);
 
   return { loading, loadNextPage, reactions };
 };
diff --git a/package/src/components/Poll/hooks/__tests__/usePollPagination.test.tsx b/package/src/components/Poll/hooks/__tests__/usePollPagination.test.tsx
new file mode 100644
index 0000000000..92ea4d9c75
--- /dev/null
+++ b/package/src/components/Poll/hooks/__tests__/usePollPagination.test.tsx
@@ -0,0 +1,71 @@
+import React, { PropsWithChildren } from 'react';
+
+import { act, renderHook, waitFor } from '@testing-library/react-native';
+
+import type { PollVoteResponseData, StreamChat } from 'stream-chat';
+
+import { ChatProvider } from '../../../../contexts/chatContext/ChatContext';
+import { PollContextProvider } from '../../../../contexts/pollContext/pollContext';
+import { generateMessage } from '../../../../mock-builders/generator/message';
+import { getTestClientWithUser } from '../../../../mock-builders/mock';
+import { usePollAnswersPagination } from '../usePollAnswersPagination';
+import { usePollOptionVotesPagination } from '../usePollOptionVotesPagination';
+
+const answer = (id: string) =>
+  ({ answer_text: id, id, is_answer: true, poll_id: 'poll-1' }) as unknown as PollVoteResponseData;
+const vote = (id: string) =>
+  ({ id, option_id: 'option-1', poll_id: 'poll-1' }) as unknown as PollVoteResponseData;
+
+describe('poll pagination hooks', () => {
+  let client: StreamChat;
+  const emptyPage = { next: undefined, votes: [] };
+  const poll = {
+    id: 'poll-1',
+    queryAnswers: jest.fn(() => Promise.resolve(emptyPage)),
+    queryOptionVotes: jest.fn(() => Promise.resolve(emptyPage)),
+  };
+
+  const wrapper = ({ children }: PropsWithChildren) => (
+    <ChatProvider value={{ client } as never}>
+      <PollContextProvider value={{ message: generateMessage(), poll: poll as never }}>
+        {children}
+      </PollContextProvider>
+    </ChatProvider>
+  );
+
+  const castInOneBatch = (votes: PollVoteResponseData[]) =>
+    act(() => {
+      votes.forEach((pollVote) =>
+        client.dispatchEvent({
+          poll: { id: 'poll-1' },
+          poll_vote: pollVote,
+          type: 'poll.vote_casted',
+        } as never),
+      );
+    });
+
+  beforeEach(async () => {
+    client = await getTestClientWithUser({ id: 'me' });
+  });
+
+  it('keeps every answer cast in the same batch', async () => {
+    const { result } = renderHook(() => usePollAnswersPagination(), { wrapper });
+    await waitFor(() => expect(result.current.loading).toBe(false));
+
+    castInOneBatch([answer('a1'), answer('a2')]);
+
+    expect(result.current.pollAnswers.map(({ id }) => id)).toEqual(['a2', 'a1']);
+  });
+
+  it('keeps every option vote cast in the same batch', async () => {
+    const { result } = renderHook(
+      () => usePollOptionVotesPagination({ option: { id: 'option-1', text: 'One' } as never }),
+      { wrapper },
+    );
+    await waitFor(() => expect(result.current.loading).toBe(false));
+
+    castInOneBatch([vote('v1'), vote('v2')]);
+
+    expect(result.current.votes.map(({ id }) => id)).toEqual(['v2', 'v1']);
+  });
+});
diff --git a/package/src/components/Poll/hooks/usePollAnswersPagination.ts b/package/src/components/Poll/hooks/usePollAnswersPagination.ts
index 31b3229440..a4663ec7d7 100644
--- a/package/src/components/Poll/hooks/usePollAnswersPagination.ts
+++ b/package/src/components/Poll/hooks/usePollAnswersPagination.ts
@@ -85,7 +85,7 @@ export const usePollAnswersPagination = ({
         }
         const vote = event.poll_vote;
         if (vote && isVoteAnswer(vote)) {
-          setPollAnswers([vote, ...pollAnswers.filter((answer) => answer.id !== vote.id)]);
+          setPollAnswers((prev) => [vote, ...prev.filter((answer) => answer.id !== vote.id)]);
         }
       }),
     );
@@ -96,7 +96,7 @@ export const usePollAnswersPagination = ({
       }
       const vote = event.poll_vote;
       if (vote && isVoteAnswer(vote)) {
-        setPollAnswers(pollAnswers.filter((item) => item.id !== vote.id));
+        setPollAnswers((prev) => prev.filter((item) => item.id !== vote.id));
       }
     });
 
@@ -104,7 +104,7 @@ export const usePollAnswersPagination = ({
       castedListeners.forEach((listener) => listener.unsubscribe());
       removedListener.unsubscribe();
     };
-  }, [client, poll, pollAnswers]);
+  }, [client, poll]);
 
   return {
     error,
diff --git a/package/src/components/Poll/hooks/usePollOptionVotesPagination.ts b/package/src/components/Poll/hooks/usePollOptionVotesPagination.ts
index 3e18399b98..0d99ea398b 100644
--- a/package/src/components/Poll/hooks/usePollOptionVotesPagination.ts
+++ b/package/src/components/Poll/hooks/usePollOptionVotesPagination.ts
@@ -55,7 +55,8 @@ export const usePollOptionVotesPagination = ({
   const [error, setError] = useState<Error>();
   const cursorRef = useRef<string | null>(undefined);
   const queryInProgress = useRef(false);
-  const optionFilter = useMemo(() => ({ option_id: option.id }), [option.id]);
+  const optionId = option.id;
+  const optionFilter = useMemo(() => ({ option_id: optionId }), [optionId]);
 
   const loadMore = useCallback(async () => {
     if (cursorRef.current === null || queryInProgress.current) {
@@ -96,10 +97,10 @@ export const usePollOptionVotesPagination = ({
         }
         const vote = event.poll_vote;
         if (vote && !isVoteAnswer(vote)) {
-          if (vote.option_id === option.id) {
-            setVotes([vote, ...votes.filter((v) => v.id !== vote.id)]);
+          if (vote.option_id === optionId) {
+            setVotes((prev) => [vote, ...prev.filter((v) => v.id !== vote.id)]);
           } else if (eventName === 'poll.vote_changed') {
-            setVotes(votes.filter((v) => v.id !== vote.id));
+            setVotes((prev) => prev.filter((v) => v.id !== vote.id));
           }
         }
       }),
@@ -110,8 +111,8 @@ export const usePollOptionVotesPagination = ({
         return;
       }
       const vote = event.poll_vote;
-      if (vote && !isVoteAnswer(vote) && vote.option_id === option.id) {
-        setVotes(votes.filter((v) => v.id !== vote.id));
+      if (vote && !isVoteAnswer(vote) && vote.option_id === optionId) {
+        setVotes((prev) => prev.filter((v) => v.id !== vote.id));
       }
     });
 
@@ -119,7 +120,7 @@ export const usePollOptionVotesPagination = ({
       castedListeners.forEach((listener) => listener.unsubscribe());
       removedListener.unsubscribe();
     };
-  }, [client, option, poll, votes]);
+  }, [client, optionId, poll]);
 
   return {
     error,
diff --git a/package/src/components/ThreadList/ThreadListUnreadBanner.tsx b/package/src/components/ThreadList/ThreadListUnreadBanner.tsx
index fcd720ccbe..c1963ac5fd 100644
--- a/package/src/components/ThreadList/ThreadListUnreadBanner.tsx
+++ b/package/src/components/ThreadList/ThreadListUnreadBanner.tsx
@@ -1,4 +1,4 @@
-import React, { useMemo, useState } from 'react';
+import React, { useCallback, useMemo, useState } from 'react';
 import { Pressable, StyleSheet, Text, View } from 'react-native';
 
 import { ThreadManagerState } from 'stream-chat';
@@ -11,9 +11,13 @@ import { primitives } from '../../theme';
 const selector = (nextValue: ThreadManagerState) =>
   ({ unseenThreadIds: nextValue.unseenThreadIds }) as const;
 
+// The paginator records a failed reload and clears it on the next successful query.
+const lastQueryErrorSelector = (nextValue: { lastQueryError?: Error }) => ({
+  lastQueryError: nextValue.lastQueryError,
+});
+
 export const ThreadListUnreadBanner = () => {
   const [loading, setLoading] = useState(false);
-  const [error, setError] = useState<Error | null>(null);
   const { client } = useChatContext();
   const { icons } = useComponentsContext();
   const { t } = useTranslationContext();
@@ -22,16 +26,30 @@ export const ThreadListUnreadBanner = () => {
   } = useTheme();
   const styles = useStyles();
   const { unseenThreadIds } = useStateStore(client.threads.state, selector);
+  const { lastQueryError } = useStateStore(client.threads.paginator.state, lastQueryErrorSelector);
+
+  const pressableStyle = useCallback(
+    ({ pressed }: { pressed: boolean }) => [
+      styles.container,
+      {
+        backgroundColor: pressed
+          ? semantics.backgroundUtilityPressed
+          : semantics.backgroundCoreSurfaceDefault,
+      },
+    ],
+    [semantics, styles],
+  );
+
   if (!unseenThreadIds.length) {
     return null;
   }
 
   const handlePress = async () => {
+    setLoading(true);
     try {
-      setLoading(true);
       await client.threads.reload();
-    } catch (err) {
-      setError(err as Error);
+    } catch {
+      // Only with the paginator's `throwErrors`; the error is already in its state.
     } finally {
       setLoading(false);
     }
@@ -46,29 +64,19 @@ export const ThreadListUnreadBanner = () => {
     );
   }
 
-  if (error) {
+  if (lastQueryError) {
     return (
-      <View style={styles.container}>
+      <Pressable onPress={handlePress} style={pressableStyle}>
         <icons.ExclamationCircle stroke={semantics.textSecondary} height={20} width={20} />
         <Text style={styles.text}>
           {t('threadList.unreadBanner.loadFailed.error', "Couldn't load new threads. Tap to retry")}
         </Text>
-      </View>
+      </Pressable>
     );
   }
 
   return (
-    <Pressable
-      onPress={handlePress}
-      style={({ pressed }) => [
-        styles.container,
-        {
-          backgroundColor: pressed
-            ? semantics.backgroundUtilityPressed
-            : semantics.backgroundCoreSurfaceDefault,
-        },
-      ]}
-    >
+    <Pressable onPress={handlePress} style={pressableStyle}>
       <icons.Reload stroke={semantics.textSecondary} height={20} width={20} />
       <Text style={styles.text}>
         {t('threadList.unreadBanner.newThreads.label', {
diff --git a/package/src/components/ThreadList/__tests__/ThreadList.test.tsx b/package/src/components/ThreadList/__tests__/ThreadList.test.tsx
index 2c5adaebe6..6f9c3e1dd8 100644
--- a/package/src/components/ThreadList/__tests__/ThreadList.test.tsx
+++ b/package/src/components/ThreadList/__tests__/ThreadList.test.tsx
@@ -1,6 +1,6 @@
 import React from 'react';
 
-import { act, cleanup, render, screen, waitFor } from '@testing-library/react-native';
+import { act, cleanup, fireEvent, render, screen, waitFor } from '@testing-library/react-native';
 import type { Channel as ChannelType, StreamChat } from 'stream-chat';
 import { Thread } from 'stream-chat';
 
@@ -157,4 +157,26 @@ describe('ThreadList loading states', () => {
     act(() => chatClient.threads.state.partialNext({ unseenThreadIds: ['a', 'b'] }));
     await waitFor(() => expect(screen.getByText('2 new threads')).toBeTruthy());
   });
+
+  it('offers a retry when loading the new threads fails', async () => {
+    const query = jest
+      .spyOn(chatClient, 'queryThreadsAndHydrate')
+      .mockResolvedValueOnce({ next: undefined, threads: [makeThread()] });
+    render(
+      <Chat client={chatClient}>
+        <ThreadList isFocused />
+      </Chat>,
+    );
+    await waitFor(() => expect(rows()).toHaveLength(1));
+    act(() => chatClient.threads.state.partialNext({ unseenThreadIds: ['a'] }));
+
+    query.mockRejectedValueOnce(new Error('offline'));
+    fireEvent.press(await screen.findByText('1 new thread'));
+    const retry = await screen.findByText("Couldn't load new threads. Tap to retry");
+
+    query.mockResolvedValueOnce({ next: undefined, threads: [makeThread(), makeThread()] });
+    fireEvent.press(retry);
+    await waitFor(() => expect(rows()).toHaveLength(2));
+    expect(screen.queryByText("Couldn't load new threads. Tap to retry")).toBeNull();
+  });
 });
diff --git a/package/src/contexts/chatContext/ChatContext.tsx b/package/src/contexts/chatContext/ChatContext.tsx
index dde7834a47..1b5c97c777 100644
--- a/package/src/contexts/chatContext/ChatContext.tsx
+++ b/package/src/contexts/chatContext/ChatContext.tsx
@@ -1,8 +1,7 @@
 import React, { PropsWithChildren, useContext } from 'react';
 
-import type { GetApplicationResponse, StreamChat } from 'stream-chat';
+import type { GetApplicationResponse, LocalMessage, StreamChat } from 'stream-chat';
 
-import { MessageContextValue } from '../messageContext/MessageContext';
 import { DEFAULT_BASE_CONTEXT_VALUE } from '../utils/defaultBaseContextValue';
 
 import { isTestEnvironment } from '../utils/isTestEnvironment';
@@ -31,7 +30,9 @@ export type ChatContextValue = {
    * @overrideType StreamChat
    * */
   client: StreamChat;
-} & Partial<Pick<MessageContextValue, 'isMessageAIGenerated'>>;
+  /** Decides whether a message renders as AI generated. Defaults to never. */
+  isMessageAIGenerated: (message: LocalMessage) => boolean;
+};
 
 export const ChatContext = React.createContext(DEFAULT_BASE_CONTEXT_VALUE as ChatContextValue);
 
diff --git a/package/src/contexts/liveLocationManagerContext/hooks/__tests__/useHandleLiveLocationEvents.test.tsx b/package/src/contexts/liveLocationManagerContext/hooks/__tests__/useHandleLiveLocationEvents.test.tsx
new file mode 100644
index 0000000000..4da86df051
--- /dev/null
+++ b/package/src/contexts/liveLocationManagerContext/hooks/__tests__/useHandleLiveLocationEvents.test.tsx
@@ -0,0 +1,74 @@
+import React, { PropsWithChildren } from 'react';
+
+import { act, renderHook } from '@testing-library/react-native';
+
+import { msToNs } from 'stream-chat';
+import type { Channel, LocalMessage, StreamChat } from 'stream-chat';
+
+import { initiateClientWithChannels } from '../../../../mock-builders/api/initiateClientWithChannels';
+import { generateMessage } from '../../../../mock-builders/generator/message';
+import { ChatProvider } from '../../../chatContext/ChatContext';
+import { useHandleLiveLocationEvents } from '../useHandleLiveLocationEvents';
+
+const sharedLocation = (messageId: string, endAtMs: number) => ({
+  channel_cid: 'messaging:location',
+  created_by_device_id: 'device',
+  end_at: msToNs(endAtMs),
+  latitude: 1,
+  longitude: 2,
+  message_id: messageId,
+});
+
+describe('useHandleLiveLocationEvents', () => {
+  let client: StreamChat;
+  let channel: Channel;
+
+  const wrapper = ({ children }: PropsWithChildren) => (
+    <ChatProvider value={{ client } as never}>{children}</ChatProvider>
+  );
+
+  const updateMessage = (id: string, endAtMs: number) =>
+    act(() => {
+      client.dispatchEvent({
+        cid: channel.cid,
+        message: generateMessage({
+          id,
+          shared_location: sharedLocation(id, endAtMs) as never,
+        }) as unknown as LocalMessage,
+        type: 'message.updated',
+      } as never);
+    });
+
+  beforeEach(async () => {
+    ({
+      channels: [channel],
+      client,
+    } = await initiateClientWithChannels());
+  });
+
+  it('is not stopped by another message whose share ended', () => {
+    const { result } = renderHook(
+      () => useHandleLiveLocationEvents({ channel, messageId: 'watched' }),
+      { wrapper },
+    );
+
+    updateMessage('other', Date.now() - 60_000);
+
+    expect(result.current.isLiveLocationStopped).toBeNull();
+    expect(result.current.locationResponse).toBeUndefined();
+  });
+
+  it('stops when its own share ends', () => {
+    const { result } = renderHook(
+      () => useHandleLiveLocationEvents({ channel, messageId: 'watched' }),
+      { wrapper },
+    );
+
+    updateMessage('watched', Date.now() + 60_000);
+    expect(result.current.isLiveLocationStopped).toBeNull();
+    expect(result.current.locationResponse?.message_id).toBe('watched');
+
+    updateMessage('watched', Date.now() - 60_000);
+    expect(result.current.isLiveLocationStopped).toBe(true);
+  });
+});
diff --git a/package/src/contexts/liveLocationManagerContext/hooks/useHandleLiveLocationEvents.ts b/package/src/contexts/liveLocationManagerContext/hooks/useHandleLiveLocationEvents.ts
index 8c82734884..39bc98aa3c 100644
--- a/package/src/contexts/liveLocationManagerContext/hooks/useHandleLiveLocationEvents.ts
+++ b/package/src/contexts/liveLocationManagerContext/hooks/useHandleLiveLocationEvents.ts
@@ -39,14 +39,12 @@ export const useHandleLiveLocationEvents = ({
   useEffect(() => {
     const handleMessageUpdate = (event: EventPayload<'message.updated'>) => {
       const { message } = event;
-      if (!message || !message.shared_location) {
+      if (!message || !message.shared_location || message.id !== messageId) {
         return;
       }
       const { shared_location } = message;
-      if (message.id === messageId) {
-        setLocationResponse(message.shared_location as SharedLocationResponse);
-        onLocationUpdate?.(message.shared_location as SharedLocationResponse);
-      }
+      setLocationResponse(shared_location as SharedLocationResponse);
+      onLocationUpdate?.(shared_location as SharedLocationResponse);
       if (shared_location.end_at != null && shared_location.end_at <= nowNs()) {
         setIsLiveLocationStopped(true);
       }
diff --git a/package/src/contexts/messageContext/MessageContext.tsx b/package/src/contexts/messageContext/MessageContext.tsx
index dec4f3cead..21135c6e1a 100644
--- a/package/src/contexts/messageContext/MessageContext.tsx
+++ b/package/src/contexts/messageContext/MessageContext.tsx
@@ -59,10 +59,6 @@ export type MessageContextValue = {
   messageHasOnlySingleAttachment: boolean;
   /** The images attached to a message */
   images: Attachment[];
-  /**
-   * A factory function that determines whether a message is AI generated or not.
-   */
-  isMessageAIGenerated: (message: LocalMessage) => boolean;
   /** Whether or not this is the active user's message */
   isMyMessage: boolean;
   /** Whether or not this is the last message in a group of messages */
diff --git a/package/src/contexts/messagesContext/MessagesContext.tsx b/package/src/contexts/messagesContext/MessagesContext.tsx
index 46435b79bd..e45bfb3401 100644
--- a/package/src/contexts/messagesContext/MessagesContext.tsx
+++ b/package/src/contexts/messagesContext/MessagesContext.tsx
@@ -15,7 +15,7 @@ import type { MessageActionType } from '../../components/MessageMenu/MessageActi
 import { NativeHandlers } from '../../native';
 
 import type { ReactionData } from '../../utils/utils';
-import type { Alignment, MessageContextValue } from '../messageContext/MessageContext';
+import type { Alignment } from '../messageContext/MessageContext';
 import type { DeepPartial } from '../themeContext/ThemeContext';
 import type { Theme } from '../themeContext/utils/theme';
 import { DEFAULT_BASE_CONTEXT_VALUE } from '../utils/defaultBaseContextValue';
@@ -36,7 +36,7 @@ export type MessageLocationProps = {
   message: LocalMessage;
 };
 
-export type MessagesContextValue = Pick<MessageContextValue, 'isMessageAIGenerated'> & {
+export type MessagesContextValue = {
   /** Should keyboard be dismissed when messaged is touched */
   dismissKeyboardOnMessageTouch: boolean;
 
diff --git a/package/src/i18n/__tests__/callSites.test.ts b/package/src/i18n/__tests__/callSites.test.ts
index fccc569b35..2a7c0201a0 100644
--- a/package/src/i18n/__tests__/callSites.test.ts
+++ b/package/src/i18n/__tests__/callSites.test.ts
@@ -26,12 +26,15 @@ import { runtimeDefaults } from '../runtimeDefaults';
 
 const SRC = path.resolve(__dirname, '../..');
 const catalog = catalogJson as Record<string, string>;
-const bundledKeys = new Set(Object.keys(runtimeDefaults));
+const PLURAL_SUFFIX = /_(zero|one|two|few|many|other)$/;
+// A bundled plural is stored as `<key>_one` / `<key>_other` and called as the bare `<key>`.
+const bundledKeys = new Set(
+  Object.keys(runtimeDefaults).map((key) => key.replace(PLURAL_SUFFIX, '')),
+);
 
 /** Callables that translate their first argument. None of them takes an inline default. */
 const TRANSLATING = new Set(['t', 'translate', 'useA11yLabel']);
 
-const PLURAL_SUFFIX = /_(zero|one|two|few|many|other)$/;
 const catalogKeys = new Set(Object.keys(catalog));
 const pluralBases = new Set(
   Object.keys(catalog)
diff --git a/package/src/i18n/__tests__/catalog.fixture.json b/package/src/i18n/__tests__/catalog.fixture.json
index f916f6c4b6..cdadf0884a 100644
--- a/package/src/i18n/__tests__/catalog.fixture.json
+++ b/package/src/i18n/__tests__/catalog.fixture.json
@@ -49,7 +49,8 @@
   "autoCompleteInput.suggestions.mentionsAvailable.accessibilityLabel": "Mention suggestions available",
   "avatar.accessibilityLabel": "Avatar of {{name}}",
   "avatar.channel.direct.accessibilityLabel": "Direct chat with {{name}}",
-  "avatar.channel.group.accessibilityLabel": "Channel with {{count}} members",
+  "avatar.channel.group.accessibilityLabel_one": "Channel with {{count}} member",
+  "avatar.channel.group.accessibilityLabel_other": "Channel with {{count}} members",
   "channel.addMembersFailed.error": "Failed to add members",
   "channel.archiveUpdateFailed.error": "Failed to update channel archive status",
   "channel.archived.text": "Channel archived",
@@ -166,7 +167,8 @@
   "channelPreview.typing.withTwoUsers.label": "{{ firstUser }} and {{ secondUser }} are typing",
   "channelPreview.typing.withUser.label": "{{ user }} is typing",
   "channelPreview.typing.withUserCount.label": "{{ numberOfUsers }} people are typing",
-  "channelPreview.unreadCount.accessibilityLabel": "{{count}} unread messages",
+  "channelPreview.unreadCount.accessibilityLabel_one": "{{count}} unread message",
+  "channelPreview.unreadCount.accessibilityLabel_other": "{{count}} unread messages",
   "common.anonymousUser.label": "Anonymous",
   "common.cameraPermission.text": "Device camera is used to take photos or videos.",
   "common.cameraPermission.title": "Allow camera access in device settings",
@@ -240,7 +242,8 @@
   "message.pinMessage.label": "Pin to Conversation",
   "message.pinned.text": "Message pinned",
   "message.pinnedBy.text": "Pinned by",
-  "message.reactionList.more.accessibilityLabel": "and {{count}} more reactions",
+  "message.reactionList.more.accessibilityLabel_one": "and {{count}} more reaction",
+  "message.reactionList.more.accessibilityLabel_other": "and {{count}} more reactions",
   "message.reactionList.viewHint.accessibilityLabel": "Double tap to view reactions",
   "message.reactionList.youReacted.accessibilityLabel": "you reacted",
   "message.reminderOverdue.text": "Reminder overdue",
@@ -288,9 +291,11 @@
   "messageInput.sendMessage.accessibilityLabel": "Send message",
   "messageInput.sendMessageDisallowed.text": "You can't send messages in this channel",
   "messageList.dismissUnread.accessibilityLabel": "Dismiss unread messages",
-  "messageList.newMessages.text": "{{count}} new messages",
+  "messageList.newMessages.text_one": "{{count}} new message",
+  "messageList.newMessages.text_other": "{{count}} new messages",
   "messageList.scrollToBottom.accessibilityLabel": "Scroll to bottom",
-  "messageList.scrollToBottom.withCount.accessibilityLabel": "Scroll to bottom, {{count}} new messages",
+  "messageList.scrollToBottom.withCount.accessibilityLabel_one": "Scroll to bottom, {{count}} new message",
+  "messageList.scrollToBottom.withCount.accessibilityLabel_other": "Scroll to bottom, {{count}} new messages",
   "messageList.typing.withMoreUsers.label": "{{ firstUser }} and {{ nonSelfUserLength }} more are typing",
   "messageList.unreadMessages.label": "Unread Messages",
   "messageList.unreadMessages.withCount.label": "{{count}} unread",
diff --git a/package/src/i18n/keys.ts b/package/src/i18n/keys.ts
index 2178970fbd..976bfed276 100644
--- a/package/src/i18n/keys.ts
+++ b/package/src/i18n/keys.ts
@@ -60,7 +60,8 @@ export type TranslationCatalog = {
   'autoCompleteInput.suggestions.mentionsAvailable.accessibilityLabel': 'Mention suggestions available';
   'avatar.accessibilityLabel': 'Avatar of {{name}}';
   'avatar.channel.direct.accessibilityLabel': 'Direct chat with {{name}}';
-  'avatar.channel.group.accessibilityLabel': 'Channel with {{count}} members';
+  'avatar.channel.group.accessibilityLabel_one': 'Channel with {{count}} member';
+  'avatar.channel.group.accessibilityLabel_other': 'Channel with {{count}} members';
   'channel.addMembersFailed.error': 'Failed to add members';
   'channel.archiveUpdateFailed.error': 'Failed to update channel archive status';
   'channel.archived.text': 'Channel archived';
@@ -177,7 +178,8 @@ export type TranslationCatalog = {
   'channelPreview.typing.withTwoUsers.label': '{{ firstUser }} and {{ secondUser }} are typing';
   'channelPreview.typing.withUser.label': '{{ user }} is typing';
   'channelPreview.typing.withUserCount.label': '{{ numberOfUsers }} people are typing';
-  'channelPreview.unreadCount.accessibilityLabel': '{{count}} unread messages';
+  'channelPreview.unreadCount.accessibilityLabel_one': '{{count}} unread message';
+  'channelPreview.unreadCount.accessibilityLabel_other': '{{count}} unread messages';
   'common.anonymousUser.label': 'Anonymous';
   'common.cameraPermission.text': 'Device camera is used to take photos or videos.';
   'common.cameraPermission.title': 'Allow camera access in device settings';
@@ -251,7 +253,8 @@ export type TranslationCatalog = {
   'message.pinMessage.label': 'Pin to Conversation';
   'message.pinned.text': 'Message pinned';
   'message.pinnedBy.text': 'Pinned by';
-  'message.reactionList.more.accessibilityLabel': 'and {{count}} more reactions';
+  'message.reactionList.more.accessibilityLabel_one': 'and {{count}} more reaction';
+  'message.reactionList.more.accessibilityLabel_other': 'and {{count}} more reactions';
   'message.reactionList.viewHint.accessibilityLabel': 'Double tap to view reactions';
   'message.reactionList.youReacted.accessibilityLabel': 'you reacted';
   'message.reminderOverdue.text': 'Reminder overdue';
@@ -299,9 +302,11 @@ export type TranslationCatalog = {
   'messageInput.sendMessage.accessibilityLabel': 'Send message';
   'messageInput.sendMessageDisallowed.text': "You can't send messages in this channel";
   'messageList.dismissUnread.accessibilityLabel': 'Dismiss unread messages';
-  'messageList.newMessages.text': '{{count}} new messages';
+  'messageList.newMessages.text_one': '{{count}} new message';
+  'messageList.newMessages.text_other': '{{count}} new messages';
   'messageList.scrollToBottom.accessibilityLabel': 'Scroll to bottom';
-  'messageList.scrollToBottom.withCount.accessibilityLabel': 'Scroll to bottom, {{count}} new messages';
+  'messageList.scrollToBottom.withCount.accessibilityLabel_one': 'Scroll to bottom, {{count}} new message';
+  'messageList.scrollToBottom.withCount.accessibilityLabel_other': 'Scroll to bottom, {{count}} new messages';
   'messageList.typing.withMoreUsers.label': '{{ firstUser }} and {{ nonSelfUserLength }} more are typing';
   'messageList.unreadMessages.label': 'Unread Messages';
   'messageList.unreadMessages.withCount.label': '{{count}} unread';
@@ -450,7 +455,6 @@ export type BundledTranslationKey =
   | 'autoCompleteInput.suggestions.mentionsAvailable.accessibilityLabel'
   | 'avatar.accessibilityLabel'
   | 'avatar.channel.direct.accessibilityLabel'
-  | 'avatar.channel.group.accessibilityLabel'
   | 'channelDetails.addMembers.accessibilityLabel'
   | 'channelDetails.editChannel.accessibilityLabel'
   | 'channelDetails.editChannel.upload.accessibilityLabel'
@@ -465,7 +469,6 @@ export type BundledTranslationKey =
   | 'channelPreview.lastMessage.accessibilityLabel'
   | 'channelPreview.muted.accessibilityLabel'
   | 'channelPreview.pinned.accessibilityLabel'
-  | 'channelPreview.unreadCount.accessibilityLabel'
   | 'common.close.accessibilityLabel'
   | 'common.messageOverlay.swipeHint.accessibilityLabel'
   | 'duration.messageReminder'
@@ -477,7 +480,6 @@ export type BundledTranslationKey =
   | 'message.content.contextMenuHint.accessibilityLabel'
   | 'message.content.fromSender.accessibilityLabel'
   | 'message.content.fromYou.accessibilityLabel'
-  | 'message.reactionList.more.accessibilityLabel'
   | 'message.reactionList.viewHint.accessibilityLabel'
   | 'message.reactionList.youReacted.accessibilityLabel'
   | 'message.status.delivered.accessibilityLabel'
@@ -495,7 +497,6 @@ export type BundledTranslationKey =
   | 'messageInput.sendMessage.accessibilityLabel'
   | 'messageList.dismissUnread.accessibilityLabel'
   | 'messageList.scrollToBottom.accessibilityLabel'
-  | 'messageList.scrollToBottom.withCount.accessibilityLabel'
   | 'messageMenu.actionList.accessibilityLabel'
   | 'messageMenu.reactionPicker.moreReactions.accessibilityLabel'
   | 'notifications.attachmentUploadFailed.error'
diff --git a/package/src/i18n/runtimeDefaults.ts b/package/src/i18n/runtimeDefaults.ts
index 0e886b3ae9..b96c0a47f4 100644
--- a/package/src/i18n/runtimeDefaults.ts
+++ b/package/src/i18n/runtimeDefaults.ts
@@ -74,7 +74,8 @@ export const runtimeDefaults = {
     'Mention suggestions available',
   'avatar.accessibilityLabel': 'Avatar of {{name}}',
   'avatar.channel.direct.accessibilityLabel': 'Direct chat with {{name}}',
-  'avatar.channel.group.accessibilityLabel': 'Channel with {{count}} members',
+  'avatar.channel.group.accessibilityLabel_one': 'Channel with {{count}} member',
+  'avatar.channel.group.accessibilityLabel_other': 'Channel with {{count}} members',
   'channelDetails.addMembers.accessibilityLabel': 'Add members',
   'channelDetails.editChannel.accessibilityLabel': 'Edit channel',
   'channelDetails.editChannel.upload.accessibilityLabel': 'Upload channel image',
@@ -89,7 +90,8 @@ export const runtimeDefaults = {
   'channelPreview.lastMessage.accessibilityLabel': 'Last message {{date}}',
   'channelPreview.muted.accessibilityLabel': 'Muted',
   'channelPreview.pinned.accessibilityLabel': 'Pinned',
-  'channelPreview.unreadCount.accessibilityLabel': '{{count}} unread messages',
+  'channelPreview.unreadCount.accessibilityLabel_one': '{{count}} unread message',
+  'channelPreview.unreadCount.accessibilityLabel_other': '{{count}} unread messages',
   'common.close.accessibilityLabel': 'Close',
   'common.messageOverlay.swipeHint.accessibilityLabel':
     'Swipe right to go through different actions',
@@ -102,7 +104,8 @@ export const runtimeDefaults = {
     'Double tap and hold to activate contextual menu',
   'message.content.fromSender.accessibilityLabel': 'Message from {{sender}}',
   'message.content.fromYou.accessibilityLabel': 'Message from you',
-  'message.reactionList.more.accessibilityLabel': 'and {{count}} more reactions',
+  'message.reactionList.more.accessibilityLabel_one': 'and {{count}} more reaction',
+  'message.reactionList.more.accessibilityLabel_other': 'and {{count}} more reactions',
   'message.reactionList.viewHint.accessibilityLabel': 'Double tap to view reactions',
   'message.reactionList.youReacted.accessibilityLabel': 'you reacted',
   'message.status.delivered.accessibilityLabel': 'Delivered',
@@ -120,7 +123,9 @@ export const runtimeDefaults = {
   'messageInput.sendMessage.accessibilityLabel': 'Send message',
   'messageList.dismissUnread.accessibilityLabel': 'Dismiss unread messages',
   'messageList.scrollToBottom.accessibilityLabel': 'Scroll to bottom',
-  'messageList.scrollToBottom.withCount.accessibilityLabel':
+  'messageList.scrollToBottom.withCount.accessibilityLabel_one':
+    'Scroll to bottom, {{count}} new message',
+  'messageList.scrollToBottom.withCount.accessibilityLabel_other':
     'Scroll to bottom, {{count}} new messages',
   'messageMenu.actionList.accessibilityLabel': 'Message actions',
   'messageMenu.reactionPicker.moreReactions.accessibilityLabel': 'Open more reactions',
diff --git a/package/src/utils/__tests__/Streami18n.test.ts b/package/src/utils/__tests__/Streami18n.test.ts
index d2f0b578b3..e1a9258d44 100644
--- a/package/src/utils/__tests__/Streami18n.test.ts
+++ b/package/src/utils/__tests__/Streami18n.test.ts
@@ -58,6 +58,17 @@ describe('runtimeDefaults', () => {
       'timestamp.UserActivityStatus',
     ]);
   });
+
+  it.each([
+    ['avatar.channel.group.accessibilityLabel', 'Channel with 1 member'],
+    ['channelPreview.unreadCount.accessibilityLabel', '1 unread message'],
+    ['message.reactionList.more.accessibilityLabel', 'and 1 more reaction'],
+    ['messageList.scrollToBottom.withCount.accessibilityLabel', 'Scroll to bottom, 1 new message'],
+  ])('uses the singular of %s for a count of 1', async (key, singular) => {
+    const { t } = await new Streami18n().init();
+
+    expect(t(key as never, { count: 1 })).toBe(singular);
+  });
 });
 
 describe('English calendar wording', () => {
diff --git a/perf/README.md b/perf/README.md
index e02f80ad8b..2d0d098af8 100644
--- a/perf/README.md
+++ b/perf/README.md
@@ -86,3 +86,8 @@ For A/B comparisons, run the same scenario on both branches and diff the `Native
 - Keep captured `.cpuprofile` files in `perf/profiles/` (gitignored).
 - Name files descriptively: `baseline.cpuprofile`, `step-8.cpuprofile`, etc.
 - Profiles must be captured in dev mode (Metro) so function names are intact. Release builds are minified — desymbolicate with the matching source map if you need to analyze one.
+
+## Full gauntlet
+
+For a complete base-vs-head comparison of every major flow in release builds (5-7 hours), use `perf/gauntlet/`
+and the `perf-gauntlet` skill (`.claude/skills/perf-gauntlet/SKILL.md`).
diff --git a/perf/gauntlet/.gitignore b/perf/gauntlet/.gitignore
new file mode 100644
index 0000000000..4012adc2d7
--- /dev/null
+++ b/perf/gauntlet/.gitignore
@@ -0,0 +1,3 @@
+out/
+runtime/generated/
+__pycache__/
diff --git a/perf/gauntlet/README.md b/perf/gauntlet/README.md
new file mode 100644
index 0000000000..fe15cbf927
--- /dev/null
+++ b/perf/gauntlet/README.md
@@ -0,0 +1,46 @@
+# perf/gauntlet
+
+Harness for the base-vs-head performance gauntlet: release builds with React's profiling renderer, a seeded
+100-message channel, ~40 scenarios on FlatList and FlashList, per-component render/re-render numbers, thread CPU,
+frames and session-level statistics. **The procedure, rules and pitfalls are in
+`.claude/skills/perf-gauntlet/SKILL.md`; read it before running anything.** A full run takes 5-7 hours.
+
+All output goes to `out/` and generated tokens to `runtime/generated/` (both gitignored). Nothing in the SampleApp
+or the SDK is edited on disk; measurement changes are applied at bundle time.
+
+| File                               | Role                                                                                                                                                                                                                                                      |
+| ---------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `runtime/probe.js`                 | in-app probe: fake DevTools hook (per-commit render/wall, per-component self/inclusive/renders/mounts), root Profiler (effects), Hermes GC, speed index, loaded-message counts, diag-only hook/context/areEqual tracking; flushes `BENCH` lines to logcat |
+| `runtime/probe-llc.js`             | wraps `client.dispatchEvent` (ES import, so it patches the app's own stream-chat build)                                                                                                                                                                   |
+| `runtime/entry-shim.js`            | loads the probe ahead of the SampleApp's first import                                                                                                                                                                                                     |
+| `metro.gauntlet.config.js`         | wraps a SampleApp's Metro config: probe first, bench tokens, profiling renderer, kept fn names                                                                                                                                                            |
+| `gauntlet-transformer.js`          | bundle-time patches: 100 messages per channel; diag-only `areEqual` instrumentation                                                                                                                                                                       |
+| `gauntlet.init.gradle`             | points this checkout's RN gradle plugin at either side's SampleApp                                                                                                                                                                                        |
+| `export-ref.sh`                    | `git archive` a ref into `out/trees/<label>` + install (no git writes)                                                                                                                                                                                    |
+| `check-native-parity.cjs`          | refuses the one-native-binary build if native deps differ                                                                                                                                                                                                 |
+| `build.sh`                         | release APK (arm64) for one side, optional `diag` variant                                                                                                                                                                                                 |
+| `tokens.cjs`                       | static 7-day tokens for the bench users -> `runtime/generated/ChatUsers.gauntlet.ts`                                                                                                                                                                      |
+| `lib.cjs`, `seed.cjs`, `actor.cjs` | backend: deterministic seed per device user; WS-connected other users driven over HTTP :9356                                                                                                                                                              |
+| `devmark.sh`                       | on-device window marker with per-thread CPU ticks                                                                                                                                                                                                         |
+| `preflight.sh`                     | gate before every session: host load, host memory / compressed emulator RAM, emulator nice, device CPU calibration                                                                                                                                        |
+| `ui.py`, `find.py`                 | uiautomator driver (never used inside a window)                                                                                                                                                                                                           |
+| `session.sh`                       | one measurement session (setup, warm-up, phases)                                                                                                                                                                                                          |
+| `run.sh`                           | ABBA sequence of sessions from a frozen copy of `session.sh`                                                                                                                                                                                              |
+| `analyze.py`                       | logcat -> `windows.json` per session                                                                                                                                                                                                                      |
+| `report.py`                        | `main`, `lists`, `comps`, `ci`, `diff <scenario>`                                                                                                                                                                                                         |
+| `diag.py`                          | diag builds: `hooks`, `ctx`, `areequal`                                                                                                                                                                                                                   |
+
+Quick start (after reading the skill):
+
+```bash
+bash perf/gauntlet/export-ref.sh origin/develop base-tree
+GAUNTLET_USER_PREFIX=g20261012 node perf/gauntlet/tokens.cjs 12
+bash perf/gauntlet/build.sh base perf/gauntlet/out/trees/base-tree
+bash perf/gauntlet/build.sh head .
+(cd examples/SampleApp/android && ./gradlew --stop)   # then cold-boot the emulator
+bash perf/gauntlet/preflight.sh
+for n in 1 2 3 4; do node perf/gauntlet/seed.cjs g20261012_s$n; done
+nohup node perf/gauntlet/actor.cjs > perf/gauntlet/out/actor.log 2>&1 &
+RUNS=5 bash perf/gauntlet/run.sh main "setup warm cold list flat flash" base head g20261012_s1 g20261012_s2 g20261012_s3 g20261012_s4
+python3 perf/gauntlet/report.py main perf/gauntlet/out/main
+```
diff --git a/perf/gauntlet/actor.cjs b/perf/gauntlet/actor.cjs
new file mode 100644
index 0000000000..8356e4d5a5
--- /dev/null
+++ b/perf/gauntlet/actor.cjs
@@ -0,0 +1,116 @@
+// actor.cjs — the "other users" for bench scenarios, WS-connected so their actions reach the device as
+// real events. GET http://127.0.0.1:9356/<cmd>?...
+//   say&cid&user&text | react&id&user&type | unreact&id&user&type | edit&id&user&text | typing&cid&user
+//   read&cid&user | reply&cid&parent&user&text | rename&cid&name[&user] | online&user | offline&user | last&cid
+const http = require('http');
+const { connect } = require('./lib.cjs');
+console.log = (
+  (o) =>
+  (...a) =>
+    typeof a[0] === 'string' && a[0].startsWith('[') ? undefined : o(...a)
+)(console.log);
+console.info = console.warn = console.debug = () => {};
+
+const clients = {};
+const channels = {};
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+const client = async (user) => {
+  if (!clients[user]) clients[user] = await connect(user);
+  return clients[user];
+};
+const channel = async (user, cid) => {
+  const key = `${user}|${cid}`;
+  if (!channels[key]) {
+    const c = await client(user);
+    const [type, id] = cid.split(':');
+    channels[key] = c.channel(type, id);
+    await channels[key].watch();
+  }
+  return channels[key];
+};
+
+const cmds = {
+  say: async (q) =>
+    (
+      await (
+        await channel(q.get('user'), q.get('cid'))
+      ).sendMessage({ message: { text: q.get('text') || 'hi' } })
+    ).message.id,
+  reply: async (q) =>
+    (
+      await (
+        await channel(q.get('user'), q.get('cid'))
+      ).sendMessage({
+        message: { text: q.get('text') || 'reply', parent_id: q.get('parent') },
+      })
+    ).message.id,
+  react: async (q) =>
+    (
+      await (
+        await client(q.get('user'))
+      ).sendReaction({ id: q.get('id') }, { reaction: { type: q.get('type') || 'like' } })
+    ).reaction.type,
+  unreact: async (q) =>
+    !!(await (
+      await client(q.get('user'))
+    ).deleteReaction({ id: q.get('id'), type: q.get('type') || 'like' })),
+  edit: async (q) =>
+    (
+      await (
+        await client(q.get('user'))
+      ).updateMessage({ id: q.get('id') }, { message: { text: q.get('text') || 'edited' } })
+    ).message.text,
+  typing: async (q) => {
+    const ch = await channel(q.get('user'), q.get('cid'));
+    await ch.sendEvent({ event: { type: 'typing.start' } });
+    await sleep(Number(q.get('ms') || 1500));
+    await ch.sendEvent({ event: { type: 'typing.stop' } });
+    return 'typed';
+  },
+  read: async (q) => !!(await (await channel(q.get('user'), q.get('cid'))).markRead()),
+  rename: async (q) => {
+    const ch = await channel(q.get('user') || 'bench_ana', q.get('cid'));
+    const r = await ch.updatePartial({ set: { name: q.get('name') } });
+    return r.channel?.custom?.name ?? r.channel?.name;
+  },
+  online: async (q) => {
+    await client(q.get('user'));
+    return 'online';
+  },
+  offline: async (q) => {
+    const u = q.get('user');
+    if (clients[u]) {
+      await clients[u].disconnectUser();
+      delete clients[u];
+      for (const k of Object.keys(channels)) if (k.startsWith(`${u}|`)) delete channels[k];
+    }
+    return 'offline';
+  },
+  // ids of the newest n messages (default 10), newest last
+  last: async (q) => {
+    const ch = await channel('bench_ana', q.get('cid'));
+    const r = await ch.query({
+      messages: { limit: Number(q.get('n') || 10) },
+      state: true,
+      watch: false,
+    });
+    return r.messages.map((m) => ({
+      id: m.id,
+      user: m.user?.id,
+      text: (m.text || '').slice(0, 30),
+    }));
+  },
+};
+
+http
+  .createServer(async (req, res) => {
+    const u = new URL(req.url, 'http://x');
+    const f = cmds[u.pathname.slice(1)];
+    try {
+      const r = f ? await f(u.searchParams) : 'unknown';
+      res.end(JSON.stringify({ ok: true, r }));
+    } catch (e) {
+      res.end(JSON.stringify({ ok: false, e: e.message }));
+    }
+  })
+  .listen(9356, () => process.stdout.write('bench actor ready\n'));
diff --git a/perf/gauntlet/analyze.py b/perf/gauntlet/analyze.py
new file mode 100644
index 0000000000..90d4a98de7
--- /dev/null
+++ b/perf/gauntlet/analyze.py
@@ -0,0 +1,178 @@
+#!/usr/bin/env python3
+"""analyze.py <session-dir> — turns a bench session's logcat + gfxinfo dumps into per-window metrics.
+
+Input:  <dir>/logcat.txt   (adb logcat -v epoch, tags ReactNativeJS + PERFMARK)
+        <dir>/gfx/<label>.txt  (dumpsys gfxinfo after each window, reset at its start)
+Output: <dir>/windows.json  — one record per window (label = "<scenario>#<run>")
+
+Per window:
+  commits, render_ms (sum HostRoot actualDuration), wall_ms (sum render+commit+layout effects),
+  layout_fx_ms, passive_fx_ms, js_react_ms (= wall + passive), max_commit_wall_ms,
+  dispatch_ms / dispatch_n (LLC dispatchEvent), dispatch_by_type,
+  cpu_js_ms / cpu_main_ms / cpu_rt_ms / cpu_proc_ms (thread CPU time, 10ms ticks),
+  gc_n / gc_cpu_ms (Hermes, sampled once a second), frames (gfxinfo),
+  comps: {name: [incl_ms, self_ms, renders, mounts]}, counts (Bench channel loaded-message counts)
+"""
+import json
+import os
+import re
+import sys
+from collections import defaultdict
+
+LINE = re.compile(r'^\s*(\d+\.\d+)\s+(\d+)\s+\d+\s+\w\s+(\S+)\s*:\s?(.*)$')
+
+
+def parse(path):
+    names = {}
+    commits = {}  # cid -> dict
+    order = []
+    layout, passive, events, heap, counts, marks, speed = [], [], [], [], [], [], []
+    for raw in open(path, errors='replace'):
+        m = LINE.match(raw)
+        if not m:
+            continue
+        pid, tag, msg = m.group(2), m.group(3), m.group(4)
+        if tag == 'PERFMARK':
+            parts = msg.split()
+            if len(parts) < 3:
+                continue
+            kind, label, ts = parts[0], parts[1], int(parts[2])
+            threads = {}
+            for p in parts[3:]:
+                n, tid, ticks = p.split(':')
+                threads.setdefault(n, {})[tid] = int(ticks)
+            marks.append((kind, label, ts, threads))
+            continue
+        if tag != 'ReactNativeJS' or not msg.startswith('BENCH '):
+            continue
+        _, kind, payload = msg.split(' ', 2)
+        try:
+            data = json.loads(payload)
+        except json.JSONDecodeError:
+            continue
+        if kind == 'N':
+            # every app process numbers component names from 0
+            for i, n in data:
+                names[(pid, i)] = n
+        elif kind == 'C':
+            cid, ts, wall, render, walk = data
+            cid = (pid, cid)  # commit ids restart in every app process
+            commits[cid] = {'ts': ts, 'wall': wall, 'render': render, 'rows': [], 'pid': pid}
+            order.append(cid)
+        elif kind == 'D':
+            cid, rows = (pid, data[0]), data[1]
+            if cid in commits:
+                commits[cid]['rows'].extend(rows)
+        elif kind == 'L':
+            layout.append(data)
+        elif kind == 'P':
+            passive.append(data)
+        elif kind == 'E':
+            events.append(data)
+        elif kind == 'H':
+            heap.append(data)
+        elif kind == 'M':
+            counts.append(data)
+        elif kind == 'S':
+            speed.append(data)
+    return names, [commits[c] for c in order], layout, passive, events, heap, counts, marks, speed
+
+
+def gfx(path):
+    if not os.path.exists(path):
+        return None
+    t = open(path, errors='replace').read()
+    def num(pat):
+        m = re.search(pat, t)
+        return float(m.group(1)) if m else None
+    return {
+        'frames': num(r'Total frames rendered: (\d+)'),
+        'janky': num(r'Janky frames: (\d+)'),
+        'p50': num(r'50th percentile: (\d+)ms'),
+        'p90': num(r'90th percentile: (\d+)ms'),
+        'p95': num(r'95th percentile: (\d+)ms'),
+        'p99': num(r'99th percentile: (\d+)ms'),
+        'slow_ui': num(r'Number Slow UI thread: (\d+)'),
+        'missed_vsync': num(r'Number Missed Vsync: (\d+)'),
+    }
+
+
+def cpu_ms(start, end, name):
+    a, b = start.get(name, {}), end.get(name, {})
+    if name == 'mqt_v_js':
+        # several JS-named threads; the runtime one is the busiest
+        return max(((b[t] - a.get(t, 0)) * 10 for t in b), default=None)
+    return sum((b[t] - a.get(t, 0)) * 10 for t in b) if b else None
+
+
+def main(d):
+    names, commits, layout, passive, events, heap, counts, marks, speed = parse(os.path.join(d, 'logcat.txt'))
+    open_marks = {}
+    windows = []
+    for kind, label, ts, threads in marks:
+        if kind == 'S':
+            open_marks[label] = (ts, threads)
+        elif kind == 'E' and label in open_marks:
+            t0, th0 = open_marks.pop(label)
+            windows.append((label, t0, ts, th0, threads))
+    out = []
+    for label, t0, t1, th0, th1 in windows:
+        inside = lambda ts: t0 <= ts <= t1
+        cs = [c for c in commits if inside(c['ts'])]
+        comps = defaultdict(lambda: [0.0, 0.0, 0, 0])
+        for c in cs:
+            for row in c['rows']:
+                i, self_ms, incl, rend, mnt = row[:5]
+                e = comps[names.get((c['pid'], i), f'?{i}')]
+                e[0] += incl
+                e[1] += self_ms
+                e[2] += rend
+                e[3] += mnt
+        ev = [e for e in events if inside(e[0])]
+        by_type = defaultdict(lambda: [0, 0.0])
+        for _, typ, dt in ev:
+            by_type[typ][0] += 1
+            by_type[typ][1] += dt
+        h0 = max((h for h in heap if h[0] <= t0), key=lambda h: h[0], default=None)
+        h1 = min((h for h in heap if h[0] >= t1), key=lambda h: h[0], default=None)
+        rec = {
+            'label': label,
+            'scenario': label.split('#')[0],
+            'run': label.split('#')[1] if '#' in label else '0',
+            'dur_ms': t1 - t0,
+            'commits': len(cs),
+            'render_ms': sum(c['render'] for c in cs),
+            'wall_ms': sum(max(c['wall'], 0) for c in cs),
+            'max_commit_wall_ms': max((c['wall'] for c in cs), default=0),
+            'layout_fx_ms': sum(x[1] for x in layout if inside(x[0])),
+            'passive_fx_ms': sum(x[1] for x in passive if inside(x[0])),
+            'dispatch_ms': sum(e[2] for e in ev),
+            'dispatch_n': len(ev),
+            'dispatch_by_type': {k: [v[0], round(v[1], 2)] for k, v in by_type.items()},
+            'cpu_js_ms': cpu_ms(th0, th1, 'mqt_v_js'),
+            'cpu_main_ms': cpu_ms(th0, th1, 'main'),
+            'cpu_rt_ms': cpu_ms(th0, th1, 'RenderThread'),
+            'cpu_proc_ms': cpu_ms(th0, th1, 'proc'),
+            # a new process (cold start) restarts the counters
+            'gc_n': (h1[1] - (h0[1] if h1[1] >= h0[1] else 0)) if h0 and h1 else None,
+            'gc_cpu_ms': round(h1[2] - (h0[2] if h1[1] >= h0[1] else 0), 2) if h0 and h1 else None,
+            'frames': gfx(os.path.join(d, 'gfx', label.replace('/', '_') + '.txt')),
+            'counts': [c for c in counts if c[0] <= t1],
+            'comps': {k: [round(v[0], 2), round(v[1], 2), v[2], v[3]] for k, v in comps.items()},
+        }
+        rec['js_react_ms'] = rec['wall_ms'] + rec['passive_fx_ms']
+        sp = sorted(x[1] for x in speed if t0 - 1000 <= x[0] <= t1 + 1000)
+        rec['speed_ms'] = sp[len(sp) // 2] if sp else None
+        mp = sorted(x[3] for x in speed if len(x) > 3 and t0 - 1000 <= x[0] <= t1 + 1000)
+        rec['mem_speed_ms'] = mp[len(mp) // 2] if mp else None
+        rec['counts'] = {name: n for _, name, n in rec['counts']}
+        out.append(rec)
+    json.dump(out, open(os.path.join(d, 'windows.json'), 'w'), indent=1)
+    for r in out:
+        print(f"{r['label']:<28} commits={r['commits']:>4} render={r['render_ms']:8.1f} wall={r['wall_ms']:8.1f} "
+              f"passive={r['passive_fx_ms']:7.1f} disp={r['dispatch_ms']:6.1f}/{r['dispatch_n']} "
+              f"cpuJS={r['cpu_js_ms']} cpuUI={r['cpu_main_ms']} cpuRT={r['cpu_rt_ms']} gc={r['gc_n']}")
+
+
+if __name__ == '__main__':
+    main(sys.argv[1])
diff --git a/perf/gauntlet/build.sh b/perf/gauntlet/build.sh
new file mode 100755
index 0000000000..d92855f999
--- /dev/null
+++ b/perf/gauntlet/build.sh
@@ -0,0 +1,30 @@
+#!/bin/bash
+# build.sh <label> <repo-root> [diag] — release APK (arm64-v8a) for one side of a comparison: THIS checkout's
+# native project + <repo-root>'s SampleApp JS bundle through the gauntlet Metro config (probe, profiling
+# renderer, 100-message patch, kept fn names). Output: out/apk/<label>.apk (+ .hbc for checks).
+# `diag` builds a DIAGNOSTIC variant (areEqual logging, hook counts, context-change tracking): never use
+# a diag APK for measured numbers.
+# First build of the native project: 10-15 min. Later builds only rebundle JS: ~1-2 min each.
+set -euo pipefail
+G=$(cd "$(dirname "$0")" && pwd)
+REPO=$(cd "$G/../.." && pwd)
+LABEL=${1:?usage: build.sh <label> <repo-root> [diag]}; ROOT=$(cd "${2:?usage}" && pwd); MODE=${3:-}
+APP="$ROOT/examples/SampleApp"
+[ -f "$G/runtime/generated/ChatUsers.gauntlet.ts" ] || { echo "run tokens.cjs first"; exit 1; }
+node "$G/check-native-parity.cjs" "$REPO" "$ROOT"
+mkdir -p "$G/out/apk"
+cd "$REPO/examples/SampleApp/android"
+rm -rf app/build/generated/assets/createBundleReleaseJsAndAssets app/build/generated/res/createBundleReleaseJsAndAssets \
+  app/build/intermediates/sourcemaps/react/release app/build/outputs/apk/release
+if [ "$MODE" = diag ]; then export GAUNTLET_DIAG=1; else unset GAUNTLET_DIAG; fi
+GAUNTLET_APP=$APP GAUNTLET_DIR=$G ./gradlew assembleRelease --init-script "$G/gauntlet.init.gradle" \
+  -PreactNativeArchitectures=arm64-v8a > "$G/out/apk/$LABEL.build.log" 2>&1
+cp app/build/outputs/apk/release/app-release.apk "$G/out/apk/$LABEL.apk"
+unzip -p "$G/out/apk/$LABEL.apk" assets/index.android.bundle > "$G/out/apk/$LABEL.hbc"
+# (strings to a file first: with pipefail, `strings | grep -q` fails on SIGPIPE when grep exits early)
+strings "$G/out/apk/$LABEL.hbc" > "$G/out/apk/$LABEL.strings"
+for s in 'BENCH ' 'probe installed' 'llc probe installed'; do
+  grep -q "$s" "$G/out/apk/$LABEL.strings" || { echo "MISSING in bundle: $s"; exit 1; }
+done
+md5 -q "$G/out/apk/$LABEL.apk" > "$G/out/apk/$LABEL.md5" 2>/dev/null || md5sum "$G/out/apk/$LABEL.apk" | cut -d' ' -f1 > "$G/out/apk/$LABEL.md5"
+echo "built out/apk/$LABEL.apk from $ROOT${MODE:+ ($MODE)}"
diff --git a/perf/gauntlet/check-native-parity.cjs b/perf/gauntlet/check-native-parity.cjs
new file mode 100644
index 0000000000..cd45605753
--- /dev/null
+++ b/perf/gauntlet/check-native-parity.cjs
@@ -0,0 +1,35 @@
+// check-native-parity.cjs <repoA> <repoB> — the one-native-project trick (build.sh) is only valid when both
+// SampleApps ship the same native modules. Compares the dependency maps of the SampleApp and the native
+// wrapper; JS-only packages that may legitimately differ are listed in JS_ONLY. Exits 1 on a native diff.
+const path = require('path');
+const JS_ONLY = new Set([
+  'stream-chat',
+  '@stream-io/state-store',
+  '@stream-io/i18n',
+  'dayjs',
+  'i18next',
+  'stream-chat-react-native',
+  'stream-chat-react-native-core',
+]);
+const deps = (root, rel) => {
+  const p = require(path.join(root, rel, 'package.json'));
+  return { ...(p.dependencies || {}) };
+};
+const [a, b] = process.argv.slice(2).map((p) => path.resolve(p));
+let bad = 0;
+for (const rel of ['examples/SampleApp', 'package/native-package']) {
+  const da = deps(a, rel);
+  const db = deps(b, rel);
+  for (const k of new Set([...Object.keys(da), ...Object.keys(db)])) {
+    if (JS_ONLY.has(k) || da[k] === db[k]) continue;
+    console.log(`NATIVE-PARITY ${rel}: ${k} ${da[k]} vs ${db[k]}`);
+    bad += 1;
+  }
+}
+if (bad) {
+  console.log(
+    'Differences above: if any is a native module, build each side with its own native project instead.',
+  );
+  process.exit(1);
+}
+console.log('native parity ok');
diff --git a/perf/gauntlet/devmark.sh b/perf/gauntlet/devmark.sh
new file mode 100644
index 0000000000..73f1bd9094
--- /dev/null
+++ b/perf/gauntlet/devmark.sh
@@ -0,0 +1,22 @@
+#!/system/bin/sh
+# devmark.sh <S|E> <label> [package] — on-device: logs a PERFMARK line with the device clock (ms) and the app's
+# per-thread CPU ticks (utime+stime, 10ms) for main, JS, native-modules and RenderThread, plus the process total.
+MARK_KIND=$1; MARK_LABEL=$2
+P=${3:-io.getstream.reactnative.sampleapp}
+pid=$(pidof $P)
+out=""
+if [ -n "$pid" ]; then
+  set -- $(cat /proc/$pid/stat)
+  out=" proc:$pid:$(( ${14} + ${15} ))"
+  for t in /proc/$pid/task/*; do
+    tid=${t##*/}
+    c=$(cat $t/comm 2>/dev/null)
+    case "$c" in
+      mqt_v_js|mqt_v_native|RenderThread) ;;
+      *) [ "$tid" = "$pid" ] || continue; c=main ;;
+    esac
+    set -- $(cat $t/stat)
+    out="$out $c:$tid:$(( ${14} + ${15} ))"
+  done
+fi
+log -t PERFMARK "$MARK_KIND $MARK_LABEL $(date +%s%3N)$out"
diff --git a/perf/gauntlet/diag.py b/perf/gauntlet/diag.py
new file mode 100644
index 0000000000..381479c0e6
--- /dev/null
+++ b/perf/gauntlet/diag.py
@@ -0,0 +1,90 @@
+#!/usr/bin/env python3
+"""diag.py <mode> ... — reads logcat.txt of sessions run with DIAGNOSTIC builds (build.sh <label> <root> diag).
+Never quote timings from diag builds; these modes are deterministic counts.
+
+  hooks <base-session-dir> <head-session-dir>   hooks per mount per component, base vs head, sorted by delta,
+                                                plus hooks per mounted message row (biggest row-mount commit)
+  ctx <session-dir> <window-label>              context providers whose value changed identity in the window,
+                                                with the keys that changed (who invalidates the tree?)
+  areequal <session-dir> <window-label>         which Message areEqual check failed, per window; an EMPTY
+                                                result while rows re-render means they re-render from a
+                                                context/store they read themselves, not from props
+"""
+import json
+import os
+import re
+import sys
+
+LINE = re.compile(r'\s(\d+)\s+\d+\s+\w\s+ReactNativeJS: BENCH (\w) (\[.*\])$')
+MARK = re.compile(r'PERFMARK: ([SE]) (\S+) (\d+)')
+
+
+def read(d):
+    names, rows, extra, marks = {}, [], [], {}
+    for line in open(os.path.join(d, 'logcat.txt'), errors='replace'):
+        m = MARK.search(line)
+        if m:
+            marks.setdefault(m.group(2), {})[m.group(1)] = int(m.group(3))
+            continue
+        m = LINE.search(line)
+        if not m:
+            continue
+        pid, kind, data = m.group(1), m.group(2), json.loads(m.group(3))
+        if kind == 'N':
+            for i, n in data:
+                names[(pid, i)] = n
+        elif kind == 'D':
+            rows.append((pid, data[1]))
+        elif kind in ('X', 'A'):
+            extra.append((kind, data[0], data[1]))
+    return names, rows, extra, marks
+
+
+def hooks(d):
+    names, rows, _, _ = read(d)
+    hk, mt = {}, {}
+    best = None
+    for pid, r in rows:
+        msg = sum(x[4] for x in r if names.get((pid, x[0])) == 'Message')
+        if msg and (best is None or msg > best[0]):
+            best = (msg, pid, r)
+        for x in r:
+            if len(x) > 5 and x[4]:
+                n = names.get((pid, x[0]), '?')
+                hk[n] = hk.get(n, 0) + x[5]
+                mt[n] = mt.get(n, 0) + x[4]
+    per_row = None
+    if best:
+        msg, pid, r = best
+        skip = ('Channel', 'Chat', 'MessageList', 'MessageComposer', 'MessageInput', 'Thread')
+        total = sum(x[5] for x in r if len(x) > 5 and not names.get((pid, x[0]), '').startswith(skip))
+        per_row = (total / msg, msg)
+    return {n: hk[n] / mt[n] for n in hk if mt[n]}, per_row
+
+
+def in_window(extra, kind, marks, label):
+    t = marks[label]
+    agg = {}
+    for k, ts, d in extra:
+        if k == kind and t['S'] - 200 <= ts <= t['E'] + 1200:  # flushed once a second
+            for key, v in d.items():
+                agg[key] = agg.get(key, 0) + v
+    return sorted(agg.items(), key=lambda kv: -kv[1])
+
+
+if __name__ == '__main__':
+    mode = sys.argv[1]
+    if mode == 'hooks':
+        (ha, ra), (hb, rb) = hooks(sys.argv[2]), hooks(sys.argv[3])
+        if not ha or not hb:
+            sys.exit('no hook data: was this a diag build? (rows carry a 6th field only with GAUNTLET_DIAG)')
+        print(f'hooks per mounted message row: base {ra[0]:.1f} (n={ra[1]}), head {rb[0]:.1f} (n={rb[1]})')
+        diff = sorted(set(ha) | set(hb), key=lambda n: -abs(hb.get(n, 0) - ha.get(n, 0)))
+        print(f'{"component (hooks per mount)":<55} {"base":>6} {"head":>6} {"delta":>6}')
+        for n in diff[:40]:
+            if ha.get(n, 0) != hb.get(n, 0):
+                print(f'{n[:55]:<55} {ha.get(n, 0):6.1f} {hb.get(n, 0):6.1f} {hb.get(n, 0) - ha.get(n, 0):+6.1f}')
+    else:
+        _, _, extra, marks = read(sys.argv[2])
+        for k, v in in_window(extra, {'ctx': 'X', 'areequal': 'A'}[mode], marks, sys.argv[3]):
+            print(v, k)
diff --git a/perf/gauntlet/export-ref.sh b/perf/gauntlet/export-ref.sh
new file mode 100755
index 0000000000..6299133761
--- /dev/null
+++ b/perf/gauntlet/export-ref.sh
@@ -0,0 +1,15 @@
+#!/bin/bash
+# export-ref.sh <git-ref> <label> — exports <git-ref> (e.g. origin/develop) into out/trees/<label> with
+# `git archive` (read-only: no worktree, no checkout, no git writes) and installs its dependencies.
+# ~1-3 min. Records the exact sha in out/trees/<label>.sha.
+set -euo pipefail
+G=$(cd "$(dirname "$0")" && pwd)
+REPO=$(cd "$G/../.." && pwd)
+REF=${1:?usage: export-ref.sh <git-ref> <label>}; LABEL=${2:?usage: export-ref.sh <git-ref> <label>}
+DEST="$G/out/trees/$LABEL"
+[ -e "$DEST" ] && { echo "$DEST exists; reuse it or pick another label"; exit 1; }
+mkdir -p "$DEST"
+git -C "$REPO" archive "$REF" | tar -x -C "$DEST"
+git -C "$REPO" rev-parse "$REF" > "$G/out/trees/$LABEL.sha"
+(cd "$DEST" && HUSKY=0 yarn install > "$G/out/trees/$LABEL-install.log" 2>&1)
+echo "exported $REF ($(cat "$G/out/trees/$LABEL.sha")) to $DEST"
diff --git a/perf/gauntlet/find.py b/perf/gauntlet/find.py
new file mode 100644
index 0000000000..32044a7905
--- /dev/null
+++ b/perf/gauntlet/find.py
@@ -0,0 +1,15 @@
+#!/usr/bin/env python3
+"""find.py <serial> <regex> [ymin] [ymax] — prints "x y" of the first node whose text or content-desc
+fully matches and whose center lies within [ymin, ymax] (default: below the header, above the composer)."""
+import os, re, sys
+sys.path.insert(0, os.path.dirname(__file__))
+from ui import dump_nodes, center
+serial, pat = sys.argv[1], re.compile(sys.argv[2])
+ymin = int(sys.argv[3]) if len(sys.argv) > 3 else 450
+ymax = int(sys.argv[4]) if len(sys.argv) > 4 else 2050
+for n in dump_nodes(serial):
+    if pat.fullmatch(n['text']) or pat.fullmatch(n['desc']):
+        x, y = center(n)
+        if ymin <= y <= ymax:
+            print(x, y); sys.exit(0)
+sys.exit(1)
diff --git a/perf/gauntlet/gauntlet-transformer.js b/perf/gauntlet/gauntlet-transformer.js
new file mode 100644
index 0000000000..3497553011
--- /dev/null
+++ b/perf/gauntlet/gauntlet-transformer.js
@@ -0,0 +1,59 @@
+// Wraps the SampleApp's babel transformer (source patches at bundle time; nothing is edited on disk).
+// Always: the SampleApp channel list query asks for 100 messages per channel instead of 25, so a channel
+// opened from the list renders 100 loaded messages on both sides without a network round trip. The
+// bundle fails if the pattern is gone (update MESSAGE_LIMIT_FROM when the SampleApp changes).
+// With GAUNTLET_DIAG=1 only (diagnostic builds, never the measured ones): Message's areEqual reports which
+// check failed to globalThis.__benchAreEqual.
+const upstream = require(process.env.GAUNTLET_UPSTREAM_TRANSFORMER);
+const MESSAGE_LIMIT_FROM = 'message_limit: 25,';
+
+const diagAreEqual = (src) => {
+  const start = src.indexOf('const areEqual = (');
+  const end = src.indexOf('const MemoizedMessage', start);
+  if (start < 0 || end < 0) throw new Error('bench: areEqual not found');
+  const body = src
+    .slice(start, end)
+    .replace(
+      /if \(!(\w+)\) \{\s*return false;\s*\}/g,
+      "if (!$1) { globalThis.__benchAreEqual && globalThis.__benchAreEqual('$1'); return false; }",
+    )
+    .replace(
+      /if \((\w+)\) \{\s*return false;\s*\}/g,
+      "if ($1) { globalThis.__benchAreEqual && globalThis.__benchAreEqual('$1'); return false; }",
+    )
+    .replace(
+      /return true;\s*\};\s*$/,
+      "globalThis.__benchAreEqual && globalThis.__benchAreEqual('EQUAL'); return true;\n};\n",
+    );
+  return src.slice(0, start) + body + src.slice(end);
+};
+
+module.exports = {
+  ...upstream,
+  // Diag and measured builds must never share Metro's transform cache.
+  getCacheKey: () =>
+    [
+      upstream.getCacheKey ? upstream.getCacheKey() : '',
+      'gauntlet-v1',
+      process.env.GAUNTLET_DIAG ? 'diag' : 'measured',
+    ].join(':'),
+  transform(args) {
+    if (args.filename.endsWith('src/screens/ChannelListScreen.tsx')) {
+      const src = args.src.replace(MESSAGE_LIMIT_FROM, 'message_limit: 100,');
+      if (src === args.src) throw new Error('bench: message_limit patch did not apply');
+      return upstream.transform({ ...args, src });
+    }
+    if (process.env.GAUNTLET_DIAG && /(^|\/)runtime\/probe\.js$/.test(args.filename)) {
+      const src = args.src.replace('var DIAG = false;', 'var DIAG = true;');
+      if (src === args.src) throw new Error('bench: DIAG flag patch did not apply');
+      return upstream.transform({ ...args, src });
+    }
+    if (
+      process.env.GAUNTLET_DIAG &&
+      /package\/src\/components\/Message\/Message\.tsx$/.test(args.filename)
+    ) {
+      return upstream.transform({ ...args, src: diagAreEqual(args.src) });
+    }
+    return upstream.transform(args);
+  },
+};
diff --git a/perf/gauntlet/gauntlet.init.gradle b/perf/gauntlet/gauntlet.init.gradle
new file mode 100644
index 0000000000..9910a7c1cb
--- /dev/null
+++ b/perf/gauntlet/gauntlet.init.gradle
@@ -0,0 +1,15 @@
+// Points the React Native gradle plugin's JS bundling at a chosen SampleApp tree (GAUNTLET_APP) through the
+// gauntlet Metro config, so ONE native project produces the release APK for either side of a comparison.
+// Only valid when both sides have identical native dependencies (build.sh checks this).
+allprojects { p ->
+  p.afterEvaluate {
+    def r = p.extensions.findByName('react')
+    if (r != null) {
+      def app = System.getenv('GAUNTLET_APP')
+      r.bundleConfig.set(new File(System.getenv('GAUNTLET_DIR') + '/metro.gauntlet.config.js'))
+      r.root.set(new File(app))
+      r.entryFile.set(new File(app + '/index.js'))
+      r.cliFile.set(new File(app + '/node_modules/react-native/cli.js'))
+    }
+  }
+}
diff --git a/perf/gauntlet/lib.cjs b/perf/gauntlet/lib.cjs
new file mode 100644
index 0000000000..3eb6123d45
--- /dev/null
+++ b/perf/gauntlet/lib.cjs
@@ -0,0 +1,23 @@
+// Backend helpers for seed.cjs / actor.cjs / tokens.cjs. Users connect to the SampleApp's public demo
+// environment with tokens from its token generator (examples/SampleApp/src/utils/tokenProvider.ts).
+// The node client is this checkout's stream-chat (written against the v10 node API; LLC_DIST overrides).
+const path = require('path');
+const { StreamChat } = require(
+  process.env.LLC_DIST ||
+    path.join(__dirname, '../../package/node_modules/stream-chat/dist/cjs/index.node.js'),
+);
+const API_KEY = 'yjrt5yxw77ev';
+const TOKEN_URL =
+  'https://pronto.getstream.io/api/auth/create-token?environment=react-native-chat-sample';
+const tokenFor = async (id) => {
+  const r = await fetch(`${TOKEN_URL}&user_id=${encodeURIComponent(id)}`);
+  const { token } = await r.json();
+  if (!token) throw new Error(`no token for ${id}`);
+  return token;
+};
+const connect = async (id) => {
+  const client = new StreamChat(API_KEY, { allowServerSideConnect: true });
+  await client.connectUser({ id }, await tokenFor(id));
+  return client;
+};
+module.exports = { connect, tokenFor };
diff --git a/perf/gauntlet/metro.gauntlet.config.js b/perf/gauntlet/metro.gauntlet.config.js
new file mode 100644
index 0000000000..2ef90c1a81
--- /dev/null
+++ b/perf/gauntlet/metro.gauntlet.config.js
@@ -0,0 +1,74 @@
+// Perf-gauntlet Metro config. Wraps a SampleApp's own config (GAUNTLET_APP = that SampleApp's directory,
+// in this repo or in an exported baseline tree) and changes only what the measurement needs:
+// - probe.js / probe-llc.js load before anything else (in place of index.js's first import)
+// - the bench users' static tokens (runtime/generated/ChatUsers.gauntlet.ts, gitignored) replace src/ChatUsers
+// - the channel list loads 100 messages per channel (gauntlet-transformer.js)
+// - function names survive minification, so per-component attribution is exact
+// - React's PROFILING Fabric renderer replaces the prod one (fiber timings in a release bundle)
+// Nothing in the SampleApp or the SDK is edited on disk.
+const path = require('path');
+const APP = process.env.GAUNTLET_APP;
+if (!APP) throw new Error('GAUNTLET_APP is not set');
+const base = require(path.join(APP, 'metro.config.js'));
+// Only runtime/ is watched: out/ can hold whole exported baseline trees (with node_modules).
+const RUNTIME = path.join(__dirname, 'runtime');
+const SHIM = path.join(RUNTIME, 'entry-shim.js');
+const TOKENS = path.join(RUNTIME, 'generated', 'ChatUsers.gauntlet.ts');
+process.env.GAUNTLET_UPSTREAM_TRANSFORMER = base.transformer.babelTransformerPath;
+module.exports = {
+  ...base,
+  projectRoot: APP,
+  transformer: {
+    ...base.transformer,
+    babelTransformerPath: path.join(__dirname, 'gauntlet-transformer.js'),
+    // Mangling renames components, so names collide or disappear. Same on both sides; names only.
+    minifierConfig: {
+      ...base.transformer.minifierConfig,
+      keep_fnames: true,
+      keep_classnames: true,
+      mangle: {
+        ...(base.transformer.minifierConfig || {}).mangle,
+        keep_fnames: true,
+        keep_classnames: true,
+      },
+      compress: {
+        ...(base.transformer.minifierConfig || {}).compress,
+        keep_fnames: true,
+        keep_classnames: true,
+      },
+    },
+  },
+  watchFolders: [...(base.watchFolders || []), RUNTIME],
+  resolver: {
+    ...base.resolver,
+    resolveRequest: (context, moduleName, platform) => {
+      // index.js's first import: the probe must be installed before anything can load the renderer.
+      if (
+        moduleName === './src/utils/bootstrapBackgroundMessageHandler' &&
+        context.originModulePath === path.join(APP, 'index.js')
+      ) {
+        return { filePath: SHIM, type: 'sourceFile' };
+      }
+      if (moduleName === 'gauntlet-real-entry') {
+        return {
+          filePath: path.join(APP, 'src/utils/bootstrapBackgroundMessageHandler.ts'),
+          type: 'sourceFile',
+        };
+      }
+      if (
+        /(^|\/)ChatUsers$/.test(moduleName) &&
+        context.originModulePath.startsWith(path.join(APP, 'src'))
+      ) {
+        return { filePath: TOKENS, type: 'sourceFile' };
+      }
+      if (/implementations\/ReactFabric-prod$/.test(moduleName)) {
+        return context.resolveRequest(
+          context,
+          moduleName.replace(/-prod$/, '-profiling'),
+          platform,
+        );
+      }
+      return context.resolveRequest(context, moduleName, platform);
+    },
+  },
+};
diff --git a/perf/gauntlet/preflight.sh b/perf/gauntlet/preflight.sh
new file mode 100755
index 0000000000..e3c29bd599
--- /dev/null
+++ b/perf/gauntlet/preflight.sh
@@ -0,0 +1,45 @@
+#!/bin/bash
+# preflight.sh — run before every session (run.sh does). Waits for the HOST to calm down and refuses to
+# measure on an unhealthy device. Exit 1 = do not measure (fix the cause first).
+#  - host 1-min load average must drop below GAUNTLET_MAX_LOAD (default 6): builds, yarn install, Metro and
+#    hermesc keep it at 15-30 for minutes after they finish; waits up to 15 min.
+#  - emulator process must run at nice 0 (started from a background task it gets nice 5 -> E-cores, 7-8x noise).
+#  - device speed: a fixed shell CPU loop (median of 3) must stay within 1.4x of the first measurement of this
+#    gauntlet (stored in out/device-calibration.txt; a fresh Pixel 7 AVD takes ~120 ms). Catches swap thrash
+#    after a day of reinstalls, host load and slow-core placement in one number. Fix: cold-boot the emulator.
+#    (Swap use itself is NOT a signal: a fresh boot already swaps ~600 MB to zram.)
+#  - host memory: >= 20% free and < 512 MB of the emulator's RAM compressed (see below).
+S=${GAUNTLET_SERIAL:-$(adb devices | awk 'NR>1 && $2=="device" {print $1; exit}')}
+MAXLOAD=${GAUNTLET_MAX_LOAD:-6}
+G=$(cd "$(dirname "$0")" && pwd)
+[ -n "$S" ] || { echo "preflight: no adb device"; exit 1; }
+for i in $(seq 1 90); do
+  load=$(sysctl -n vm.loadavg 2>/dev/null | awk '{print $2}'); [ -n "$load" ] || load=$(awk '{print $1}' /proc/loadavg)
+  awk -v l="$load" -v m="$MAXLOAD" 'BEGIN { exit !(l < m) }' && break
+  [ "$i" = 1 ] && echo "preflight: host load $load >= $MAXLOAD, waiting"
+  sleep 10
+done
+awk -v l="$load" -v m="$MAXLOAD" 'BEGIN { exit !(l < m) }' || { echo "preflight: host load still $load after 15 min"; exit 1; }
+q=$(pgrep -f qemu-system | head -1)
+if [ -n "$q" ]; then
+  nice=$(ps -o nice= -p "$q" | tr -d ' ')
+  [ "$nice" = 0 ] || { echo "preflight: emulator runs at nice $nice (start it from the user's Terminal panel)"; exit 1; }
+fi
+# Host memory: compressed or swapped emulator RAM makes memory-heavy work (React) several x slower while
+# CPU loops look normal. Require host free memory >= 20% and < 512 MB of the emulator compressed.
+free_pct=$(memory_pressure 2>/dev/null | awk -F': ' '/free percentage/ {gsub("%","",$2); print $2}')
+if [ -n "$q" ] && command -v top >/dev/null; then
+  cmprs=$(top -l 1 -pid "$q" -stats cmprs 2>/dev/null | tail -1 | tr -d ' ')
+  cmprs_mb=$(echo "$cmprs" | awk '/G$/ {print int($0*1024); next} /M$/ {print int($0); next} /K$/ {print 0; next} {print int($0/1048576)}')
+fi
+[ -z "$free_pct" ] || [ "$free_pct" -ge 20 ] || { echo "preflight: host memory free ${free_pct}% < 20% (close apps, stop gradle daemons)"; exit 1; }
+[ -z "$cmprs_mb" ] || [ "$cmprs_mb" -lt 512 ] || { echo "preflight: ${cmprs_mb}MB of the emulator's RAM is compressed (host memory pressure): free memory, cold-boot the emulator"; exit 1; }
+loop_ms() { adb -s "$S" shell 's=$(date +%s%N); i=0; while [ $i -lt 100000 ]; do i=$((i+1)); done; e=$(date +%s%N); echo $(( (e-s)/1000000 ))' | tr -d '\r'; }
+speed=$( (loop_ms; loop_ms; loop_ms) | sort -n | sed -n 2p)
+CAL="$G/out/device-calibration.txt"
+mkdir -p "$G/out"; [ -s "$CAL" ] || echo "$speed" > "$CAL"
+ref=$(cat "$CAL")
+avail=$(adb -s "$S" shell cat /proc/meminfo | awk '/MemAvailable/ {print int($2/1024)}')
+awk -v s="$speed" -v r="$ref" 'BEGIN { exit !(s <= r * 1.4) }' || {
+  echo "preflight: device loop ${speed}ms vs calibration ${ref}ms (>1.4x; MemAvailable ${avail}MB): cold-boot the emulator"; exit 1; }
+echo "preflight ok: host load $load, host free ${free_pct:-?}%, emulator nice ${nice:-n/a} compressed ${cmprs_mb:-?}MB, device loop ${speed}ms (cal ${ref}ms), MemAvailable ${avail}MB"
diff --git a/perf/gauntlet/report.py b/perf/gauntlet/report.py
new file mode 100644
index 0000000000..09348a4856
--- /dev/null
+++ b/perf/gauntlet/report.py
@@ -0,0 +1,254 @@
+#!/usr/bin/env python3
+"""report.py <mode> <dir>... — base vs head tables from analyzed sessions (run analyze.py on each first;
+session.sh does it at the end). A <dir> is a session dir (has meta.txt) or a run dir (out/<name>) whose
+session subdirs are all used.
+
+Modes:
+  main    per-scenario JS work (render + commit + effects), medians with min-max, Mann-Whitney p, verdict,
+          plus render, commits, JS/UI-thread CPU and the speed index (runtime speed during the windows)
+  lists   FlatList vs FlashList per side, for every scenario run with both
+  comps   major-component tables (inclusive ms, renders r / mounts m) for mount and re-render scenarios
+  ci      SESSION-level bootstrap 95% CIs for chosen scenarios (default: open_channel_flat x_open_flat
+          scroll_flat x_scroll_flat), on raw render, render / speed index and JS-thread CPU. Use this before
+          calling a few-% difference real: per-run p-values overstate certainty (runs within a session share
+          the emulator's state)
+  diff <scenario>   per-component median self time / renders / mounts base vs head, sorted by delta
+
+Verdicts in `main`: "faster"/"SLOWER" only when p < 0.05 AND |delta| >= 5% AND >= 1 ms; otherwise "same".
+FlatList event windows where the list mounted a new batch of cells (> 5 Message mounts) are split out as
+"<scenario>~batch": that is VirtualizedList windowing landing in the window, not the event's own cost.
+"""
+import glob
+import json
+import math
+import os
+import random
+import statistics
+import sys
+from collections import defaultdict
+
+EVENT_PREFIXES = ('ch_', 'composer_', 'thread_reply_event', 'list_')
+SIDES = ('base', 'head')
+
+
+def sessions(args):
+    out = []
+    for a in args:
+        if os.path.exists(os.path.join(a, 'meta.txt')):
+            out.append(a)
+        else:
+            out += sorted(d for d in glob.glob(os.path.join(a, '*')) if os.path.exists(os.path.join(d, 'windows.json')))
+    return out
+
+
+def meta(d):
+    m = {}
+    for tok in open(os.path.join(d, 'meta.txt')).read().split():
+        if '=' in tok:
+            k, v = tok.split('=', 1)
+            m[k] = v
+    return m
+
+
+def is_batch(w):
+    return w['comps'].get('Message', [0, 0, 0, 0])[3] > 5
+
+
+def load(dirs, keep_batches=False):
+    runs = {s: defaultdict(list) for s in SIDES}
+    per_session = {s: [] for s in SIDES}
+    for d in dirs:
+        side = meta(d)['side']
+        ws = json.load(open(os.path.join(d, 'windows.json')))
+        per_session[side].append(ws)
+        for w in ws:
+            if not keep_batches and w['scenario'].startswith(EVENT_PREFIXES) and is_batch(w):
+                runs[side][w['scenario'] + '~batch'].append(w)
+            else:
+                runs[side][w['scenario']].append(w)
+    return runs, per_session
+
+
+def mannwhitney(a, b):
+    if len(a) < 3 or len(b) < 3:
+        return None
+    allv = sorted([(v, 0) for v in a] + [(v, 1) for v in b])
+    ranks = [0.0] * len(allv)
+    i = 0
+    ties = 0.0
+    while i < len(allv):
+        j = i
+        while j + 1 < len(allv) and allv[j + 1][0] == allv[i][0]:
+            j += 1
+        for k in range(i, j + 1):
+            ranks[k] = (i + j) / 2 + 1
+        t = j - i + 1
+        ties += t ** 3 - t
+        i = j + 1
+    n1, n2 = len(a), len(b)
+    u1 = sum(r for r, (_, g) in zip(ranks, allv) if g == 0) - n1 * (n1 + 1) / 2
+    n = n1 + n2
+    sigma = math.sqrt(n1 * n2 / 12 * ((n + 1) - ties / (n * (n - 1))))
+    if sigma == 0:
+        return 1.0
+    z = (abs(u1 - n1 * n2 / 2) - 0.5) / sigma
+    return max(0.0, min(1.0, math.erfc(z / math.sqrt(2))))
+
+
+def med(xs):
+    xs = [x for x in xs if x is not None]
+    return statistics.median(xs) if xs else None
+
+
+def fmt(x, nd=1):
+    return '-' if x is None else f'{x:.{nd}f}'
+
+
+def cell(xs, m):
+    return '-' if m is None else f'{m:.1f} ({min(xs):.0f}-{max(xs):.0f})'
+
+
+def verdict(a, b, p):
+    if a is None or b is None:
+        return ''
+    d = b - a
+    rel = d / a * 100 if a else (0 if d == 0 else math.inf)
+    if p is None or p >= 0.05 or abs(d) < 1 or abs(rel) < 5:
+        return 'same'
+    return 'faster' if d < 0 else 'SLOWER'
+
+
+def vals(runs, side, scen, key):
+    return [w.get(key) for w in runs[side].get(scen, []) if w.get(key) is not None]
+
+
+def mode_main(dirs):
+    runs, _ = load(dirs)
+    print('| scenario | n base/head | JS work base ms | JS work head ms | delta | p | verdict | render base/head | commits | JS CPU base/head | UI CPU base/head | speed idx base/head (arith, mem) |')
+    print('|---|---|---|---|---|---|---|---|---|---|---|---|')
+    for s in sorted(set(runs['base']) | set(runs['head'])):
+        a, b = vals(runs, 'base', s, 'js_react_ms'), vals(runs, 'head', s, 'js_react_ms')
+        ma, mb = med(a), med(b)
+        p = mannwhitney(a, b)
+        d = (mb - ma) if ma is not None and mb is not None else None
+        rel = f' ({d / ma * 100:+.0f}%)' if d is not None and ma else ''
+        g = lambda k: f"{fmt(med(vals(runs, 'base', s, k)), 0)}/{fmt(med(vals(runs, 'head', s, k)), 0)}"
+        sp = (f"{fmt(med(vals(runs, 'base', s, 'speed_ms')), 2)}/{fmt(med(vals(runs, 'head', s, 'speed_ms')), 2)} "
+              f"mem {fmt(med(vals(runs, 'base', s, 'mem_speed_ms')), 2)}/{fmt(med(vals(runs, 'head', s, 'mem_speed_ms')), 2)}")
+        print(f'| {s} | {len(a)}/{len(b)} | {cell(a, ma)} | {cell(b, mb)} | {fmt(d)}{rel} | {fmt(p, 3)} | {verdict(ma, mb, p)} | '
+              f"{g('render_ms')} | {g('commits')} | {g('cpu_js_ms')} | {g('cpu_main_ms')} | {sp} |")
+
+
+def mode_lists(dirs):
+    runs, _ = load(dirs)
+    print('| scenario | side | FlatList ms | FlashList ms | FlashList vs FlatList | p |')
+    print('|---|---|---|---|---|---|')
+    bases = sorted({s[:-5] for side in SIDES for s in runs[side] if s.endswith('_flat')})
+    for base in bases:
+        for side in SIDES:
+            a, b = vals(runs, side, base + '_flat', 'js_react_ms'), vals(runs, side, base + '_flash', 'js_react_ms')
+            if not a or not b:
+                continue
+            ma, mb = med(a), med(b)
+            rel = (mb - ma) / ma * 100 if ma else 0
+            print(f'| {base} | {side} | {cell(a, ma)} | {cell(b, mb)} | {mb - ma:+.1f} ({rel:+.0f}%) | {fmt(mannwhitney(a, b), 3)} |')
+
+
+MAJOR = [
+    ('#root', 'Whole app (all React work)'), ('ChannelList', 'ChannelList'), ('ChannelPreview', 'ChannelPreview (rows)'),
+    ('ChannelHeader', 'ChannelHeader (SampleApp)'), ('Channel', 'Channel'), ('MessageList', 'MessageList (FlatList)'),
+    ('MessageFlashList', 'MessageFlashList'), ('Message', 'Message (rows)'),
+    ('MessageTextContainerWithContext', '  text + markdown'), ('ReactionListTop', '  reaction list'),
+    ('GalleryWithContext', '  image gallery'), ('MessageFooterWithContext', '  footer'),
+    ('MessageComposer{messageComposer}', 'MessageComposer'), ('AutoCompleteInputWithContext', '  input'),
+    ('Thread', 'Thread'), ('MessageOverlayHostLayer', 'Message overlay host'),
+]
+COMP_GROUPS = [
+    (['cold_start', 'open_channel_flat', 'open_channel_flash'], 'Mount: cold start (channel list) and opening a 100-message channel'),
+    (['thread_open_flat', 'thread_open_flash', 'menu_open'], 'Mount: thread and context menu'),
+    (['list_msg_top', 'list_msg_reorder', 'list_presence_on'], 'Re-render: channel list events'),
+    (['ch_msg_new_flat', 'ch_reaction_flat', 'ch_edit_flat'], 'Re-render: open channel (FlatList)'),
+    (['ch_msg_new_flash', 'ch_reaction_flash', 'ch_edit_flash'], 'Re-render: open channel (FlashList)'),
+    (['ch_typing_flat', 'composer_type_flat', 'ch_own_send_flat'], 'Re-render: typing, composer, own send (FlatList)'),
+]
+
+
+def mode_comps(dirs):
+    runs, _ = load(dirs)
+    for scenarios, title in COMP_GROUPS:
+        print(f'\n### {title}\n')
+        print('| component | ' + ' | '.join(f'{s} base | {s} head' for s in scenarios) + ' |')
+        print('|---|' + '---|---|' * len(scenarios))
+        for name, label in MAJOR:
+            cells, seen = [], False
+            for s in scenarios:
+                for side in SIDES:
+                    ws = runs[side].get(s, [])
+                    if not ws:
+                        cells.append('-')
+                        continue
+                    g = lambda k: statistics.median([w['comps'].get(name, [0, 0, 0, 0])[k] for w in ws])
+                    incl, rend, mnt = g(0), g(2), g(3)
+                    seen = seen or bool(incl or rend or mnt)
+                    cells.append(f'{incl:.1f} ({rend:.0f}r/{mnt:.0f}m)')
+            if seen:
+                print(f'| {label} | ' + ' | '.join(cells) + ' |')
+
+
+def mode_ci(dirs, scen_groups):
+    _, per = load(dirs)
+    random.seed(1)
+
+    def boot(a, b):
+        base = statistics.median(b) / statistics.median(a) - 1
+        bs = []
+        for _ in range(20000):
+            ra = [random.choice(a) for _ in a]
+            rb = [random.choice(b) for _ in b]
+            bs.append(statistics.median(rb) / statistics.median(ra) - 1)
+        bs.sort()
+        return base, bs[int(0.025 * len(bs))], bs[int(0.975 * len(bs))]
+
+    for scens in scen_groups:
+        sess = {s: [] for s in SIDES}
+        for side in SIDES:
+            for ws in per[side]:
+                ws = [w for w in ws if w['scenario'] in scens and w.get('speed_ms')]
+                if ws:
+                    sess[side].append((statistics.median([w['render_ms'] for w in ws]),
+                                       statistics.median([w['render_ms'] / w['speed_ms'] for w in ws]),
+                                       statistics.median([w['cpu_js_ms'] for w in ws])))
+        if len(sess['base']) < 3 or len(sess['head']) < 3:
+            print(f'{"/".join(scens)}: need >= 3 sessions per side (have {len(sess["base"])}/{len(sess["head"])})')
+            continue
+        print(f'{"/".join(scens)}  sessions base/head {len(sess["base"])}/{len(sess["head"])}')
+        for i, lab in ((0, 'raw render'), (1, 'render / speed index'), (2, 'JS-thread CPU')):
+            e, lo, hi = boot([x[i] for x in sess['base']], [x[i] for x in sess['head']])
+            print(f'   {lab:<22} {e * 100:+5.1f}%   95% CI [{lo * 100:+5.1f}%, {hi * 100:+5.1f}%]')
+
+
+def mode_diff(dirs, scen, top=30):
+    runs, _ = load(dirs, keep_batches=True)
+    ws = {s: runs[s].get(scen, []) for s in SIDES}
+    names = set()
+    for s in SIDES:
+        for w in ws[s]:
+            names |= set(w['comps'])
+    m = lambda side, n, k: statistics.median([w['comps'].get(n, [0, 0, 0, 0])[k] for w in ws[side]]) if ws[side] else 0
+    rows = sorted(names, key=lambda n: -abs(m('head', n, 1) - m('base', n, 1)))
+    print(f"{scen}: n={len(ws['base'])}/{len(ws['head'])}")
+    print(f'{"component":<55} {"self base":>9} {"self head":>9} {"delta":>8}   renders b/h   mounts b/h')
+    for n in rows[:top]:
+        print(f'{n[:55]:<55} {m("base", n, 1):9.2f} {m("head", n, 1):9.2f} {m("head", n, 1) - m("base", n, 1):+8.2f}   '
+              f'{m("base", n, 2):5.0f}/{m("head", n, 2):<5.0f}  {m("base", n, 3):5.0f}/{m("head", n, 3):<5.0f}')
+
+
+if __name__ == '__main__':
+    mode, rest = sys.argv[1], sys.argv[2:]
+    if mode == 'diff':
+        mode_diff(sessions(rest[1:]), rest[0])
+    elif mode == 'ci':
+        mode_ci(sessions(rest), [('open_channel_flat', 'x_open_flat'), ('scroll_flat', 'x_scroll_flat'),
+                                 ('open_channel_flash',), ('scroll_flash',), ('cold_start',)])
+    else:
+        {'main': mode_main, 'lists': mode_lists, 'comps': mode_comps}[mode](sessions(rest))
diff --git a/perf/gauntlet/run.sh b/perf/gauntlet/run.sh
new file mode 100755
index 0000000000..62f403176c
--- /dev/null
+++ b/perf/gauntlet/run.sh
@@ -0,0 +1,25 @@
+#!/bin/bash
+# run.sh <name> "<phases>" <base-apk> <head-apk> <user>... — runs one session per user, sides in ABBA order
+# (base, head, head, base, base, head, ...) so slow drift of the emulator cancels out. Output:
+# out/<name>/<NN>-<role>-<user>/ per session, progress in out/<name>/progress.log.
+# A user should be used once per full session (sessions mutate its channels). For extra-sample runs
+# (phases "setup warm rowcost") pass each user twice so it runs on both sides: u1 u1 u2 u2.
+# The session script is frozen into out/<name>/frozen/ first: never edit a script bash is executing.
+set -u
+G=$(cd "$(dirname "$0")" && pwd)
+NAME=$1; PH=$2; BASE=$3; HEAD=$4; shift 4
+RUN="$G/out/$NAME"; mkdir -p "$RUN/frozen"
+cp "$G/session.sh" "$RUN/frozen/session.sh"
+echo "[$(date '+%F %T')] start: phases='$PH' base=$BASE head=$HEAD users=$* RUNS=${RUNS:-5}" >> "$RUN/progress.log"
+n=0
+for user in "$@"; do
+  case $((n % 4)) in 0|3) role=base; apk=$BASE ;; *) role=head; apk=$HEAD ;; esac
+  n=$((n + 1)); out=$(printf '%s/%02d-%s-%s' "$RUN" "$n" "$role" "$user")
+  if ! pf=$(bash "$G/preflight.sh" 2>&1); then
+    echo "[$(date '+%F %T')] STOPPED before $(basename "$out"): $pf" >> "$RUN/progress.log"; exit 1
+  fi
+  echo "[$(date '+%F %T')] start $out ($pf)" >> "$RUN/progress.log"
+  GAUNTLET_DIR=$G bash "$RUN/frozen/session.sh" "$role" "$apk" "$user" "$out" $PH > "$out.out" 2>&1
+  echo "[$(date '+%F %T')] end $(basename "$out") exit $? warns=$(grep -c WARN "$out/session.log" 2>/dev/null)" >> "$RUN/progress.log"
+done
+echo "[$(date '+%F %T')] done" >> "$RUN/progress.log"
diff --git a/perf/gauntlet/runtime/entry-shim.js b/perf/gauntlet/runtime/entry-shim.js
new file mode 100644
index 0000000000..5f030bf8c0
--- /dev/null
+++ b/perf/gauntlet/runtime/entry-shim.js
@@ -0,0 +1,4 @@
+// Loaded in place of SampleApp index.js's first import: installs the probe, then loads the real module.
+require('./probe.js');
+require('./probe-llc.js');
+module.exports = require('gauntlet-real-entry');
diff --git a/perf/gauntlet/runtime/probe-llc.js b/perf/gauntlet/runtime/probe-llc.js
new file mode 100644
index 0000000000..80a85e722b
--- /dev/null
+++ b/perf/gauntlet/runtime/probe-llc.js
@@ -0,0 +1,25 @@
+// The LLC half of the probe. An ES `import`, so Metro resolves the same stream-chat build (package
+// "exports" import condition) the app imports; a CommonJS require() would get a different copy.
+import { StreamChat } from 'stream-chat';
+
+const B = globalThis.__bench;
+const origGetInstance = StreamChat.getInstance;
+StreamChat.getInstance = function (...args) {
+  const client = origGetInstance.apply(this, args);
+  if (client && !client.__benchWrapped) {
+    client.__benchWrapped = true;
+    B.client = client;
+    const dispatch = client.dispatchEvent;
+    client.dispatchEvent = function (event) {
+      const t0 = B.pnow();
+      try {
+        return dispatch.apply(this, arguments);
+      } finally {
+        B.emit('E', [Date.now(), (event && event.type) || '?', B.r2(B.pnow() - t0)]);
+      }
+    };
+    B.emit('I', ['client wrapped']);
+  }
+  return client;
+};
+B.emit('I', ['llc probe installed']);
diff --git a/perf/gauntlet/runtime/probe.js b/perf/gauntlet/runtime/probe.js
new file mode 100644
index 0000000000..ef3df9ae25
--- /dev/null
+++ b/perf/gauntlet/runtime/probe.js
@@ -0,0 +1,378 @@
+/* Bench probe, loaded before anything else in the bundle (see entry-shim.js).
+ *
+ * Needs React's PROFILING renderer (the Metro config redirects ReactFabric-prod to it), which keeps
+ * fiber.actualDuration / actualStartTime and the Profiler commit hooks in a release build.
+ *
+ * Per React commit (fake DevTools hook, installed before the renderer loads):
+ *   wall    = hook time - HostRoot.actualStartTime  (render + Fabric commit/layout + layout effects)
+ *   render  = HostRoot.actualDuration               (render phase incl. host-node creation)
+ *   per component name: self time, inclusive time (outermost instance only), renders, mounts
+ * Root <Profiler> (AppRegistry patch): layout-effect and passive-effect durations.
+ * client.dispatchEvent: synchronous event-handling time per event type.
+ * Hermes heap/GC stats once a second.
+ *
+ * Everything is buffered and flushed to logcat once a second as `BENCH <kind> <json>` lines under 3.5k
+ * chars. The host marks scenario windows with `adb shell log -t PERFMARK ...` and matches by Date.now(). */
+(function () {
+  var g = globalThis;
+  if (g.__bench) return;
+  var B = (g.__bench = { commits: 0 });
+  var DIAG = false; // set by gauntlet-transformer.js in diagnostic builds only
+  var pnow = function () {
+    return g.performance.now();
+  };
+
+  var out = [];
+  var emit = function (kind, payload) {
+    out.push('BENCH ' + kind + ' ' + JSON.stringify(payload));
+  };
+
+  // Component-name table, sent incrementally.
+  var nameIds = new Map();
+  var newNames = [];
+  var nameId = function (n) {
+    var i = nameIds.get(n);
+    if (i === undefined) {
+      i = nameIds.size;
+      nameIds.set(n, i);
+      newNames.push([i, n]);
+    }
+    return i;
+  };
+
+  var typeName = function (t) {
+    if (!t) return null;
+    if (typeof t === 'function') return t.displayName || t.name || 'Anonymous';
+    if (typeof t === 'object') {
+      if (t.displayName) return t.displayName;
+      if (t.render) return t.render.displayName || t.render.name || 'ForwardRef';
+      if (t.type) return typeName(t.type);
+    }
+    return null;
+  };
+  var fiberName = function (f) {
+    switch (f.tag) {
+      case 0:
+      case 1:
+      case 11:
+      case 15:
+        return typeName(f.type) || 'Anonymous';
+      case 14:
+        return (typeName(f.type) || 'Anonymous') + '(memo)';
+      case 5:
+        return '#' + f.type;
+      case 6:
+        return '#text';
+      case 3:
+        return '#root';
+      default:
+        return null; // context, fragment, mode, profiler, suspense...: folded into '#other'
+    }
+  };
+  var OTHER = '#other';
+
+  // Per-commit accumulation (reused arrays keyed by name id).
+  var selfT = [];
+  var inclT = [];
+  var rend = [];
+  var mnt = [];
+  var touched = [];
+  var active = [];
+  var hooks = [];
+  var ctxChanges = {};
+  var touch = function (id) {
+    if (selfT[id] === undefined || selfT[id] === null) {
+      selfT[id] = 0;
+      inclT[id] = 0;
+      rend[id] = 0;
+      mnt[id] = 0;
+      active[id] = 0;
+      touched.push(id);
+    }
+  };
+
+  var walk = function (root) {
+    // Iterative DFS over the fibers React processed in this commit; enter/exit markers keep an
+    // "already inside a same-named fiber" count so inclusive time is counted once per subtree.
+    var stack = [root];
+    var exits = [false];
+    while (stack.length) {
+      var f = stack.pop();
+      var isExit = exits.pop();
+      var n = fiberName(f);
+      var id = nameId(n || OTHER);
+      if (isExit) {
+        active[id] -= 1;
+        continue;
+      }
+      touch(id);
+      var alt = f.alternate;
+      var dur = f.actualDuration > 0 ? f.actualDuration : 0;
+      var childSum = 0;
+      var reconciled = !alt || f.child !== alt.child;
+      if (n !== null && active[id] === 0) inclT[id] += dur;
+      active[id] += 1;
+      stack.push(f);
+      exits.push(true);
+      if (reconciled) {
+        for (var c = f.child; c; c = c.sibling) {
+          childSum += c.actualDuration > 0 ? c.actualDuration : 0;
+          stack.push(c);
+          exits.push(false);
+        }
+      }
+      var self = dur - childSum;
+      selfT[id] += self > 0 ? self : 0;
+      if (f.tag === 0 || f.tag === 1 || f.tag === 11 || f.tag === 15) {
+        if (f.flags & 1) rend[id] += 1;
+      }
+      if (!alt) mnt[id] += 1;
+      // Diagnostic builds: context providers whose value changed identity in this commit.
+      if (
+        DIAG &&
+        f.tag === 10 &&
+        alt &&
+        alt.memoizedProps &&
+        f.memoizedProps &&
+        alt.memoizedProps.value !== f.memoizedProps.value
+      ) {
+        var cx = f.type && (f.type._context || f.type);
+        var v = f.memoizedProps.value;
+        var cname =
+          (cx && cx.displayName) ||
+          'ctx{' +
+            (v && typeof v === 'object' ? Object.keys(v).slice(0, 4).join(',') : typeof v) +
+            '}';
+        var changed = '';
+        if (
+          v &&
+          typeof v === 'object' &&
+          alt.memoizedProps.value &&
+          typeof alt.memoizedProps.value === 'object'
+        ) {
+          var ov = alt.memoizedProps.value;
+          changed = Object.keys(v)
+            .filter(function (k) {
+              return v[k] !== ov[k];
+            })
+            .slice(0, 6)
+            .join(',');
+        }
+        ctxChanges[cname + ' [' + changed + ']'] =
+          (ctxChanges[cname + ' [' + changed + ']'] || 0) + 1;
+      }
+      // Diagnostic builds: hooks per mounted function component (length of the hook list).
+      if (DIAG && !alt && (f.tag === 0 || f.tag === 11 || f.tag === 15)) {
+        var hk = 0;
+        for (var h = f.memoizedState; h && typeof h === 'object' && 'next' in h; h = h.next)
+          hk += 1;
+        hooks[id] = (hooks[id] || 0) + hk;
+      }
+    }
+  };
+
+  var r2 = function (x) {
+    return Math.round(x * 100) / 100;
+  };
+
+  var installHook = function () {
+    var hook = g.__REACT_DEVTOOLS_GLOBAL_HOOK__;
+    if (!hook) {
+      var rid = 0;
+      hook = g.__REACT_DEVTOOLS_GLOBAL_HOOK__ = {
+        supportsFiber: true,
+        renderers: new Map(),
+        inject: function (r) {
+          rid += 1;
+          this.renderers.set(rid, r);
+          return rid;
+        },
+        onScheduleFiberRoot: function () {},
+        onCommitFiberRoot: function () {},
+        onCommitFiberUnmount: function () {},
+        onPostCommitFiberRoot: function () {},
+        checkDCE: function () {},
+      };
+    }
+    var orig = hook.onCommitFiberRoot;
+    hook.onCommitFiberRoot = function (rendererID, root) {
+      var tHook = pnow();
+      var ts = Date.now();
+      try {
+        var cur = root && root.current;
+        if (cur) {
+          B.commits += 1;
+          var wall = cur.actualStartTime >= 0 ? tHook - cur.actualStartTime : -1;
+          var render = cur.actualDuration > 0 ? cur.actualDuration : 0;
+          touched.length = 0;
+          walk(cur);
+          var rows = [];
+          for (var i = 0; i < touched.length; i++) {
+            var id = touched[i];
+            if (selfT[id] > 0.004 || inclT[id] > 0.004 || rend[id] || mnt[id]) {
+              rows.push(
+                DIAG
+                  ? [id, r2(selfT[id]), r2(inclT[id]), rend[id], mnt[id], hooks[id] || 0]
+                  : [id, r2(selfT[id]), r2(inclT[id]), rend[id], mnt[id]],
+              );
+              hooks[id] = 0;
+            }
+            selfT[id] = null;
+          }
+          emit('C', [B.commits, ts, r2(wall), r2(render), r2(pnow() - tHook)]);
+          for (var k = 0; k < rows.length; k += 110) {
+            emit('D', [B.commits, rows.slice(k, k + 110)]);
+          }
+        }
+      } catch (e) {
+        emit('ERR', String(e && e.stack));
+      }
+      return orig && orig.apply(this, arguments);
+    };
+  };
+  installHook();
+
+  // Root Profiler: layout / passive effect durations.
+  var React = require('react');
+  var RN = require('react-native');
+  var onCommit = function (id, phase, effectDuration) {
+    emit('L', [Date.now(), r2(effectDuration)]);
+  };
+  var onPostCommit = function (id, phase, passiveDuration) {
+    emit('P', [Date.now(), r2(passiveDuration)]);
+  };
+  var origReg = RN.AppRegistry.registerComponent;
+  RN.AppRegistry.registerComponent = function (key, getComponent, section) {
+    return origReg.call(
+      this,
+      key,
+      function () {
+        var C = getComponent();
+        var Wrapped = function (props) {
+          return React.createElement(
+            React.Profiler,
+            { id: 'gauntlet-root', onCommit: onCommit, onPostCommit: onPostCommit },
+            React.createElement(C, props),
+          );
+        };
+        return Wrapped;
+      },
+      section,
+    );
+  };
+
+  // LLC event handling: see probe-llc.js (an ES module, so it gets the same stream-chat build as the app).
+  B.emit = emit;
+  B.pnow = pnow;
+  B.r2 = r2;
+
+  var heap = function () {
+    var H = g.HermesInternal;
+    var s = H && H.getInstrumentedStats ? H.getInstrumentedStats() : null;
+    if (s) {
+      emit('H', [
+        Date.now(),
+        s.js_numGCs,
+        r2(s.js_gcCPUTime || 0),
+        r2(s.js_gcTime || 0),
+        s.js_heapSize,
+        s.js_allocatedBytes,
+      ]);
+    }
+  };
+
+  // Loaded-message counts of the Bench channels, logged when they change (proves "100 loaded").
+  var lastCounts = {};
+  var counts = function () {
+    var client = B.client;
+    if (!client) return;
+    // v10 keeps channels in client.channelManager, v9 in client.activeChannels.
+    var list =
+      client.channelManager && client.channelManager.values
+        ? client.channelManager.values()
+        : Object.keys(client.activeChannels || {}).map(function (k) {
+            return client.activeChannels[k];
+          });
+    var cids = list.map(function (c) {
+      return c && c.cid;
+    });
+    for (var i = 0; i < list.length; i++) {
+      var ch = list[i];
+      var d = ch && ch.data;
+      var name = d && (d.name || (d.custom && d.custom.name));
+      if (!name || String(name).indexOf('Bench') !== 0) continue;
+      var n = -1;
+      try {
+        n = ch.messagePaginator
+          ? (ch.messagePaginator.state.getLatestValue().items || []).length
+          : ch.state.messages.length;
+      } catch (e) {}
+      if (lastCounts[cids[i]] !== n) {
+        lastCounts[cids[i]] = n;
+        emit('M', [Date.now(), String(name), n]);
+      }
+    }
+  };
+
+  // Diagnostic builds only (GAUNTLET_DIAG): which Message areEqual check failed.
+  var ae = {};
+  g.__benchAreEqual = function (k) {
+    ae[k] = (ae[k] || 0) + 1;
+  };
+
+  // Speed index: a fixed amount of JS work timed once a second. The emulator can run on slower or
+  // faster host cores; this shows which, per window, independent of the code under test.
+  // Two probes: a tight arithmetic loop (CPU speed) and a memory-heavy one (allocate and walk ~1 MB of
+  // objects). React work is memory-heavy: when the host compresses or swaps the emulator's RAM, the second
+  // slows down (several x) while the first does not.
+  var calibrate = function () {
+    var t0 = pnow();
+    var x = 0;
+    for (var i = 0; i < 50000; i++) x = (x + i * 7) % 1000003;
+    var arith = pnow() - t0;
+    t0 = pnow();
+    var objs = [];
+    for (var j = 0; j < 20000; j++) objs.push({ a: j, b: 'k' + (j % 97), c: [j, j + 1] });
+    var sum = 0;
+    for (var k = objs.length - 1; k >= 0; k -= 7)
+      sum += objs[k].a + objs[k].c[1] + objs[k].b.length;
+    emit('S', [Date.now(), r2(arith), x, r2(pnow() - t0), sum]);
+  };
+
+  var flush = function () {
+    calibrate();
+    if (Object.keys(ctxChanges).length) {
+      emit('X', [Date.now(), ctxChanges]);
+      ctxChanges = {};
+    }
+    if (Object.keys(ae).length) {
+      emit('A', [Date.now(), ae]);
+      ae = {};
+    }
+    try {
+      counts();
+    } catch (e) {}
+    if (newNames.length) {
+      for (var k = 0; k < newNames.length; k += 60) emit('N', newNames.slice(k, k + 60));
+      newNames = [];
+      // names must precede the commits that use them: move them to the front of this flush
+      var nLines = out.filter(function (l) {
+        return l.indexOf('BENCH N ') === 0;
+      });
+      var rest = out.filter(function (l) {
+        return l.indexOf('BENCH N ') !== 0;
+      });
+      out = nLines.concat(rest);
+    }
+    heap();
+    var lines = out;
+    out = [];
+    for (var i = 0; i < lines.length; i++) console.log(lines[i]);
+  };
+  setInterval(flush, 1000);
+  emit('I', [
+    'probe installed',
+    typeof g.HermesInternal,
+    g.__REACT_DEVTOOLS_GLOBAL_HOOK__ ? 'hook' : 'nohook',
+  ]);
+})();
diff --git a/perf/gauntlet/seed.cjs b/perf/gauntlet/seed.cjs
new file mode 100644
index 0000000000..67ed2ac804
--- /dev/null
+++ b/perf/gauntlet/seed.cjs
@@ -0,0 +1,255 @@
+// seed.cjs <deviceUser> — deterministic bench data for one measurement session's device user
+// (<prefix>_s1..<prefix>_sN from tokens.cjs; a fresh user per session so every session starts from
+// identical state). Takes ~5 min per user (hundreds of API calls); run seeds BEFORE measuring, never
+// alongside a session.
+//   Other users: bench_ana, bench_ben, bench_cleo, bench_dan.
+//   "Bench Mount": 160 mixed messages (the latest 100 are what the list loads), never mutated by events.
+//   "Bench Live":  the same 160 messages, the target of incoming events.
+//   28 list channels ("Team 01".."Team 26" + 2 DMs) with a few messages each, some unread.
+// Writes out/seed/seed-<deviceUser>.json (read by session.sh).
+const fs = require('fs');
+const path = require('path');
+const { connect } = require('./lib.cjs');
+
+const ME = process.argv[2];
+if (!/^[a-z0-9_]+_s\d+$/.test(ME || '')) throw new Error('usage: seed.cjs <prefix>_sN');
+const USERS = {
+  [ME]: { name: 'Bench Me', image: 'https://randomuser.me/api/portraits/men/32.jpg' },
+  bench_ana: { name: 'Ana Torres', image: 'https://randomuser.me/api/portraits/women/44.jpg' },
+  bench_ben: { name: 'Ben Okafor', image: 'https://randomuser.me/api/portraits/men/75.jpg' },
+  bench_cleo: { name: 'Cleo Park', image: 'https://randomuser.me/api/portraits/women/68.jpg' },
+  bench_dan: { name: 'Dan Reyes', image: 'https://randomuser.me/api/portraits/men/12.jpg' },
+};
+
+const SHORT = [
+  'ok',
+  'sounds good 👍',
+  'on it',
+  'lol',
+  'yes!',
+  'thanks',
+  'brb',
+  'nice',
+  '👀',
+  'agreed',
+];
+const MEDIUM = [
+  'I pushed the fix to the branch, can you take a look when you get a sec?',
+  'The meeting moved to 3pm, same room as last week.',
+  'Did anyone else see the build fail on the release pipeline this morning?',
+  'Let me check with the design team and get back to you.',
+  'Coffee run in 10 minutes, who wants something?',
+  'Reminder: the quarterly review deck is due Friday.',
+  'I think we should split this into two smaller PRs.',
+  'Can confirm it works on Android, still testing iOS.',
+];
+const LONG = [
+  'Quick summary of where we are: the new pagination layer is merged, the list renders from the paginator, and the remaining work is mostly cleanup. There are two open questions about how we handle jumps to old messages and whether the unread separator should survive a reconnect. I would like to settle both before the release branch is cut next week.',
+  'Long story short, the crash only happens when the app resumes from the background with a stale socket and the user immediately opens a thread. The thread query races the reconnect and we end up with an empty reply list. I have a repro on the emulator and a fix that waits for the connection to recover before querying.',
+  'For the offsite we have three options: the mountain lodge (great views, two hours away), the downtown space (easy to reach, no outdoor area), or the lake house (in between on both). Please vote in the thread below by Thursday so we can book it.',
+];
+const MARKDOWN = [
+  'Release checklist:\n- bump the version\n- update the **changelog**\n- run `yarn build` and the _full_ test suite\n- tag and publish',
+  'Use this instead:\n```ts\nconst items = paginator.state.getLatestValue().items;\n```\nit avoids the extra copy.',
+  '**Heads up:** the staging DB is being migrated tonight. Expect ~15 min of downtime around _22:00 UTC_.',
+  '1. open the channel\n2. scroll to the top\n3. tap the quoted message\n\n> it should jump to the original',
+];
+const LINKS = [
+  'Docs are here https://getstream.io/chat/docs/sdk/reactnative/',
+  'Repo: https://github.com/GetStream/stream-chat-react-native',
+  'Worth reading https://reactnative.dev/blog',
+  'Our site https://getstream.io',
+];
+const EMOJI = ['🔥🔥🔥', '🎉', '😂😂', '🚀'];
+
+const img = (id, w = 800, h = 600) => ({
+  type: 'image',
+  image_url: `https://picsum.photos/id/${id}/${w}/${h}`,
+  original_width: w,
+  original_height: h,
+  fallback: `image-${id}.jpg`,
+});
+const voice = (n) => ({
+  type: 'voiceRecording',
+  asset_url: 'https://upload.wikimedia.org/wikipedia/commons/c/c8/Example.ogg',
+  duration: 7 + n,
+  mime_type: 'audio/ogg',
+  file_size: 104000 + n,
+  title: `audio_recording_${n}.ogg`,
+  waveform_data: Array.from(
+    { length: 100 },
+    (_, i) => Math.round(Math.abs(Math.sin((i + n) / 7)) * 100) / 100,
+  ),
+});
+const file = {
+  type: 'file',
+  asset_url: 'https://www.w3.org/WAI/ER/tests/xhtml/testfiles/resources/pdf/dummy.pdf',
+  title: 'quarterly-report.pdf',
+  mime_type: 'application/pdf',
+  file_size: 13264,
+};
+
+// Deterministic content plan for message i (1-based) of a 160-message channel.
+const SENDER_RUNS = [
+  ['bench_ana', 2],
+  [ME, 1],
+  ['bench_ben', 3],
+  ['bench_cleo', 1],
+  [ME, 2],
+  ['bench_ana', 1],
+  ['bench_ben', 1],
+  [ME, 1],
+  ['bench_cleo', 2],
+  ['bench_ana', 3],
+];
+const senders = [];
+while (senders.length < 160)
+  for (const [u, n] of SENDER_RUNS) for (let k = 0; k < n; k++) senders.push(u);
+
+const plan = (i) => {
+  const m = {};
+  if (i % 23 === 0) m.attachments = [img(10 + (i % 40)), img(20 + (i % 40)), img(30 + (i % 40))];
+  else if (i % 11 === 0) m.attachments = [img(100 + (i % 50))];
+  else if (i % 37 === 0) m.attachments = [voice(i)];
+  else if (i % 41 === 0) m.attachments = [file];
+  if (i % 31 === 0) m.text = LINKS[(i / 31) % LINKS.length];
+  else if (i % 13 === 0) m.text = MARKDOWN[(i / 13) % MARKDOWN.length];
+  else if (i % 17 === 0) m.text = LONG[(i / 17) % LONG.length];
+  else if (i % 19 === 0) m.text = EMOJI[(i / 19) % EMOJI.length];
+  else if (i % 3 === 0) m.text = SHORT[i % SHORT.length];
+  else if (!m.attachments || i % 2) m.text = MEDIUM[i % MEDIUM.length];
+  if (i % 29 === 0) {
+    m.text = `@Ana Torres ${m.text || 'can you check this?'}`;
+    m.mentioned_users = ['bench_ana'];
+  }
+  return m;
+};
+// Which messages get extras (indices 1-based).
+const QUOTES = [44, 58, 72, 86, 99, 113, 127, 141, 152, 158]; // quote the message 5 before
+const REACTIONS = {}; // index -> [[user, type]...]
+for (let i = 62; i <= 160; i += 4) {
+  const set = [
+    ['bench_ana', 'like'],
+    ['bench_ben', 'love'],
+    ['bench_cleo', 'haha'],
+    [ME, 'wow'],
+  ];
+  REACTIONS[i] = set.slice(0, 1 + (i % 4));
+}
+const THREADS = { 120: 40, 131: 3, 145: 5, 150: 1 }; // index -> reply count (120 = the bench thread)
+const EDITS = [77, 104, 138];
+const DELETES = [91, 133];
+const PINS = [118];
+
+const seedChannel = async (clients, id, name, members) => {
+  const ch = {};
+  const owner = clients[ME];
+  const c0 = owner.channel('messaging', id, { members, custom: { name } });
+  await c0.create();
+  for (const u of members) {
+    ch[u] = clients[u].channel('messaging', id);
+    await ch[u].watch();
+  }
+  const ids = [];
+  for (let i = 1; i <= 160; i++) {
+    const u = senders[i - 1];
+    const msg = plan(i);
+    if (QUOTES.includes(i)) msg.quoted_message_id = ids[i - 6];
+    const { message } = await ch[u].sendMessage({ message: msg });
+    ids.push(message.id);
+    if (THREADS[i]) {
+      for (let r = 1; r <= THREADS[i]; r++) {
+        const ru = r % 3 === 0 ? ME : r % 3 === 1 ? 'bench_ben' : 'bench_ana';
+        const reply = {
+          text: r % 5 === 0 ? LONG[r % LONG.length] : `${MEDIUM[r % MEDIUM.length]} (reply ${r})`,
+          parent_id: message.id,
+        };
+        if (r === 2 && i === 120) reply.show_in_channel = true;
+        await ch[ru].sendMessage({ message: reply });
+      }
+    }
+    if (i % 20 === 0) process.stdout.write(`${name}: ${i}\n`);
+  }
+  for (const [i, set] of Object.entries(REACTIONS)) {
+    for (const [u, type] of set)
+      await clients[u].sendReaction({ id: ids[i - 1] }, { reaction: { type } });
+  }
+  for (const i of EDITS) {
+    const u = senders[i - 1];
+    await clients[u].updateMessage(
+      { id: ids[i - 1] },
+      { message: { ...plan(i), text: `${plan(i).text || 'edited'} (edited)` } },
+    );
+  }
+  for (const i of PINS) await clients[ME].pinMessage(ids[i - 1]);
+  for (const i of DELETES)
+    await clients[senders[i - 1]].deleteMessage({ id: ids[i - 1] }, { hard: false });
+  await ch[ME].markRead();
+  return { id, cid: `messaging:${id}`, name, ids, threadParent: ids[119] };
+};
+
+(async () => {
+  const clients = {};
+  for (const id of Object.keys(USERS)) clients[id] = await connect(id);
+  for (const [id, u] of Object.entries(USERS)) {
+    await clients[id].updateUsersPartial({
+      users: [{ id, set: { name: u.name, image: u.image } }],
+    });
+  }
+  const ts = Date.now().toString(36);
+  const others = ['bench_ana', 'bench_ben', 'bench_cleo', 'bench_dan'];
+  const list = [];
+  for (let t = 1; t <= 26; t++) {
+    const members = [ME, ...others.filter((_, k) => (t + k) % 3 !== 0)];
+    const id = `bench-team-${String(t).padStart(2, '0')}-${ts}`;
+    const name = `Team ${String(t).padStart(2, '0')}`;
+    const custom = { name };
+    if (t % 4 === 0) custom.image = `https://picsum.photos/id/${200 + t}/200/200`;
+    await clients[ME].channel('messaging', id, { members, custom }).create();
+    const n = 2 + (t % 4);
+    for (let k = 0; k < n; k++) {
+      const u = members[(t + k) % members.length];
+      const msg = {
+        text: k === n - 1 && t % 5 === 0 ? undefined : MEDIUM[(t + k) % MEDIUM.length],
+      };
+      if (!msg.text) msg.attachments = [img(300 + t)];
+      await clients[u].channel('messaging', id).sendMessage({ message: msg });
+    }
+    // Most read, every 4th left unread (the last messages are from others there).
+    if (t % 4 !== 1) await clients[ME].channel('messaging', id).markRead();
+    list.push({ id, cid: `messaging:${id}`, name });
+  }
+  for (const other of ['bench_cleo', 'bench_dan']) {
+    const dm = clients[ME].channel('messaging', { members: [ME, other] });
+    await dm.create();
+    await clients[other]
+      .channel('messaging', dm.id)
+      .sendMessage({ message: { text: `hey, got a minute? (${other})` } });
+    await clients[ME].channel('messaging', dm.id).sendMessage({
+      message: { text: 'sure, what is up?' },
+    });
+    list.push({ id: dm.id, cid: dm.cid, name: `DM ${other}` });
+  }
+  const mount = await seedChannel(clients, `bench-mount-${ts}`, 'Bench Mount', [
+    ME,
+    'bench_ana',
+    'bench_ben',
+    'bench_cleo',
+  ]);
+  const live = await seedChannel(clients, `bench-live-${ts}`, 'Bench Live', [
+    ME,
+    'bench_ana',
+    'bench_ben',
+    'bench_cleo',
+  ]);
+  fs.mkdirSync(path.join(__dirname, 'out', 'seed'), { recursive: true });
+  fs.writeFileSync(
+    path.join(__dirname, 'out', 'seed', `seed-${ME}.json`),
+    JSON.stringify({ me: ME, ts, mount, live, list }, null, 2),
+  );
+  console.log('seeded', ts);
+  process.exit(0);
+})().catch((e) => {
+  console.error('ERR', e.message, JSON.stringify(e.response?.data ?? {}).slice(0, 400));
+  process.exit(1);
+});
diff --git a/perf/gauntlet/session.sh b/perf/gauntlet/session.sh
new file mode 100755
index 0000000000..05ae3168d5
--- /dev/null
+++ b/perf/gauntlet/session.sh
@@ -0,0 +1,251 @@
+#!/bin/bash
+# session.sh <base|head> <apk-label> <user> <outdir> [phases...]
+# One measurement session: installs out/apk/<apk-label>.apk, logs in as <user> (seeded: out/seed/seed-<user>.json),
+# runs the phases, then analyzes. Every scenario window is S/E-marked on the device clock; nothing that touches
+# the UI hierarchy (uiautomator dumps) runs inside a window.
+# Phases (default "setup warm cold list flat flash"): setup warm cold list flat flash rowcost diagthread.
+# Env: RUNS (default 5), GAUNTLET_SERIAL (default: first adb device), GAUNTLET_PKG.
+# Coordinates assume a 1080x2400 screen (the Pixel 7 AVD); setup warns otherwise.
+# Never edit this file while a session runs (bash reads scripts incrementally): run.sh runs a frozen copy.
+G=${GAUNTLET_DIR:-$(cd "$(dirname "$0")" && pwd)}
+B=$G
+ROLE=$1; LABEL_APK=$2; ME=$3; OUT=$4; shift 4
+PHASES=" ${*:-setup warm cold list flat flash} "
+S=${GAUNTLET_SERIAL:-$(adb devices | awk 'NR>1 && $2=="device" {print $1; exit}')}
+P=${GAUNTLET_PKG:-io.getstream.reactnative.sampleapp}
+R=${RUNS:-5}
+[ -n "$S" ] || { echo "no adb device"; exit 1; }
+mkdir -p "$OUT/gfx"
+SEED=$G/out/seed/seed-$ME.json
+[ -f "$SEED" ] || { echo "no $SEED"; exit 1; }
+j() { node -e "const s=require('$SEED'); console.log($1)"; }
+MOUNT_CID=$(j s.mount.cid); LIVE_CID=$(j s.live.cid); PARENT=$(j s.mount.threadParent)
+has() { [[ "$PHASES" == *" $1 "* ]]; }
+A() { adb -s $S "$@"; }
+U() { python3 "$B/ui.py" $S "$@"; }
+log() { echo "[$(date +%H:%M:%S)] $*" | tee -a "$OUT/session.log"; }
+act() { curl -s -m 30 "http://127.0.0.1:9356/$1"; }
+LABEL=
+win() { LABEL=$1; A shell dumpsys gfxinfo $P reset >/dev/null; A shell sh /data/local/tmp/devmark.sh S "$LABEL" $P; }
+endwin() { A shell sh /data/local/tmp/devmark.sh E "$LABEL" $P; A shell dumpsys gfxinfo $P > "$OUT/gfx/$LABEL.txt"; }
+settle() { sleep "${1:-2}"; }
+back() { A shell input keyevent 4; }
+hide_kb() { A shell dumpsys input_method | grep -q 'mInputShown=true' && back; return 0; }
+findre() { python3 "$B/find.py" $S "$1"; }
+deny_notif() { U has-id com.android.permissioncontroller:id/permission_deny_button && U tap-id com.android.permissioncontroller:id/permission_deny_button; }
+on_list() { U has-id channel-list-view; }
+to_list() { local t; for t in 1 2 3 4; do on_list && return 0; back; sleep 1.5; done; on_list; }
+# tap a channel row by its name (dump happens before the caller opens a window)
+row_xy() { U dump | python3 -c "
+import sys,re
+for l in sys.stdin:
+    if \"id='channel-preview-button'\" in l and ', $1, ' in l:
+        x1,y1,x2,y2=map(int,re.findall(r'\d+',l.split(')')[0])); print((x1+x2)//2,(y1+y2)//2); break"; }
+open_channel_unmeasured() { local xy; xy=$(row_xy "$1"); [ -n "$xy" ] || return 1; A shell input tap $xy; U wait-id message-flat-list 20; }
+scroll_up_n() { local k; for k in $(seq 1 $1); do A shell input swipe 540 800 540 1800 300; sleep 0.6; done; }
+scroll_thread_n() { local k; for k in $(seq 1 $1); do A shell input swipe 540 800 540 1600 400; sleep 1.2; done; }
+restart_app() { A shell am force-stop $P; A shell am start -n $P/.MainActivity >/dev/null; U wait-id channel-list-view 90 || { deny_notif; U wait-id channel-list-view 60; }; deny_notif; }
+set_list_impl() { # FlatList|FlashList
+  local ok= attempt
+  for attempt in 1 2 3; do
+    to_list; A shell input tap 72 220; sleep 3; for _t in 1 2 3 4 5 6 7 8; do A shell input tap 255 210; sleep 0.4; done; sleep 2
+    if U tap-text "$1"; then ok=1; break; fi
+    back; sleep 2
+  done
+  [ -n "$ok" ] || { log "WARN could not switch to $1"; return 1; }
+  sleep 1; back; sleep 1; restart_app; sleep 8; log "list implementation: $1"; }
+
+# logcat for the whole session
+A logcat -c; A logcat -G 16M >/dev/null
+adb -s $S logcat -v epoch -s ReactNativeJS:V PERFMARK:V > "$OUT/logcat.txt" &
+LC=$!
+trap 'kill $LC 2>/dev/null' EXIT
+A push "$B/devmark.sh" /data/local/tmp/devmark.sh >/dev/null
+echo "side=$ROLE apk=$LABEL_APK apk_md5=$(cat "$G/out/apk/$LABEL_APK.md5" 2>/dev/null) user=$ME seed=$(j s.ts) runs=$R phases=$PHASES" > "$OUT/meta.txt"
+
+if has setup; then
+  log "setup: install $LABEL_APK ($ROLE)"
+  SIZE=$(A shell wm size | grep -oE '[0-9]+x[0-9]+' | tail -1)
+  [ "$SIZE" = 1080x2400 ] || log "WARN screen is $SIZE: drawer/secret-menu taps and swipes assume 1080x2400"
+  A install -r "$G/out/apk/$LABEL_APK.apk" | tail -1
+  A shell pm clear $P >/dev/null
+  # granted up front so the permission dialog never pauses the app (it pauses JS timers too)
+  A shell pm grant $P android.permission.POST_NOTIFICATIONS
+  A shell am start -n $P/.MainActivity >/dev/null
+  U wait-id "user-selector-button-$ME" 40 || { for t in 1 2 3; do A shell input swipe 540 1900 540 700 400; U has-id "user-selector-button-$ME" && break; done; }
+  U tap-id "user-selector-button-$ME"; sleep 4; deny_notif
+  U wait-id channel-list-view 60 || { log "no channel list"; exit 1; }
+  sleep 10
+fi
+
+if has warm; then
+  log "warm-up (images, caches)"
+  open_channel_unmeasured "Bench Mount" && { sleep 4; scroll_up_n 14; sleep 2; back; sleep 2; }
+  open_channel_unmeasured "Bench Live" && { sleep 4; scroll_up_n 4; sleep 1; back; sleep 2; }
+  sleep 3
+fi
+
+# Cold start, controlled: the window opens before the force-stop and the launch follows at once, so
+# the process starts at launch. A plain force-stop + wait lets Firebase's datatransport job restart the app
+# ~0.4s later, so the launch lands in a half-initialized background process and cold starts become bimodal.
+# (The logged start reason may still say "service": that job's request lands in the same instant.)
+if has cold; then
+  for i in $(seq 1 $R); do
+    to_list; sleep 4
+    win "cold_start#$i"; A shell "am force-stop $P; am start -n $P/.MainActivity" >/dev/null; settle 15; endwin
+    reason=$(A logcat -d -b events | grep "am_proc_start.*$P" | tail -1 | grep -oE "next-top-activity|service|broadcast|content provider|activity" | head -1)
+    log "cold_start#$i process started for: $reason"
+    on_list || U wait-id channel-list-view 30
+    sleep 6
+  done
+fi
+
+if has list; then
+  to_list; sleep 3
+  for i in $(seq 1 $R); do
+    log "list events #$i"
+    win "list_msg_top#$i"; act "say?cid=$LIVE_CID&user=bench_ana&text=list-top-$i" >/dev/null; settle 3; endwin; sleep 1
+    # the channel at the bottom of the first page (10 channels) moves to the top: Team 21, 22, ...
+    T=$((20 + i)); TCID=$(j "s.list.find(c=>c.name==='Team $T').cid")
+    win "list_msg_reorder#$i"; act "say?cid=$TCID&user=bench_ben&text=list-reorder-$i" >/dev/null; settle 3; endwin; sleep 1
+    MID=$(act "last?cid=$LIVE_CID&n=1" | node -e "let s='';process.stdin.on('data',d=>s+=d).on('end',()=>console.log(JSON.parse(s).r[0].id))")
+    win "list_reaction#$i"; act "react?id=$MID&user=bench_cleo&type=like" >/dev/null; settle 3; endwin; sleep 1
+    win "list_typing#$i"; act "typing?cid=$LIVE_CID&user=bench_ben&ms=1500" >/dev/null; settle 2; endwin; sleep 1
+    win "list_read#$i"; act "read?cid=$LIVE_CID&user=bench_cleo" >/dev/null; settle 3; endwin; sleep 1
+    win "list_presence_on#$i"; act "online?user=bench_dan" >/dev/null; settle 4; endwin; sleep 2
+    win "list_presence_off#$i"; act "offline?user=bench_dan" >/dev/null; settle 4; endwin; sleep 2
+  done
+fi
+
+# Channel-screen phase for one list implementation: open/close, live events, composer, scroll, thread, menu.
+channel_phase() {
+  local impl=$1
+  to_list; sleep 2
+  for i in $(seq 1 $R); do
+    log "$impl open/close #$i"
+    xy=$(row_xy "Bench Mount"); sleep 2
+    win "open_channel_$impl#$i"; A shell input tap $xy; settle 6; endwin
+    U has-id message-flat-list || { log "WARN open_channel_$impl#$i: list not visible"; to_list; continue; }
+    sleep 1
+    win "close_channel_$impl#$i"; back; settle 3; endwin
+    on_list || { log "WARN not back on list"; to_list; }
+    sleep 1
+  done
+  log "$impl live events"
+  open_channel_unmeasured "Bench Live" || { log "cannot open Bench Live"; return 1; }
+  sleep 6
+  U has-id scroll-to-bottom-button && { U tap-id scroll-to-bottom-button; sleep 3; }
+  sleep 8  # let the list finish its incremental cell rendering before the first event
+  for i in $(seq 1 $R); do
+    win "ch_msg_new_$impl#$i"; LAST=$(act "say?cid=$LIVE_CID&user=bench_ana&text=hello-$impl-$i" | node -e "let s='';process.stdin.on('data',d=>s+=d).on('end',()=>console.log(JSON.parse(s).r))"); settle 3; endwin; sleep 1
+    win "ch_reaction_$impl#$i"; act "react?id=$LAST&user=bench_ben&type=love" >/dev/null; settle 3; endwin; sleep 1
+    win "ch_edit_$impl#$i"; act "edit?id=$LAST&user=bench_ana&text=hello-$impl-$i-edited" >/dev/null; settle 3; endwin; sleep 1
+    win "ch_typing_$impl#$i"; act "typing?cid=$LIVE_CID&user=bench_cleo&ms=1500" >/dev/null; settle 2; endwin; sleep 1
+    win "ch_read_$impl#$i"; act "read?cid=$LIVE_CID&user=bench_ben" >/dev/null; settle 3; endwin; sleep 1
+    win "ch_thread_reply_$impl#$i"; act "reply?cid=$LIVE_CID&parent=$LAST&user=bench_cleo&text=thread-$impl-$i" >/dev/null; settle 3; endwin; sleep 1
+    # composer: type 20 characters, then send
+    U tap-id auto-complete-text-input; sleep 1.5
+    win "composer_type_$impl#$i"; A shell input text "benchtyping$i$impl"; settle 2; endwin
+    SEND=$(U dump | python3 -c "
+import sys,re
+for l in sys.stdin:
+    if \"desc='Send'\" in l or \"id='send-button'\" in l:
+        x1,y1,x2,y2=map(int,re.findall(r'\d+',l.split(')')[0])); print((x1+x2)//2,(y1+y2)//2); break")
+    sleep 1
+    if [ -n "$SEND" ]; then win "ch_own_send_$impl#$i"; A shell input tap $SEND; settle 3; endwin; else log "WARN no send button"; fi
+    hide_kb; sleep 1.5
+  done
+  back; sleep 2; to_list; sleep 2
+  log "$impl scroll"
+  for i in $(seq 1 $R); do
+    open_channel_unmeasured "Bench Mount"; sleep 4
+    win "scroll_$impl#$i"; scroll_up_n 6; settle 2; endwin
+    back; sleep 2; to_list; sleep 1
+  done
+  log "$impl thread"; TSWIPES=
+  for i in $(seq 1 $R); do
+    open_channel_unmeasured "Bench Mount"; sleep 4
+    # the first run searches for the 40-reply parent; later runs replay the same number of swipes
+    TXY=
+    if [ -n "$TSWIPES" ]; then
+      scroll_thread_n $TSWIPES; sleep 1.5; TXY=$(findre '4[0-9] Replies')
+      # item heights are estimated (FlashList), so the replay can overshoot: look back down a little
+      if [ -z "$TXY" ]; then for k in 1 2 3 4; do A shell input swipe 540 1400 540 1000 400; sleep 1.2; TXY=$(findre '4[0-9] Replies') && break; done; fi
+    fi
+    if [ -z "$TXY" ]; then
+      for k in $(seq 1 20); do TXY=$(findre '4[0-9] Replies') && { TSWIPES=${TSWIPES:-$((k - 1))}; break; }; A shell input swipe 540 800 540 1600 400; sleep 1.2; done
+    fi
+    [ -n "$TXY" ] || { log "WARN thread parent not found"; back; sleep 2; continue; }
+    sleep 2; TXY=$(findre '4[0-9] Replies')
+    win "thread_open_$impl#$i"; A shell input tap $TXY; settle 6; endwin
+    U has-text "Thread Reply" || { log "WARN thread_open_$impl#$i: thread screen not open"; to_list; continue; }
+    if [ $i -le 3 ]; then
+      win "thread_reply_event_$impl#$i"; act "reply?cid=$MOUNT_CID&parent=$PARENT&user=bench_ana&text=bench-reply-$impl-$i" >/dev/null; settle 3; endwin
+    fi
+    sleep 1
+    win "thread_close_$impl#$i"; back; settle 3; endwin
+    back; sleep 2; to_list; sleep 1
+  done
+  if [ "$impl" = flat ]; then
+    log "context menu"
+    to_list; open_channel_unmeasured "Bench Mount" || log "WARN menu: channel did not open"; sleep 4
+    for i in $(seq 1 $R); do
+      XY=$(U dump | python3 -c "
+import sys,re
+best=None
+for l in sys.stdin:
+    if \"id='message-content-wrapper'\" in l:
+        x1,y1,x2,y2=map(int,re.findall(r'\d+',l.split(')')[0]))
+        if y2<2100 and (best is None or y1>best[1]): best=((x1+x2)//2,(y1+y2)//2)
+print(*best) if best else None")
+      [ -n "$XY" ] || { log "WARN menu_open#$i: no message found"; break; }
+      sleep 1.5
+      win "menu_open#$i"; A shell input swipe $XY $XY 700; settle 3; endwin
+      win "menu_close#$i"; back; settle 3; endwin
+      U has-id message-flat-list || { log "WARN menu_close#$i: not back in the channel"; break; }
+      sleep 1
+    done
+    back; sleep 2; to_list
+  fi
+}
+
+# Extra samples of the row-mount scenarios (FlatList): opening the 100-message channel and scrolling it.
+if has rowcost; then
+  to_list; sleep 2
+  for i in $(seq 1 $R); do
+    log "rowcost #$i"
+    xy=$(row_xy "Bench Mount"); sleep 2
+    win "x_open_flat#$i"; A shell input tap $xy; settle 6; endwin
+    U has-id message-flat-list || { log "WARN x_open_flat#$i: list not visible"; to_list; continue; }
+    sleep 1
+    win "x_scroll_flat#$i"; scroll_up_n 6; settle 2; endwin
+    back; sleep 2; to_list; sleep 1
+  done
+fi
+
+# Diagnostic: open the channel, open and close the 40-reply thread (diag builds log areEqual results).
+if has diagthread; then
+  to_list; sleep 2
+  open_channel_unmeasured "Bench Mount"; sleep 6
+  for k in $(seq 1 20); do TXY=$(findre '4[0-9] Replies') && break; A shell input swipe 540 800 540 1600 400; sleep 1.2; done
+  sleep 3; TXY=$(findre '4[0-9] Replies')
+  win "diag_thread_open#1"; A shell input tap $TXY; settle 6; endwin
+  win "diag_thread_close#1"; back; settle 4; endwin
+  win "diag_idle#1"; settle 4; endwin
+fi
+
+if has flat; then
+  log "FlatList phase"
+  channel_phase flat
+fi
+if has flash; then
+  log "FlashList phase: switching"
+  set_list_impl FlashList
+  open_channel_unmeasured "Bench Mount" && { sleep 4; scroll_up_n 8; back; sleep 2; }
+  channel_phase flash
+  set_list_impl FlatList
+fi
+log "session done"
+kill $LC 2>/dev/null
+python3 "$B/analyze.py" "$OUT" > "$OUT/summary.txt" 2>&1
+tail -3 "$OUT/summary.txt"
diff --git a/perf/gauntlet/tokens.cjs b/perf/gauntlet/tokens.cjs
new file mode 100644
index 0000000000..fe25d87775
--- /dev/null
+++ b/perf/gauntlet/tokens.cjs
@@ -0,0 +1,39 @@
+// tokens.cjs [count] — writes runtime/generated/ChatUsers.gauntlet.ts with static tokens for the device users
+// <prefix>_s1..<prefix>_s<count> (default 8). GAUNTLET_USER_PREFIX picks the prefix (default "bench");
+// use a fresh prefix per gauntlet so every session's user starts empty. The token generator issues
+// 7-day tokens: regenerate (and rebuild the APKs, which embed the file) when they expire. The generated
+// file is gitignored and must never be committed.
+const fs = require('fs');
+const path = require('path');
+const { tokenFor } = require('./lib.cjs');
+
+(async () => {
+  const count = Number(process.argv[2] || 8);
+  const prefix = process.env.GAUNTLET_USER_PREFIX || 'bench';
+  const tokens = {};
+  const users = {};
+  let exp = 0;
+  for (let i = 1; i <= count; i++) {
+    const id = `${prefix}_s${i}`;
+    tokens[id] = await tokenFor(id);
+    users[id] = {
+      id,
+      image: 'https://randomuser.me/api/portraits/men/32.jpg',
+      name: `Bench S${i}`,
+    };
+    exp = JSON.parse(Buffer.from(tokens[id].split('.')[1], 'base64').toString()).exp;
+  }
+  const out = path.join(__dirname, 'runtime', 'generated');
+  fs.mkdirSync(out, { recursive: true });
+  fs.writeFileSync(
+    path.join(out, 'ChatUsers.gauntlet.ts'),
+    `// Generated by perf/gauntlet/tokens.cjs. Do not commit.\nexport const USER_TOKENS = ${JSON.stringify(tokens)};\nexport const USERS = ${JSON.stringify(users, null, 2)};\n`,
+  );
+  console.log(
+    `wrote ${count} users (${prefix}_s1..${prefix}_s${count}); tokens expire ${new Date(exp * 1000).toISOString()}`,
+  );
+  process.exit(0);
+})().catch((e) => {
+  console.error('ERR', e.message);
+  process.exit(1);
+});
diff --git a/perf/gauntlet/ui.py b/perf/gauntlet/ui.py
new file mode 100644
index 0000000000..deee59d8a9
--- /dev/null
+++ b/perf/gauntlet/ui.py
@@ -0,0 +1,179 @@
+#!/usr/bin/env python3
+"""Tiny adb/uiautomator driver for the perf gauntlet.
+
+Every dump goes to a fresh device path that is deleted first, and the pulled file is checked to be
+new, so a failed dump can never be mistaken for the current screen (the stale-dump trap).
+
+Usage: ui.py <serial> <command> [args]
+  dump                         print a compact list of visible nodes (text / resource-id / desc / bounds)
+  tap-id <prefix> [n]          tap the n-th (default 0) node whose resource-id starts with <prefix>
+  tap-text <substr> [n]        tap the n-th node whose text or content-desc contains <substr>
+  tap-xy <x> <y>
+  has-id <prefix>              exit 0 if present
+  has-text <substr>            exit 0 if present
+  wait-id <prefix> [secs]      poll until present (exit 1 on timeout)
+  wait-text <substr> [secs]
+  wait-no-text <substr> [secs] poll until absent
+  count-text <substr>          print how many nodes contain <substr>
+  texts                        print all visible texts, top to bottom
+  type <text>                  type into the focused field (spaces supported)
+  key <keycode>
+  swipe <x1> <y1> <x2> <y2> [ms]
+  shot <path>                  screenshot to a local PNG
+"""
+import os
+import re
+import shutil
+import subprocess
+import sys
+import time
+import xml.etree.ElementTree as ET
+
+ADB = shutil.which('adb') or os.path.expanduser('~/Library/Android/sdk/platform-tools/adb')
+
+
+def adb(serial, *args, check=True, timeout=None):
+    return subprocess.run([ADB, '-s', serial, *args], capture_output=True, text=True, check=check, timeout=timeout)
+
+
+def dump_nodes(serial):
+    remote = f'/sdcard/ui-{int(time.time() * 1000)}.xml'
+    local = f'/tmp/ui-{serial}.xml'
+    if os.path.exists(local):
+        os.remove(local)
+    for _ in range(6):
+        adb(serial, 'shell', 'rm', '-f', remote, check=False)
+        try:
+            out = adb(serial, 'shell', 'uiautomator', 'dump', remote, check=False, timeout=25)
+        except subprocess.TimeoutExpired:
+            # a dump that waits forever for an idle UI: kill it on the device and retry
+            adb(serial, 'shell', 'pkill', '-f', 'uiautomator', check=False)
+            time.sleep(1)
+            continue
+        if 'dumped to' in (out.stdout + out.stderr):
+            adb(serial, 'pull', remote, local, check=False)
+            adb(serial, 'shell', 'rm', '-f', remote, check=False)
+            if os.path.exists(local) and os.path.getsize(local) > 0:
+                break
+        time.sleep(0.7)
+    else:
+        raise RuntimeError('uiautomator dump failed (screen animating?)')
+    root = ET.parse(local).getroot()
+    nodes = []
+    for n in root.iter('node'):
+        b = re.findall(r'\d+', n.get('bounds', '[0,0][0,0]'))
+        x1, y1, x2, y2 = map(int, b)
+        if x2 <= x1 or y2 <= y1:
+            continue
+        nodes.append({
+            'text': n.get('text', ''),
+            'id': n.get('resource-id', ''),
+            'desc': n.get('content-desc', ''),
+            'bounds': (x1, y1, x2, y2),
+            'clickable': n.get('clickable') == 'true',
+        })
+    return nodes
+
+
+def center(node):
+    x1, y1, x2, y2 = node['bounds']
+    return (x1 + x2) // 2, (y1 + y2) // 2
+
+
+def by_id(nodes, prefix):
+    return [n for n in nodes if n['id'].startswith(prefix)]
+
+
+def by_text(nodes, sub):
+    return [n for n in nodes if sub in n['text'] or sub in n['desc']]
+
+
+def tap(serial, x, y):
+    adb(serial, 'shell', 'input', 'tap', str(x), str(y))
+
+
+def wait(serial, pred, secs):
+    deadline = time.time() + secs
+    while time.time() < deadline:
+        try:
+            if pred(dump_nodes(serial)):
+                return True
+        except RuntimeError:
+            pass
+        time.sleep(0.8)
+    return False
+
+
+def main():
+    serial, cmd, *args = sys.argv[1:]
+    if cmd == 'dump':
+        for n in dump_nodes(serial):
+            if n['text'] or n['id'] or n['desc']:
+                print(f"{n['bounds']} id={n['id']!r} text={n['text']!r} desc={n['desc']!r}")
+    elif cmd == 'texts':
+        nodes = sorted(dump_nodes(serial), key=lambda n: (n['bounds'][1], n['bounds'][0]))
+        for n in nodes:
+            if n['text']:
+                print(f"y={n['bounds'][1]:>5} {n['text']}")
+    elif cmd == 'tap-id':
+        idx = int(args[1]) if len(args) > 1 else 0
+        found = by_id(dump_nodes(serial), args[0])
+        if len(found) <= idx:
+            sys.exit(f'no node with id prefix {args[0]!r} (found {len(found)})')
+        tap(serial, *center(found[idx]))
+    elif cmd == 'tap-text':
+        idx = int(args[1]) if len(args) > 1 else 0
+        found = by_text(dump_nodes(serial), args[0])
+        if len(found) <= idx:
+            sys.exit(f'no node with text {args[0]!r} (found {len(found)})')
+        tap(serial, *center(found[idx]))
+    elif cmd == 'tap-exact':
+        # exact text match; with several matches, the lowest one on screen (bottom tabs) unless an index is given
+        found = [n for n in dump_nodes(serial) if n['text'] == args[0] or n['desc'] == args[0]]
+        if not found:
+            sys.exit(f'no node with exact text {args[0]!r}')
+        found.sort(key=lambda n: n['bounds'][1])
+        tap(serial, *center(found[int(args[1])] if len(args) > 1 else found[-1]))
+    elif cmd == 'longpress-text':
+        # the LAST (lowest on screen) exact-text match, i.e. the newest message with that text
+        found = [n for n in dump_nodes(serial) if n['text'] == args[0]]
+        if not found:
+            sys.exit(f'no node with exact text {args[0]!r}')
+        found.sort(key=lambda n: n['bounds'][1])
+        x, y = center(found[-1])
+        adb(serial, 'shell', 'input', 'swipe', str(x), str(y), str(x), str(y), '900')
+    elif cmd == 'tap-xy':
+        tap(serial, int(args[0]), int(args[1]))
+    elif cmd == 'has-id':
+        sys.exit(0 if by_id(dump_nodes(serial), args[0]) else 1)
+    elif cmd == 'has-text':
+        sys.exit(0 if by_text(dump_nodes(serial), args[0]) else 1)
+    elif cmd == 'wait-id':
+        secs = float(args[1]) if len(args) > 1 else 30
+        sys.exit(0 if wait(serial, lambda ns: by_id(ns, args[0]), secs) else 1)
+    elif cmd == 'wait-text':
+        secs = float(args[1]) if len(args) > 1 else 30
+        sys.exit(0 if wait(serial, lambda ns: by_text(ns, args[0]), secs) else 1)
+    elif cmd == 'wait-no-text':
+        secs = float(args[1]) if len(args) > 1 else 30
+        sys.exit(0 if wait(serial, lambda ns: not by_text(ns, args[0]), secs) else 1)
+    elif cmd == 'count-text':
+        print(len(by_text(dump_nodes(serial), args[0])))
+    elif cmd == 'type':
+        text = ' '.join(args).replace(' ', '%s')
+        adb(serial, 'shell', 'input', 'text', text)
+    elif cmd == 'key':
+        adb(serial, 'shell', 'input', 'keyevent', args[0])
+    elif cmd == 'swipe':
+        ms = args[4] if len(args) > 4 else '300'
+        adb(serial, 'shell', 'input', 'swipe', *args[:4], ms)
+    elif cmd == 'shot':
+        with open(args[0], 'wb') as f:
+            f.write(subprocess.run([ADB, '-s', serial, 'exec-out', 'screencap', '-p'],
+                                   capture_output=True, check=True).stdout)
+    else:
+        sys.exit(f'unknown command {cmd}')
+
+
+if __name__ == '__main__':
+    main()