diff --git a/FabricExample/package.json b/FabricExample/package.json
index 5a3fde26e1..32fc649f36 100644
--- a/FabricExample/package.json
+++ b/FabricExample/package.json
@@ -13,6 +13,7 @@
   },
   "dependencies": {
     "@gorhom/bottom-sheet": "5.2.6",
+    "@legendapp/list": "3.0.0-beta.32",
     "@lottiefiles/dotlottie-react": "^0.17.10",
     "@react-native-community/blur": "^4.4.1",
     "@react-native-masked-view/masked-view": "^0.3.2",
@@ -36,7 +37,8 @@
     "react-native-toast-message": "^2.3.0",
     "react-native-web": "^0.21.2",
     "react-native-webview": "^13.16.0",
-    "react-native-worklets": "^0.7.1"
+    "react-native-worklets": "^0.7.1",
+    "zustand": "^5.0.10"
   },
   "devDependencies": {
     "@babel/core": "^7.25.2",
@@ -88,5 +90,10 @@
   },
   "engines": {
     "node": ">=20"
+  },
+  "reanimated": {
+    "staticFeatureFlags": {
+      "USE_COMMIT_HOOK_ONLY_FOR_REACT_COMMITS": true
+    }
   }
 }
diff --git a/FabricExample/src/constants/screenNames.ts b/FabricExample/src/constants/screenNames.ts
index 7f50da4c13..4b3370632a 100644
--- a/FabricExample/src/constants/screenNames.ts
+++ b/FabricExample/src/constants/screenNames.ts
@@ -27,4 +27,5 @@ export enum ScreenNames {
   LIQUID_KEYBOARD = "LIQUID_KEYBOARD",
   KEYBOARD_SHARED_TRANSITIONS = "KEYBOARD_SHARED_TRANSITIONS",
   KEYBOARD_EXTENDER = "KEYBOARD_EXTENDER",
+  CHAT_KIT = "CHAT_KIT",
 }
diff --git a/FabricExample/src/navigation/ExamplesStack/index.tsx b/FabricExample/src/navigation/ExamplesStack/index.tsx
index 208e17ee95..1ee1fcc6b9 100644
--- a/FabricExample/src/navigation/ExamplesStack/index.tsx
+++ b/FabricExample/src/navigation/ExamplesStack/index.tsx
@@ -13,6 +13,7 @@ import InteractiveKeyboard from "../../screens/Examples/InteractiveKeyboard";
 import InteractiveKeyboardIOS from "../../screens/Examples/InteractiveKeyboardIOS";
 import KeyboardAnimation from "../../screens/Examples/KeyboardAnimation";
 import KeyboardAvoidingViewExample from "../../screens/Examples/KeyboardAvoidingView";
+import KeyboardChatScrollViewPlayground from "../../screens/Examples/KeyboardChatScrollView";
 import KeyboardExtender from "../../screens/Examples/KeyboardExtender";
 import KeyboardSharedTransitionExample from "../../screens/Examples/KeyboardSharedTransitions";
 import UseKeyboardState from "../../screens/Examples/KeyboardStateHook";
@@ -54,6 +55,7 @@ export type ExamplesStackParamList = {
   [ScreenNames.LIQUID_KEYBOARD]: undefined;
   [ScreenNames.KEYBOARD_SHARED_TRANSITIONS]: undefined;
   [ScreenNames.KEYBOARD_EXTENDER]: undefined;
+  [ScreenNames.CHAT_KIT]: undefined;
 };
 
 const Stack = createStackNavigator<ExamplesStackParamList>();
@@ -138,6 +140,14 @@ const options = {
     title: "Keyboard Extender",
     headerShown: false,
   },
+  [ScreenNames.CHAT_KIT]: {
+    title: "Chat Kit",
+    headerTintColor: "#fff",
+    headerStyle: {
+      backgroundColor: "#3A3A3C",
+    },
+    headerBackTitle: "Back",
+  },
 };
 
 const ExamplesStack = () => (
@@ -267,6 +277,11 @@ const ExamplesStack = () => (
       name={ScreenNames.KEYBOARD_EXTENDER}
       options={options[ScreenNames.KEYBOARD_EXTENDER]}
     />
+    <Stack.Screen
+      component={KeyboardChatScrollViewPlayground}
+      name={ScreenNames.CHAT_KIT}
+      options={options[ScreenNames.CHAT_KIT]}
+    />
   </Stack.Navigator>
 );
 
diff --git a/FabricExample/src/screens/Examples/KeyboardChatScrollView/VirtualizedListScrollView.tsx b/FabricExample/src/screens/Examples/KeyboardChatScrollView/VirtualizedListScrollView.tsx
new file mode 100644
index 0000000000..d84487c12a
--- /dev/null
+++ b/FabricExample/src/screens/Examples/KeyboardChatScrollView/VirtualizedListScrollView.tsx
@@ -0,0 +1,83 @@
+import React, { forwardRef, useCallback, useMemo, useState } from "react";
+import {
+  type LayoutChangeEvent,
+  type ScrollViewProps,
+  StyleSheet,
+  Text,
+} from "react-native";
+import { KeyboardChatScrollView } from "react-native-keyboard-controller";
+import { useSafeAreaInsets } from "react-native-safe-area-context";
+
+import { useChatConfigStore } from "./store";
+import { MARGIN, TEXT_INPUT_HEIGHT } from "./styles";
+
+export type VirtualizedListScrollViewRef = React.ElementRef<
+  typeof KeyboardChatScrollView
+>;
+
+const VirtualizedListScrollView = forwardRef<
+  VirtualizedListScrollViewRef,
+  ScrollViewProps
+>(({ onLayout: onLayoutProp, ...props }, ref) => {
+  const [layoutPass, setLayoutPass] = useState(0);
+  const { bottom } = useSafeAreaInsets();
+  const chatKitOffset = bottom - MARGIN;
+
+  const { inverted, freeze, mode, keyboardLiftBehavior } = useChatConfigStore();
+
+  const contentContainerStyle = useMemo(
+    () => ({ paddingBottom: TEXT_INPUT_HEIGHT + MARGIN }),
+    [],
+  );
+  const invertedContentContainerStyle = useMemo(
+    () => ({ paddingTop: TEXT_INPUT_HEIGHT + MARGIN }),
+    [],
+  );
+  // on new arch only FlatList supports `inverted` prop
+  const isInvertedSupported = inverted && mode === "flat" ? inverted : false;
+  const onLayout = useCallback(
+    (e: LayoutChangeEvent) => {
+      setLayoutPass((l) => l + 1);
+      onLayoutProp?.(e);
+    },
+    [onLayoutProp],
+  );
+
+  return (
+    <>
+      <KeyboardChatScrollView
+        ref={ref}
+        automaticallyAdjustContentInsets={false}
+        contentContainerStyle={
+          isInvertedSupported
+            ? invertedContentContainerStyle
+            : contentContainerStyle
+        }
+        contentInsetAdjustmentBehavior="never"
+        freeze={freeze}
+        inverted={isInvertedSupported}
+        keyboardDismissMode="interactive"
+        keyboardLiftBehavior={keyboardLiftBehavior}
+        offset={chatKitOffset}
+        testID="chat.scroll"
+        onLayout={onLayout}
+        {...props}
+      />
+      <Text style={styles.counter} testID="layout_passes">
+        Layout pass: {layoutPass}
+      </Text>
+    </>
+  );
+});
+
+const styles = StyleSheet.create({
+  counter: {
+    position: "absolute",
+    color: "white",
+    top: 0,
+    padding: 12,
+    backgroundColor: "#3c3c3c",
+  },
+});
+
+export default VirtualizedListScrollView;
diff --git a/FabricExample/src/screens/Examples/KeyboardChatScrollView/components/Message.tsx b/FabricExample/src/screens/Examples/KeyboardChatScrollView/components/Message.tsx
new file mode 100644
index 0000000000..7d31f7940d
--- /dev/null
+++ b/FabricExample/src/screens/Examples/KeyboardChatScrollView/components/Message.tsx
@@ -0,0 +1,39 @@
+import React from "react";
+import { StyleSheet, Text, View } from "react-native";
+
+import type { MessageProps } from "../../../../components/Message/types";
+
+/**
+ * Fork of original Message component. Created in order not to break existing e2e tests (requires assets re-generation).
+ */
+export default function Message({ text, sender }: MessageProps) {
+  return (
+    <View style={sender ? styles.senderContainer : styles.recipientContainer}>
+      <Text style={styles.message}>{text}</Text>
+    </View>
+  );
+}
+
+const container = {
+  borderRadius: 10,
+  padding: 10,
+  margin: 10,
+  marginVertical: 5,
+  maxWidth: "80%" as const,
+};
+
+const styles = StyleSheet.create({
+  senderContainer: {
+    alignSelf: "flex-end",
+    backgroundColor: "#F8F8FC",
+    ...container,
+  },
+  recipientContainer: {
+    alignSelf: "flex-start",
+    backgroundColor: "#64D2FF",
+    ...container,
+  },
+  message: {
+    color: "#000000",
+  },
+});
diff --git a/FabricExample/src/screens/Examples/KeyboardChatScrollView/config.tsx b/FabricExample/src/screens/Examples/KeyboardChatScrollView/config.tsx
new file mode 100644
index 0000000000..df71884789
--- /dev/null
+++ b/FabricExample/src/screens/Examples/KeyboardChatScrollView/config.tsx
@@ -0,0 +1,166 @@
+import BottomSheet, { BottomSheetView } from "@gorhom/bottom-sheet";
+import { useNavigation } from "@react-navigation/native";
+import React, { useCallback, useEffect, useRef } from "react";
+import { Button, StyleSheet, Text, TouchableOpacity, View } from "react-native";
+import { KeyboardController } from "react-native-keyboard-controller";
+
+import Switch from "../../../components/Switch";
+
+import { useChatConfigStore } from "./store";
+
+function ConfigSheet() {
+  const navigation = useNavigation();
+  const bottomSheetModalRef = useRef<BottomSheet>(null);
+  const inverted = useChatConfigStore((state) => state.inverted);
+  const setInverted = useChatConfigStore((state) => state.setInverted);
+  const beginning = useChatConfigStore((state) => state.beginning);
+  const setBeginning = useChatConfigStore((state) => state.setBeginning);
+  const setFreeze = useChatConfigStore((state) => state.setFreeze);
+  const mode = useChatConfigStore((state) => state.mode);
+  const setMode = useChatConfigStore((state) => state.setMode);
+  const keyboardLiftBehavior = useChatConfigStore(
+    (state) => state.keyboardLiftBehavior,
+  );
+  const nextLiftBehavior = useChatConfigStore(
+    (state) => state.nextLiftBehavior,
+  );
+
+  const handlePresentModalPress = useCallback(async () => {
+    setFreeze(true);
+    requestAnimationFrame(async () => {
+      await KeyboardController.dismiss({ keepFocus: true });
+      bottomSheetModalRef.current?.expand();
+    });
+  }, [setFreeze]);
+
+  const handleSheetChange = useCallback(
+    (index: number) => {
+      if (index < 0) {
+        setFreeze(false);
+        KeyboardController.setFocusTo("current");
+      }
+    },
+    [setFreeze],
+  );
+
+  useEffect(() => {
+    navigation.setOptions({
+      headerRight: () => (
+        <Text
+          style={styles.header}
+          testID="open_bottom_sheet_modal"
+          onPress={handlePresentModalPress}
+        >
+          Open config
+        </Text>
+      ),
+    });
+  }, [navigation]);
+
+  return (
+    <BottomSheet
+      ref={bottomSheetModalRef}
+      index={-1}
+      snapPoints={["50%"]}
+      onChange={handleSheetChange}
+    >
+      <BottomSheetView style={styles.bottomSheetContent}>
+        <Button
+          testID="bottom_sheet_close_modal"
+          title="Close modal"
+          onPress={() => bottomSheetModalRef.current?.close()}
+        />
+        <View style={styles.switchContainer}>
+          <Text style={styles.text}>Toggle inverted</Text>
+          <Switch
+            testID="bottom_sheet_toggle_inverted_state"
+            value={inverted}
+            onChange={() => {
+              setInverted(!inverted);
+            }}
+          />
+        </View>
+        <View style={styles.switchContainer}>
+          <Text style={styles.text}>Toggle beginning</Text>
+          <Switch
+            testID="bottom_sheet_toggle_beginning_state"
+            value={beginning}
+            onChange={() => {
+              setBeginning(!beginning);
+            }}
+          />
+        </View>
+        <View style={styles.switchContainer}>
+          <Text style={styles.text}>Use Scroll View</Text>
+          <Switch
+            testID="bottom_sheet_toggle_scroll_view_list_state"
+            value={mode === "scroll"}
+            onChange={() => {
+              setMode("scroll");
+            }}
+          />
+        </View>
+        <View style={styles.switchContainer}>
+          <Text style={styles.text}>Use Flat List</Text>
+          <Switch
+            testID="bottom_sheet_toggle_flat_list_state"
+            value={mode === "flat"}
+            onChange={() => {
+              setMode("flat");
+            }}
+          />
+        </View>
+        <View style={styles.switchContainer}>
+          <Text style={styles.text}>Use Flash List</Text>
+          <Switch
+            testID="bottom_sheet_toggle_flash_list_state"
+            value={mode === "flash"}
+            onChange={() => {
+              setMode("flash");
+            }}
+          />
+        </View>
+        <View style={styles.switchContainer}>
+          <Text style={styles.text}>Use Legend List</Text>
+          <Switch
+            testID="bottom_sheet_toggle_legend_list_state"
+            value={mode === "legend"}
+            onChange={() => {
+              setMode("legend");
+            }}
+          />
+        </View>
+        <View style={styles.switchContainer}>
+          <Text style={styles.text}>Lifting mode</Text>
+          <TouchableOpacity
+            testID="bottom_sheet_next_keyboard_lift_behavior"
+            onPress={nextLiftBehavior}
+          >
+            <Text style={styles.text}>{keyboardLiftBehavior}</Text>
+          </TouchableOpacity>
+        </View>
+      </BottomSheetView>
+    </BottomSheet>
+  );
+}
+
+const styles = StyleSheet.create({
+  header: {
+    color: "white",
+    paddingRight: 12,
+  },
+  bottomSheetContent: {
+    flex: 1,
+  },
+  switchContainer: {
+    flexDirection: "row",
+    justifyContent: "space-between",
+    alignItems: "center",
+    margin: 16,
+  },
+  text: {
+    color: "black",
+  },
+});
+
+export default ConfigSheet;
diff --git a/FabricExample/src/screens/Examples/KeyboardChatScrollView/data.ts b/FabricExample/src/screens/Examples/KeyboardChatScrollView/data.ts
new file mode 100644
index 0000000000..71c6503d8f
--- /dev/null
+++ b/FabricExample/src/screens/Examples/KeyboardChatScrollView/data.ts
@@ -0,0 +1,25 @@
+import { history } from "../../../components/Message/data";
+
+export const messages = [
+  ...history,
+  // continue dialog further
+  { text: "Do you any other questions?", sender: true },
+  { text: "Yes, I have a question about teleport library" },
+  { text: "Do you know anything about it?", sender: true },
+  {
+    text: "I have seen some techno demos, but haven't tried it uet",
+    sender: true,
+  },
+  { text: "Yes, I already tried it in my project" },
+  {
+    text: "It's pretty cool. We were able to built gallery with share element transitions without any flickering or any other issues",
+    sender: true,
+  },
+  { text: "So far it looks cool!", sender: true },
+  { text: "And seems to be pretty stable", sender: true },
+  {
+    text: "This is a literally missing 'move' operation in react/react-native. Before we could only create/delete elements, but now you get power of zero-overhead 'move' operation and it can bring your app performance on the next level and also significantly boost your app UI cause it unlocks the power that we didn't have before",
+  },
+  { text: "Wow! That's awesome!" },
+  { text: "Yes! Totally agree!", sender: true },
+];
diff --git a/FabricExample/src/screens/Examples/KeyboardChatScrollView/index.tsx b/FabricExample/src/screens/Examples/KeyboardChatScrollView/index.tsx
new file mode 100644
index 0000000000..7a45c11851
--- /dev/null
+++ b/FabricExample/src/screens/Examples/KeyboardChatScrollView/index.tsx
@@ -0,0 +1,175 @@
+import { LegendList, type LegendListRef } from "@legendapp/list";
+import { FlashList, type FlashListRef } from "@shopify/flash-list";
+import React, {
+  useCallback,
+  useEffect,
+  useMemo,
+  useRef,
+  useState,
+} from "react";
+import {
+  FlatList,
+  Image,
+  StyleSheet,
+  TextInput,
+  TouchableOpacity,
+  View,
+} from "react-native";
+import {
+  KeyboardGestureArea,
+  KeyboardStickyView,
+} from "react-native-keyboard-controller";
+import {
+  SafeAreaView,
+  useSafeAreaInsets,
+} from "react-native-safe-area-context";
+
+import BlurView from "../../../components/BlurView";
+
+import Message from "./components/Message";
+import ConfigSheet from "./config";
+import { useChatConfigStore } from "./store";
+import styles, { MARGIN, TEXT_INPUT_HEIGHT } from "./styles";
+import VirtualizedListScrollView, {
+  type VirtualizedListScrollViewRef,
+} from "./VirtualizedListScrollView";
+
+import type { MessageProps } from "../../../components/Message/types";
+import type { LayoutChangeEvent, ScrollViewProps } from "react-native";
+
+function KeyboardChatScrollViewPlayground() {
+  const legendRef = useRef<LegendListRef>(null);
+  const flashRef = useRef<FlashListRef<MessageProps>>(null);
+  const flatRef = useRef<FlatList<MessageProps>>(null);
+  const scrollRef = useRef<VirtualizedListScrollViewRef>(null);
+  const textInputRef = useRef<TextInput>(null);
+  const textRef = useRef("");
+  const [inputHeight, setInputHeight] = useState(TEXT_INPUT_HEIGHT);
+  const { inverted, messages, reversedMessages, addMessage, mode } =
+    useChatConfigStore();
+  const { bottom } = useSafeAreaInsets();
+
+  const stickyViewOffset = useMemo(
+    () => ({ opened: bottom - MARGIN }),
+    [bottom],
+  );
+
+  const onInputLayoutChanged = useCallback((e: LayoutChangeEvent) => {
+    setInputHeight(e.nativeEvent.layout.height);
+  }, []);
+  const onInput = useCallback((text: string) => {
+    textRef.current = text;
+  }, []);
+  const onSend = useCallback(() => {
+    const message = textRef.current.trim();
+
+    if (message === "") {
+      return;
+    }
+
+    addMessage({ text: message, sender: true });
+    textInputRef.current?.clear();
+    textRef.current = "";
+  }, [addMessage]);
+
+  useEffect(() => {
+    legendRef.current?.scrollToOffset({
+      animated: true,
+      offset: Number.MAX_SAFE_INTEGER,
+    });
+    flashRef.current?.scrollToEnd({ animated: true });
+    flatRef.current?.scrollToOffset({
+      animated: true,
+      offset: Number.MAX_SAFE_INTEGER,
+    });
+    scrollRef.current?.scrollToEnd({ animated: true });
+  }, [messages]);
+
+  const memoList = useCallback(
+    (props: ScrollViewProps) => <VirtualizedListScrollView {...props} />,
+    [],
+  );
+
+  return (
+    <SafeAreaView edges={["bottom"]} style={styles.container}>
+      <KeyboardGestureArea
+        interpolator="ios"
+        offset={inputHeight}
+        style={styles.container}
+        textInputNativeID="chat-input"
+      >
+        {mode === "legend" && (
+          <LegendList
+            ref={legendRef}
+            alignItemsAtEnd={inverted}
+            data={messages}
+            initialScrollAtEnd={inverted}
+            keyExtractor={(item) => item.text}
+            renderItem={({ item }) => <Message {...item} />}
+            renderScrollComponent={memoList}
+          />
+        )}
+        {mode === "flash" && (
+          <FlashList
+            ref={flashRef}
+            data={messages}
+            keyExtractor={(item) => item.text}
+            maintainVisibleContentPosition={{
+              startRenderingFromBottom: inverted,
+            }}
+            renderItem={({ item }) => <Message {...item} />}
+            renderScrollComponent={VirtualizedListScrollView}
+          />
+        )}
+        {mode === "flat" && (
+          <FlatList
+            ref={flatRef}
+            data={inverted ? reversedMessages : messages}
+            inverted={inverted}
+            keyExtractor={(item) => item.text}
+            renderItem={({ item }) => <Message {...item} />}
+            renderScrollComponent={memoList}
+          />
+        )}
+        {mode === "scroll" && (
+          <VirtualizedListScrollView ref={scrollRef}>
+            {messages.map((message, index) => (
+              <Message key={index} {...message} />
+            ))}
+          </VirtualizedListScrollView>
+        )}
+        <KeyboardStickyView offset={stickyViewOffset} style={styles.composer}>
+          <View
+            style={[
+              StyleSheet.absoluteFillObject,
+              { overflow: "hidden" },
+              styles.input,
+            ]}
+          >
+            <BlurView
+              blurAmount={32}
+              blurType="light"
+              reducedTransparencyFallbackColor="white"
+              style={StyleSheet.absoluteFillObject}
+            />
+          </View>
+          <TextInput
+            ref={textInputRef}
+            multiline
+            nativeID="chat-input"
+            style={styles.input}
+            testID="chat.input"
+            onChangeText={onInput}
+            onLayout={onInputLayoutChanged}
+          />
+          <TouchableOpacity style={styles.send} onPress={onSend}>
+            <Image source={require("./send.png")} style={styles.icon} />
+          </TouchableOpacity>
+        </KeyboardStickyView>
+      </KeyboardGestureArea>
+      <ConfigSheet />
+    </SafeAreaView>
+  );
+}
+
+export default KeyboardChatScrollViewPlayground;
diff --git a/FabricExample/src/screens/Examples/KeyboardChatScrollView/send.png b/FabricExample/src/screens/Examples/KeyboardChatScrollView/send.png
new file mode 100644
index 0000000000..93aec6092a
Binary files /dev/null and b/FabricExample/src/screens/Examples/KeyboardChatScrollView/send.png differ
diff --git a/FabricExample/src/screens/Examples/KeyboardChatScrollView/store.ts b/FabricExample/src/screens/Examples/KeyboardChatScrollView/store.ts
new file mode 100644
index 0000000000..d8ff348956
--- /dev/null
+++ b/FabricExample/src/screens/Examples/KeyboardChatScrollView/store.ts
@@ -0,0 +1,81 @@
+import { create } from "zustand";
+
+import { messages as initialMessages } from "./data";
+
+import type { MessageProps } from "../../../components/Message/types";
+import type { KeyboardChatScrollViewProps } from "react-native-keyboard-controller";
+
+type ListMode = "scroll" | "flat" | "flash" | "legend";
+
+const liftModes: KeyboardChatScrollViewProps["keyboardLiftBehavior"][] = [
+  "always",
+  "whenAtEnd",
+  "persistent",
+  "never",
+];
+
+interface ChatConfigStore {
+  inverted: boolean;
+  setInverted: (inverted: boolean) => void;
+  beginning: boolean;
+  setBeginning: (beginning: boolean) => void;
+  freeze: boolean;
+  setFreeze: (freeze: boolean) => void;
+  messages: MessageProps[];
+  reversedMessages: MessageProps[];
+  setMessages: (messages: MessageProps[]) => void;
+  addMessage: (message: MessageProps) => void;
+  mode: ListMode;
+  setMode: (mode: ListMode) => void;
+  resetMessages: () => void;
+  keyboardLiftBehavior: KeyboardChatScrollViewProps["keyboardLiftBehavior"];
+  nextLiftBehavior: () => void;
+}
+
+export const useChatConfigStore = create<ChatConfigStore>((set, get) => ({
+  inverted: false,
+  setInverted: (inverted) => set({ inverted }),
+  freeze: false,
+  setFreeze: (freeze) => set({ freeze }),
+  beginning: false,
+  setBeginning: (beginning) => {
+    set(() => {
+      const newMessages = beginning ? [initialMessages[0]] : initialMessages;
+
+      return {
+        beginning,
+        messages: newMessages,
+        reversedMessages: [...newMessages].reverse(),
+      };
+    });
+  },
+  messages: initialMessages,
+  reversedMessages: [...initialMessages].reverse(),
+  setMessages: (messages) =>
+    set({ messages, reversedMessages: [...messages].reverse() }),
+  addMessage: (message) =>
+    set((state) => {
+      const newMessages = [...state.messages, message];
+
+      return {
+        messages: newMessages,
+        reversedMessages: [...newMessages].reverse(),
+      };
+    }),
+  mode: "scroll",
+  setMode: (mode) => set({ mode }),
+  resetMessages: () =>
+    set({
+      messages: initialMessages,
+      reversedMessages: [...initialMessages].reverse(),
+    }),
+  keyboardLiftBehavior: "always",
+  nextLiftBehavior: () => {
+    const idx = liftModes.indexOf(get().keyboardLiftBehavior);
+
+    set({
+      keyboardLiftBehavior:
+        liftModes[idx === liftModes.length - 1 ? 0 : idx + 1],
+    });
+  },
+}));
diff --git a/FabricExample/src/screens/Examples/KeyboardChatScrollView/styles.ts b/FabricExample/src/screens/Examples/KeyboardChatScrollView/styles.ts
new file mode 100644
index 0000000000..facb2c5cae
--- /dev/null
+++ b/FabricExample/src/screens/Examples/KeyboardChatScrollView/styles.ts
@@ -0,0 +1,44 @@
+import { StyleSheet } from "react-native";
+
+export const TEXT_INPUT_HEIGHT = 50;
+
+export const MARGIN = 16;
+
+export default StyleSheet.create({
+  container: {
+    justifyContent: "flex-end",
+    flex: 1,
+    backgroundColor: "#3A3A3C",
+  },
+  input: {
+    flex: 1,
+    margin: MARGIN,
+    marginBottom: 0,
+    padding: MARGIN,
+    borderRadius: 99,
+    borderWidth: 1,
+    borderColor: "#BCBCBC",
+    backgroundColor: "#3A3A3C66",
+  },
+  composer: {
+    position: "absolute",
+    width: "100%",
+    minHeight: TEXT_INPUT_HEIGHT,
+  },
+  send: {
+    position: "absolute",
+    top: MARGIN + (TEXT_INPUT_HEIGHT - MARGIN * 2) / 2,
+    right: MARGIN * 2,
+    padding: MARGIN,
+    backgroundColor: "white",
+    height: 24,
+    width: 24,
+    alignItems: "center",
+    justifyContent: "center",
+    borderRadius: 99,
+  },
+  icon: {
+    width: 20,
+    height: 20,
+  },
+});
diff --git a/FabricExample/src/screens/Examples/Main/constants.ts b/FabricExample/src/screens/Examples/Main/constants.ts
index b9cd7f6aab..e8d6dd5a82 100644
--- a/FabricExample/src/screens/Examples/Main/constants.ts
+++ b/FabricExample/src/screens/Examples/Main/constants.ts
@@ -153,4 +153,10 @@ export const examples: Example[] = [
     info: ScreenNames.KEYBOARD_EXTENDER,
     icons: "🧩",
   },
+  {
+    title: "Chat Kit",
+    testID: "chat_kit",
+    info: ScreenNames.CHAT_KIT,
+    icons: "🛠 💬",
+  },
 ];
diff --git a/FabricExample/yarn.lock b/FabricExample/yarn.lock
index 535e1285ab..78f94c6731 100644
--- a/FabricExample/yarn.lock
+++ b/FabricExample/yarn.lock
@@ -1462,6 +1462,13 @@
     "@jsonjoy.com/buffers" "^1.0.0"
     "@jsonjoy.com/codegen" "^1.0.0"
 
+"@legendapp/list@3.0.0-beta.32":
+  version "3.0.0-beta.32"
+  resolved "https://registry.yarnpkg.com/@legendapp/list/-/list-3.0.0-beta.32.tgz#33a08df134d103e7ae1920ca8385cb59323cd42b"
+  integrity sha512-lWIdQ1Z3IrR5Iv7I3qOLDYk9Uh/gc03wITNEObTpR2tIYNvgDibOL/3yAznyvkQMuwl3TLquan46Zo0t/XdmIA==
+  dependencies:
+    use-sync-external-store "^1.5.0"
+
 "@leichtgewicht/ip-codec@^2.0.1":
   version "2.0.5"
   resolved "https://registry.yarnpkg.com/@leichtgewicht/ip-codec/-/ip-codec-2.0.5.tgz#4fc56c15c580b9adb7dc3c333a134e540b44bfb1"
@@ -7382,3 +7389,8 @@ yocto-queue@^0.1.0:
   version "0.1.0"
   resolved "https://registry.yarnpkg.com/yocto-queue/-/yocto-queue-0.1.0.tgz#0294eb3dee05028d31ee1a5fa2c556a6aaf10a1b"
   integrity sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==
+
+zustand@^5.0.10:
+  version "5.0.10"
+  resolved "https://registry.yarnpkg.com/zustand/-/zustand-5.0.10.tgz#4db510c0c4c25a5f1ae43227b307ddf1641a3210"
+  integrity sha512-U1AiltS1O9hSy3rul+Ub82ut2fqIAefiSuwECWt6jlMVUGejvf+5omLcRBSzqbRagSM3hQZbtzdeRc6QVScXTg==
diff --git a/android/src/fabric/java/com/reactnativekeyboardcontroller/ClippingScrollViewDecoratorViewManager.kt b/android/src/fabric/java/com/reactnativekeyboardcontroller/ClippingScrollViewDecoratorViewManager.kt
index 9992d906ac..8bce1384eb 100644
--- a/android/src/fabric/java/com/reactnativekeyboardcontroller/ClippingScrollViewDecoratorViewManager.kt
+++ b/android/src/fabric/java/com/reactnativekeyboardcontroller/ClippingScrollViewDecoratorViewManager.kt
@@ -27,4 +27,11 @@ class ClippingScrollViewDecoratorViewManager :
   ) {
     view?.setContentInsetBottom(value)
   }
+
+  override fun setContentInsetTop(
+    view: ClippingScrollViewDecoratorView?,
+    value: Double,
+  ) {
+    view?.setContentInsetTop(value)
+  }
 }
diff --git a/android/src/main/java/com/reactnativekeyboardcontroller/views/ClippingScrollViewDecoratorView.kt b/android/src/main/java/com/reactnativekeyboardcontroller/views/ClippingScrollViewDecoratorView.kt
index dcfaa37e4c..2abfb02618 100644
--- a/android/src/main/java/com/reactnativekeyboardcontroller/views/ClippingScrollViewDecoratorView.kt
+++ b/android/src/main/java/com/reactnativekeyboardcontroller/views/ClippingScrollViewDecoratorView.kt
@@ -1,6 +1,7 @@
 package com.reactnativekeyboardcontroller.views
 
 import android.annotation.SuppressLint
+import android.view.ViewGroup
 import android.widget.ScrollView
 import com.facebook.react.uimanager.ThemedReactContext
 import com.facebook.react.views.view.ReactViewGroup
@@ -11,6 +12,8 @@ class ClippingScrollViewDecoratorView(
   val reactContext: ThemedReactContext,
 ) : ReactViewGroup(reactContext) {
   private var insetBottom = 0.0
+  private var insetTop = 0.0
+  private var appliedTopInsetPx = 0
 
   override fun onAttachedToWindow() {
     super.onAttachedToWindow()
@@ -23,15 +26,39 @@ class ClippingScrollViewDecoratorView(
     decorateScrollView()
   }
 
+  fun setContentInsetTop(value: Double) {
+    insetTop = value
+    decorateScrollView()
+  }
+
   private fun decorateScrollView() {
     val scrollView = getChildAt(0) as? ScrollView ?: return
 
     scrollView.clipToPadding = false
+
+    val newTopInsetPx = insetTop.toFloat().px.toInt()
+
+    // Translate the content view as a whole — this keeps FlatList's
+    // virtualizer calculations correct (it reads layout positions,
+    // not translationY).
+    val contentView = scrollView.getChildAt(0) as? ViewGroup ?: return
+    (contentView.getChildAt(0) as? ViewGroup)?.translationY = newTopInsetPx.toFloat()
+
     scrollView.setPadding(
       scrollView.paddingLeft,
       scrollView.paddingTop,
       scrollView.paddingRight,
-      insetBottom.toFloat().px.toInt(),
+      // pass accumulated value — visually both top and bottom insets
+      // extend the scroll range via bottom padding
+      (insetBottom + insetTop).toFloat().px.toInt(),
     )
+
+    // scroll by the delta to keep content visually in place
+    val delta = newTopInsetPx - appliedTopInsetPx
+    if (delta != 0) {
+      scrollView.scrollBy(0, delta)
+    }
+
+    appliedTopInsetPx = newTopInsetPx
   }
 }
diff --git a/android/src/paper/java/com/reactnativekeyboardcontroller/ClippingScrollViewDecoratorViewManager.kt b/android/src/paper/java/com/reactnativekeyboardcontroller/ClippingScrollViewDecoratorViewManager.kt
index a02cc22d1b..816454728a 100644
--- a/android/src/paper/java/com/reactnativekeyboardcontroller/ClippingScrollViewDecoratorViewManager.kt
+++ b/android/src/paper/java/com/reactnativekeyboardcontroller/ClippingScrollViewDecoratorViewManager.kt
@@ -21,4 +21,12 @@ class ClippingScrollViewDecoratorViewManager : ViewGroupManager<ClippingScrollVi
   ) {
     view.setContentInsetBottom(value)
   }
+
+  @ReactProp(name = "contentInsetTop")
+  fun setContentInsetTop(
+    view: ClippingScrollViewDecoratorView,
+    value: Double,
+  ) {
+    view.setContentInsetTop(value)
+  }
 }
diff --git a/cspell.json b/cspell.json
index 8d1c2589d8..24e63fe9c3 100644
--- a/cspell.json
+++ b/cspell.json
@@ -193,7 +193,8 @@
     "xoyseau",
     "kirylziusko",
     "lottiefiles",
-    "dotlottie"
+    "dotlottie",
+    "legendapp"
   ],
   "ignorePaths": [
     "node_modules",
diff --git a/docs/docs/api/components/keyboard-aware-scroll-view.mdx b/docs/docs/api/components/keyboard-aware-scroll-view.mdx
index d2199be7b7..f6ce907b12 100644
--- a/docs/docs/api/components/keyboard-aware-scroll-view.mdx
+++ b/docs/docs/api/components/keyboard-aware-scroll-view.mdx
@@ -6,6 +6,7 @@ keywords:
     keyboard aware view,
     aware scroll view,
   ]
+description: ScrollView that effortlessly handles keyboard appearance, automatically scrolls to focused TextInput and provides a native-like performance
 ---
 
 # KeyboardAwareScrollView
diff --git a/docs/docs/api/components/keyboard-chat-scroll-view.mdx b/docs/docs/api/components/keyboard-chat-scroll-view.mdx
new file mode 100644
index 0000000000..182aa3f5c4
--- /dev/null
+++ b/docs/docs/api/components/keyboard-chat-scroll-view.mdx
@@ -0,0 +1,182 @@
+# KeyboardChatScrollView
+
+`KeyboardChatScrollView` is a purpose-built component for chat application layouts. It handles keyboard appearance, interactive dismissal, and content repositioning with smooth 60/120 FPS animations — all the keyboard behaviors that chat apps need, but general-purpose components **_struggle_** to deliver.
+
+import Video from "@site/src/components/Video";
+
+<Video src="/video/keyboard-chat-scroll-view/always.mov" width={35} />
+
+## Props
+
+### [`ScrollView Props`](https://reactnative.dev/docs/scrollview#props)
+
+Inherits all [ScrollView Props](https://reactnative.dev/docs/scrollview#props).
+
+### `ScrollViewComponent`
+
+Custom component that will be used as a `ScrollView`. Default is `ScrollView`.
+
+:::tip When to use it?
+If you want to use `ScrollView` from `react-native-gesture-handler` you can pass it as a `ScrollViewComponent` prop.
+
+```tsx
+import { ScrollView } from "react-native-gesture-handler";
+
+<KeyboardChatScrollView ScrollViewComponent={ScrollView} />;
+```
+
+:::
+
+### `freeze`
+
+When `true`, freezes all keyboard-driven layout changes. This is useful when dismissing the keyboard to show a custom input view (such as an emoji picker or bottom sheet) — it prevents the chat content from shifting while the transition happens.
+
+### `inverted`
+
+Set to `true` if your list uses the `inverted` prop (the standard pattern for chat-style lists where the newest messages appear at the bottom).
+
+### `keyboardLiftBehavior`
+
+Controls how the chat content responds when the keyboard appears. Defaults to `"always"`.
+
+#### `always`
+
+Content always lifts with the keyboard, keeping the bottom messages visible **regardless** of the current scroll position. This is the most common chat app behavior, used by **Telegram**, **WhatsApp**, and others.
+
+<Video src="/video/keyboard-chat-scroll-view/always.mov" width={25} />
+
+#### `whenAtEnd`
+
+Content lifts only when the scroll view is **at the end** (i.e., the last message is visible or near the bottom). If the user has scrolled up to read older messages, the keyboard won't push the content around. This matches the **ChatGPT** mobile app behavior.
+
+<Video src="/video/keyboard-chat-scroll-view/when-at-end.mov" width={25} />
+
+#### `persistent`
+
+Content lifts when the keyboard appears, but **does not drop back** when the keyboard hides. The scroll position stays where it was pushed to. This matches the **Claude** mobile app behavior.
+
+<Video src="/video/keyboard-chat-scroll-view/persistent.mp4" width={25} />
+
+#### `never`
+
+Content never moves in response to the keyboard. The keyboard simply overlaps the chat. This matches the **Perplexity** app behavior.
+
+<Video src="/video/keyboard-chat-scroll-view/never.mov" width={25} />
+
+### `offset`
+
+The distance between the bottom of the screen and the `ScrollView`. When the keyboard appears, the `ScrollView` will only push content by the effective distance (`keyboardHeight - offset`) instead of the full keyboard height. Defaults to `0`.
+
+This is useful when the input is not at the very bottom of the screen — for example, when the `ScrollView` sits above a **safe area** inset, **bottom tabs**, or **any other fixed-height element**. In that case, set `offset` to the height of the elements between the `ScrollView` and the bottom of the screen.
+
+## Usage with virtualized lists
+
+`KeyboardChatScrollView` doesn't ship with built-in wrappers for third-party virtualized list libraries, but since all of them (`FlatList`, `FlashList`, `LegendList`) accept a custom scroll component, integration is straightforward.
+
+First, create a wrapper component:
+
+```tsx title="VirtualizedListScrollView.tsx"
+import { forwardRef } from "react";
+import { KeyboardChatScrollView } from "react-native-keyboard-controller";
+
+import type { ScrollViewProps } from "react-native";
+
+const VirtualizedListScrollView = forwardRef((props: ScrollViewProps, ref) => {
+  return (
+    <KeyboardChatScrollView
+      ref={ref}
+      automaticallyAdjustContentInsets={false}
+      contentInsetAdjustmentBehavior="never"
+      {...props}
+    />
+  );
+});
+
+export default VirtualizedListScrollView;
+```
+
+Then pass it to your list via `renderScrollComponent`:
+
+```tsx title="FlashList"
+<FlashList
+  ref={ref}
+  data={messages}
+  keyExtractor={(item) => item.text}
+  renderItem={({ item }) => <Message {...item} />}
+  renderScrollComponent={VirtualizedListScrollView}
+/>
+```
+
+```tsx title="FlatList/LegendList"
+const memoList = useCallback(
+  (props: ScrollViewProps) => <VirtualizedListScrollView {...props} />,
+  [],
+);
+
+<FlatList
+  ref={ref}
+  data={messages}
+  keyExtractor={(item) => item.text}
+  renderItem={({ item }) => <Message {...item} />}
+  renderScrollComponent={memoList}
+/>
+
+<LegendList
+  ref={ref}
+  data={messages}
+  keyExtractor={(item) => item.text}
+  renderItem={({ item }) => <Message {...item} />}
+  renderScrollComponent={memoList}
+/>
+```
+
+## Example
+
+<div
+  data-snack-id="@kirylziusko/c0b7f0"
+  data-snack-platform="ios"
+  data-snack-preview="true"
+  data-snack-theme="light"
+  style={{
+    overflow: "hidden",
+    background: "#fbfcfd",
+    border: "1px solid var(--color-border)",
+    borderRadius: 4,
+    height: 505,
+    width: "100%",
+  }}
+></div>
+
+<Head>
+  <script src="https://snack.expo.dev/embed.js" async />
+</Head>
+
+## Design principles
+
+The key idea behind this component is that the `ScrollView` layout **never** changes. Instead of adjusting the **layout** or the `ScrollView` **position**, it changes the content position. To implement a chat interface we need to do two things: extend the scrollable range and adjust the scroll position.
+
+### Extending scroll range
+
+When the keyboard appears we need to extend the scrollable range. On iOS this is achievable via `contentInset`. On Android it's less straightforward because there is no such property.
+
+To bring support on Android, the `ScrollView` is wrapped with [`ClippingScrollViewDecorator`](https://github.com/kirillzyusko/react-native-keyboard-controller/blob/main/android/src/main/java/com/reactnativekeyboardcontroller/views/ClippingScrollViewDecoratorView.kt) — a custom view built in `react-native-keyboard-controller` that simulates `contentInset` behavior on Android by exposing two additional properties: `contentInsetBottom` and `contentInsetTop`. The usage looks like:
+
+```tsx
+<ClippingScrollViewDecorator contentInsetTop={0} contentInsetBottom={0}>
+  <ScrollView style={{ flex: 1 }}>{/* ...content... */}</ScrollView>
+</ClippingScrollViewDecorator>
+```
+
+The `ClippingScrollViewDecorator` should wrap the `ScrollView`. Whenever you change the `contentInsetBottom` or `contentInsetTop` properties, the `contentInset` will be automatically applied to the underlying `ScrollView`.
+
+### Adjusting scroll position
+
+The second step is to adjust the scroll position. This is handled differently on iOS and Android.
+
+#### iOS
+
+On iOS we change the [`contentOffset`](https://reactnative.dev/docs/scrollview#contentoffset) property. It works well and without bugs, unlike on Android, so for Android we use a different approach.
+
+#### Android
+
+On Android we adjust the scroll position inside the [`onMove`](../hooks/keyboard/use-keyboard-handler#onmove) handler via the [`scrollTo`](https://docs.swmansion.com/react-native-reanimated/docs/scroll/scrollTo/) method on the UI thread from a worklet.
diff --git a/docs/docs/guides/building-chat-app.mdx b/docs/docs/guides/building-chat-app.mdx
new file mode 100644
index 0000000000..0a33fd19d0
--- /dev/null
+++ b/docs/docs/guides/building-chat-app.mdx
@@ -0,0 +1,413 @@
+---
+sidebar_position: 5
+description: A guide that explores the challenges of building chat app layouts and shows how to solve them using the KeyboardChatScrollView component
+keywords:
+  [
+    react-native-keyboard-controller,
+    react-native,
+    keyboard,
+    chat,
+    KeyboardChatScrollView,
+  ]
+---
+
+# Building a chat app
+
+Keyboard handling in chat applications has always been one of the trickiest problems in mobile development — even on native platforms. Chat apps push keyboard interactions to their limits: interactive dismissal, content repositioning, smooth transitions between the keyboard and custom input views, and all of it at 120 FPS. Getting this right requires deep integration between the keyboard, scroll views, and layout systems — far more than a general-purpose component can offer.
+
+## Why general-purpose components fall short
+
+You might be tempted to reach for `KeyboardAvoidingView` or `KeyboardAwareScrollView` to handle keyboard interactions in a chat app. While these components work well for forms, settings screens, and other straightforward layouts, they weren't designed for the unique demands of a chat interface.
+
+Here's what you'll run into:
+
+- **Frame drops with complex layouts** — `KeyboardAvoidingView` with `behavior="padding"` or `behavior="height"` can cause [frame drops](https://github.com/software-mansion/react-native-reanimated/issues/6854), particularly when the layout is complex.
+- **First-message rendering issues** — using `behavior="translate-with-padding"` makes it [impossible](https://github.com/kirillzyusko/react-native-keyboard-controller/issues/951) to render the first message at the top of the screen.
+- **Double scroll on interactive dismissal** — combining `KeyboardAvoidingView` with interactive keyboard dismissal on iOS leads to a [double-scroll problem](https://github.com/kirillzyusko/react-native-keyboard-controller/issues/594#issuecomment-2406860730).
+- **Unnecessary animation** — when you are at the beginning of the list and keyboard closes, `KeyboardAvoidingView` still animates the content even though no scrolling adjustment is needed.
+
+These aren't edge cases — they're fundamental mismatches between what generic components were designed to do and what chat apps actually need. You can work around them, but you'll end up writing a lot of platform-specific code to get a polished result.
+
+## What chat apps actually need
+
+Despite the complexity, most chat apps share the same set of keyboard-related requirements:
+
+- **Content repositioning** — push messages up when the keyboard appears (with the option to disable this in certain cases).
+- **Interactive dismissal** — let users swipe the keyboard away with a drag gesture.
+- **Content freezing** — hold the chat in place when switching from the keyboard to a custom input view like an emoji picker or bottom sheet.
+- **Virtualized list support** — work seamlessly with `FlatList`, `FlashList`, `LegendList`, and other virtualized list implementations.
+- **Smooth animations** — maintain 60/120 FPS during keyboard transitions, even on low-end devices.
+- **Keyboard padding** — extend the scrollable area to account for keyboard height.
+- **Custom offsets** — support layouts where the chat isn't flush against the bottom of the screen.
+
+Implementing all of this from scratch is a significant undertaking. That's why we built `KeyboardChatScrollView` — a dedicated component that handles all of these behaviors out of the box, so you can focus on building your chat experience rather than fighting the keyboard.
+
+## What is `KeyboardChatScrollView`?
+
+`KeyboardChatScrollView` is a purpose-built component for chat app layouts. It provides all the requirements listed above — content repositioning, interactive dismissal, content freezing, virtualized list support, smooth animations, keyboard padding, and custom offsets — with zero configuration needed for the common case.
+
+## Step-by-step integration
+
+This section walks through building a chat screen from scratch using `KeyboardChatScrollView`. We'll start with the simplest possible setup and progressively layer on features.
+
+### Basic setup with `ScrollView`
+
+The simplest way to use `KeyboardChatScrollView` is as a drop-in replacement for `ScrollView`:
+
+```tsx
+import { TextInput, View } from "react-native";
+import {
+  KeyboardChatScrollView,
+  KeyboardStickyView,
+} from "react-native-keyboard-controller";
+
+function ChatScreen() {
+  return (
+    <View style={{ flex: 1 }}>
+      <KeyboardChatScrollView>
+        {messages.map((msg) => (
+          <Message key={msg.id} {...msg} />
+        ))}
+      </KeyboardChatScrollView>
+      <KeyboardStickyView>
+        <TextInput placeholder="Type a message..." />
+      </KeyboardStickyView>
+    </View>
+  );
+}
+```
+
+That's it — the keyboard will push messages up when it appears, and pull them back when it hides.
+
+### Adding interactive dismissal
+
+To let users swipe the keyboard away with a drag gesture, wrap the chat area in a `KeyboardGestureArea` and set `keyboardDismissMode="interactive"` on the scroll view:
+
+```tsx
+import { TextInput, View } from "react-native";
+import {
+  KeyboardChatScrollView,
+  KeyboardGestureArea,
+  KeyboardStickyView,
+} from "react-native-keyboard-controller";
+
+function ChatScreen() {
+  return (
+    <View style={{ flex: 1 }}>
+      // add-new-code
+      <KeyboardGestureArea
+        // add-new-code
+        interpolator="ios"
+        // add-new-code
+        style={{ flex: 1 }}
+        // add-new-code
+        textInputNativeID="chat-input"
+        // add-new-code
+      >
+        <KeyboardChatScrollView
+          // add-new-code
+          keyboardDismissMode="interactive"
+        >
+          {messages.map((msg) => (
+            <Message key={msg.id} {...msg} />
+          ))}
+        </KeyboardChatScrollView>
+        <KeyboardStickyView>
+          // add-new-code
+          <TextInput nativeID="chat-input" placeholder="Type a message..." />
+        </KeyboardStickyView>
+      </KeyboardGestureArea>
+    </View>
+  );
+}
+```
+
+Note the matching `textInputNativeID` on `KeyboardGestureArea` and `nativeID` on `TextInput` — this links the gesture area to the correct input.
+
+### Accounting for bottom safe area
+
+If your chat sits above the bottom safe area (or a tab bar), set the `offset` prop so the component only pushes content by the effective distance (`keyboardHeight - offset`):
+
+```tsx
+import { useSafeAreaInsets } from "react-native-safe-area-context";
+
+function ChatScreen() {
+  const { bottom } = useSafeAreaInsets();
+
+  return (
+    <KeyboardChatScrollView offset={bottom}>
+      {/* ...messages... */}
+    </KeyboardChatScrollView>
+  );
+}
+```
+
+Without this, the content would overshoot by the height of the safe area every time the keyboard appears.
+
+### Choosing a `keyboardLiftBehavior`
+
+The `keyboardLiftBehavior` prop controls how messages react when the keyboard opens. Different chat apps use different strategies — pick the one that fits your product:
+
+| Value                | Behavior                                                   | Used by            |
+| -------------------- | ---------------------------------------------------------- | ------------------ |
+| `"always"` (default) | Content always lifts with the keyboard                     | Telegram, WhatsApp |
+| `"whenAtEnd"`        | Content lifts only if the user is scrolled to the bottom   | ChatGPT            |
+| `"persistent"`       | Content lifts when keyboard opens, but stays when it hides | Claude             |
+| `"never"`            | Content never moves; the keyboard overlaps the chat        | Perplexity         |
+
+```tsx
+<KeyboardChatScrollView keyboardLiftBehavior="whenAtEnd">
+  {/* ...messages... */}
+</KeyboardChatScrollView>
+```
+
+### Freezing content for custom input views
+
+When transitioning from the keyboard to a custom input view (like an emoji picker), you don't want the chat to jump. Set `freeze={true}` to hold the scroll position in place during the transition:
+
+```tsx
+const [showEmojiPicker, setShowEmojiPicker] = useState(false);
+const [freeze, setFreeze] = useState(false);
+
+const onEmojiPress = () => {
+  setFreeze(true); // freeze before dismissing keyboard
+  Keyboard.dismiss();
+  setShowEmojiPicker(true);
+};
+
+const onKeyboardPress = () => {
+  setFreeze(false);
+  setShowEmojiPicker(false);
+  textInputRef.current?.focus();
+};
+
+// ...
+
+<KeyboardChatScrollView freeze={freeze}>
+  {/* ...messages... */}
+</KeyboardChatScrollView>;
+```
+
+When `freeze` is `true`, all keyboard-driven layout changes (padding, content offset, scroll position) are paused.
+
+## Using with virtualized lists
+
+For production chat apps you'll likely use a virtualized list (`FlatList`, `FlashList`, or `LegendList`) instead of a plain `ScrollView`. All of these accept a custom scroll component, making integration straightforward.
+
+### Creating a scroll wrapper
+
+Create a wrapper that passes `KeyboardChatScrollView` props down:
+
+```tsx title="VirtualizedListScrollView.tsx"
+import { forwardRef } from "react";
+import { KeyboardChatScrollView } from "react-native-keyboard-controller";
+import { useSafeAreaInsets } from "react-native-safe-area-context";
+
+import type { ScrollViewProps } from "react-native";
+
+const BOTTOM_OFFSET = 8; // distance from safe area to input
+
+const VirtualizedListScrollView = forwardRef((props: ScrollViewProps, ref) => {
+  const { bottom } = useSafeAreaInsets();
+
+  return (
+    <KeyboardChatScrollView
+      ref={ref}
+      automaticallyAdjustContentInsets={false}
+      contentInsetAdjustmentBehavior="never"
+      keyboardDismissMode="interactive"
+      offset={bottom - BOTTOM_OFFSET}
+      {...props}
+    />
+  );
+});
+
+export default VirtualizedListScrollView;
+```
+
+:::tip
+Always set `automaticallyAdjustContentInsets={false}` and `contentInsetAdjustmentBehavior="never"` when using `KeyboardChatScrollView` inside virtualized lists. This prevents iOS from applying its own content inset adjustments, which would conflict with the component's inset management.
+:::
+
+### Plugging into `FlashList`
+
+`FlashList` accepts `renderScrollComponent` directly as a component reference:
+
+```tsx
+import { FlashList } from "@shopify/flash-list";
+
+<FlashList
+  data={messages}
+  inverted
+  keyExtractor={(item) => item.id}
+  renderItem={({ item }) => <Message {...item} />}
+  renderScrollComponent={VirtualizedListScrollView}
+/>;
+```
+
+### Plugging into `FlatList` / `LegendList`
+
+`FlatList` and `LegendList` require a stable function reference — wrap the component in `useCallback`:
+
+```tsx
+import { useCallback } from "react";
+import { FlatList, type ScrollViewProps } from "react-native";
+
+const renderScrollComponent = useCallback(
+  (props: ScrollViewProps) => <VirtualizedListScrollView {...props} />,
+  [],
+);
+
+<FlatList
+  data={messages}
+  inverted
+  keyExtractor={(item) => item.id}
+  renderItem={({ item }) => <Message {...item} />}
+  renderScrollComponent={renderScrollComponent}
+/>;
+```
+
+### Handling the `inverted` prop
+
+If your list uses the `inverted` prop (the standard pattern for chat lists where newest messages appear at the bottom), make sure to pass `inverted` to `KeyboardChatScrollView` as well:
+
+```tsx title="VirtualizedListScrollView.tsx"
+const VirtualizedListScrollView = forwardRef(
+  ({ inverted, ...props }: ScrollViewProps & { inverted?: boolean }, ref) => {
+    return (
+      <KeyboardChatScrollView
+        ref={ref}
+        // add-new-code
+        inverted={inverted}
+        {...props}
+      />
+    );
+  },
+);
+```
+
+## Complete example
+
+Here is a complete chat screen that ties together all the pieces — `KeyboardChatScrollView` with a `FlatList`, interactive dismissal, sticky input, and safe area handling:
+
+```tsx
+import { useCallback, useRef, useState } from "react";
+import {
+  FlatList,
+  StyleSheet,
+  TextInput,
+  TouchableOpacity,
+  View,
+  type ScrollViewProps,
+} from "react-native";
+import {
+  KeyboardChatScrollView,
+  KeyboardGestureArea,
+  KeyboardStickyView,
+} from "react-native-keyboard-controller";
+import {
+  SafeAreaView,
+  useSafeAreaInsets,
+} from "react-native-safe-area-context";
+
+const MARGIN = 8;
+const INPUT_HEIGHT = 42;
+
+// Wrapper for virtualized lists
+const ChatScrollView = forwardRef((props: ScrollViewProps, ref) => {
+  const { bottom } = useSafeAreaInsets();
+
+  return (
+    <KeyboardChatScrollView
+      ref={ref}
+      automaticallyAdjustContentInsets={false}
+      contentInsetAdjustmentBehavior="never"
+      keyboardDismissMode="interactive"
+      offset={bottom - MARGIN}
+      {...props}
+    />
+  );
+});
+
+function ChatScreen() {
+  const textInputRef = useRef<TextInput>(null);
+  const textRef = useRef("");
+  const [messages, setMessages] = useState(INITIAL_MESSAGES);
+  const { bottom } = useSafeAreaInsets();
+
+  const renderScrollComponent = useCallback(
+    (props: ScrollViewProps) => <ChatScrollView {...props} />,
+    [],
+  );
+
+  const onSend = useCallback(() => {
+    const text = textRef.current.trim();
+    if (!text) return;
+
+    setMessages((prev) => [...prev, { id: String(Date.now()), text }]);
+    textInputRef.current?.clear();
+    textRef.current = "";
+  }, []);
+
+  return (
+    <SafeAreaView edges={["bottom"]} style={styles.container}>
+      <KeyboardGestureArea
+        interpolator="ios"
+        offset={INPUT_HEIGHT}
+        style={styles.container}
+        textInputNativeID="chat-input"
+      >
+        <FlatList
+          data={messages}
+          inverted
+          contentContainerStyle={{ paddingTop: INPUT_HEIGHT + MARGIN }}
+          keyExtractor={(item) => item.id}
+          renderItem={({ item }) => <Message {...item} />}
+          renderScrollComponent={renderScrollComponent}
+        />
+        <KeyboardStickyView
+          offset={{ opened: bottom - MARGIN }}
+          style={styles.composer}
+        >
+          <TextInput
+            ref={textInputRef}
+            multiline
+            nativeID="chat-input"
+            placeholder="Type a message..."
+            style={styles.input}
+            onChangeText={(text) => (textRef.current = text)}
+          />
+          <TouchableOpacity onPress={onSend}>
+            <Text>Send</Text>
+          </TouchableOpacity>
+        </KeyboardStickyView>
+      </KeyboardGestureArea>
+    </SafeAreaView>
+  );
+}
+```
+
+Or play with the code in live mode directly in the browser:
+
+<div
+  data-snack-id="@kirylziusko/c0b7f0"
+  data-snack-platform="ios"
+  data-snack-preview="true"
+  data-snack-theme="light"
+  style={{
+    overflow: "hidden",
+    background: "#fbfcfd",
+    border: "1px solid var(--color-border)",
+    borderRadius: 4,
+    height: 505,
+    width: "100%",
+  }}
+></div>
+
+<Head>
+  <script src="https://snack.expo.dev/embed.js" async />
+</Head>
+
+## API reference
+
+For the full list of props and design principles, see the [`KeyboardChatScrollView` API reference](../api/components/keyboard-chat-scroll-view).
diff --git a/docs/docs/guides/compatibility.md b/docs/docs/guides/compatibility.md
index 0b2b77419a..5116e3ec3d 100644
--- a/docs/docs/guides/compatibility.md
+++ b/docs/docs/guides/compatibility.md
@@ -1,5 +1,5 @@
 ---
-sidebar_position: 5
+sidebar_position: 6
 description: Compatibility of library with different react-native versions and architectures
 keywords:
   [react-native-keyboard-controller, compatibility, react-native versions]
diff --git a/docs/docs/guides/components-overview.mdx b/docs/docs/guides/components-overview.mdx
index 9c207425f1..318e0e7245 100644
--- a/docs/docs/guides/components-overview.mdx
+++ b/docs/docs/guides/components-overview.mdx
@@ -28,6 +28,10 @@ keywords:
 
 This guide provides a concise overview of the main UI components in `react-native-keyboard-controller`. Choose the right component to handle keyboard interactions smoothly and consistently across platforms.
 
+:::info Building a chat app?
+If you are building a chat application, check out the dedicated [guide](./building-chat-app) guide that explores pitfalls of building chat app layout and shows how to solve them using `KeyboardChatScrollView` component.
+:::
+
 ## [`KeyboardAvoidingView`](../api/components/keyboard-avoiding-view)
 
 import Lottie from "lottie-react";
diff --git a/docs/static/video/keyboard-chat-scroll-view/always.mov b/docs/static/video/keyboard-chat-scroll-view/always.mov
new file mode 100644
index 0000000000..733e96ed3e
Binary files /dev/null and b/docs/static/video/keyboard-chat-scroll-view/always.mov differ
diff --git a/docs/static/video/keyboard-chat-scroll-view/never.mov b/docs/static/video/keyboard-chat-scroll-view/never.mov
new file mode 100644
index 0000000000..f148f29d1f
Binary files /dev/null and b/docs/static/video/keyboard-chat-scroll-view/never.mov differ
diff --git a/docs/static/video/keyboard-chat-scroll-view/persistent.mp4 b/docs/static/video/keyboard-chat-scroll-view/persistent.mp4
new file mode 100644
index 0000000000..17ac536691
Binary files /dev/null and b/docs/static/video/keyboard-chat-scroll-view/persistent.mp4 differ
diff --git a/docs/static/video/keyboard-chat-scroll-view/when-at-end.mov b/docs/static/video/keyboard-chat-scroll-view/when-at-end.mov
new file mode 100644
index 0000000000..53a459fde1
Binary files /dev/null and b/docs/static/video/keyboard-chat-scroll-view/when-at-end.mov differ
diff --git a/example/package.json b/example/package.json
index 46b5985161..069abedf28 100644
--- a/example/package.json
+++ b/example/package.json
@@ -12,6 +12,7 @@
   },
   "dependencies": {
     "@gorhom/bottom-sheet": "5.2.6",
+    "@legendapp/list": "^2.0.19",
     "@react-native-community/blur": "^4.4.1",
     "@react-native-masked-view/masked-view": "^0.3.2",
     "@react-navigation/bottom-tabs": "^7.9.0",
@@ -31,7 +32,8 @@
     "react-native-screens": "4.16.0",
     "react-native-text-input-mask": "3.1.5",
     "react-native-toast-message": "^2.3.0",
-    "react-native-webview": "^13.16.0"
+    "react-native-webview": "^13.16.0",
+    "zustand": "^5.0.11"
   },
   "devDependencies": {
     "@babel/core": "^7.25.2",
diff --git a/example/src/constants/screenNames.ts b/example/src/constants/screenNames.ts
index 7f50da4c13..4b3370632a 100644
--- a/example/src/constants/screenNames.ts
+++ b/example/src/constants/screenNames.ts
@@ -27,4 +27,5 @@ export enum ScreenNames {
   LIQUID_KEYBOARD = "LIQUID_KEYBOARD",
   KEYBOARD_SHARED_TRANSITIONS = "KEYBOARD_SHARED_TRANSITIONS",
   KEYBOARD_EXTENDER = "KEYBOARD_EXTENDER",
+  CHAT_KIT = "CHAT_KIT",
 }
diff --git a/example/src/navigation/ExamplesStack/index.tsx b/example/src/navigation/ExamplesStack/index.tsx
index 208e17ee95..1ee1fcc6b9 100644
--- a/example/src/navigation/ExamplesStack/index.tsx
+++ b/example/src/navigation/ExamplesStack/index.tsx
@@ -13,6 +13,7 @@ import InteractiveKeyboard from "../../screens/Examples/InteractiveKeyboard";
 import InteractiveKeyboardIOS from "../../screens/Examples/InteractiveKeyboardIOS";
 import KeyboardAnimation from "../../screens/Examples/KeyboardAnimation";
 import KeyboardAvoidingViewExample from "../../screens/Examples/KeyboardAvoidingView";
+import KeyboardChatScrollViewPlayground from "../../screens/Examples/KeyboardChatScrollView";
 import KeyboardExtender from "../../screens/Examples/KeyboardExtender";
 import KeyboardSharedTransitionExample from "../../screens/Examples/KeyboardSharedTransitions";
 import UseKeyboardState from "../../screens/Examples/KeyboardStateHook";
@@ -54,6 +55,7 @@ export type ExamplesStackParamList = {
   [ScreenNames.LIQUID_KEYBOARD]: undefined;
   [ScreenNames.KEYBOARD_SHARED_TRANSITIONS]: undefined;
   [ScreenNames.KEYBOARD_EXTENDER]: undefined;
+  [ScreenNames.CHAT_KIT]: undefined;
 };
 
 const Stack = createStackNavigator<ExamplesStackParamList>();
@@ -138,6 +140,14 @@ const options = {
     title: "Keyboard Extender",
     headerShown: false,
   },
+  [ScreenNames.CHAT_KIT]: {
+    title: "Chat Kit",
+    headerTintColor: "#fff",
+    headerStyle: {
+      backgroundColor: "#3A3A3C",
+    },
+    headerBackTitle: "Back",
+  },
 };
 
 const ExamplesStack = () => (
@@ -267,6 +277,11 @@ const ExamplesStack = () => (
       name={ScreenNames.KEYBOARD_EXTENDER}
       options={options[ScreenNames.KEYBOARD_EXTENDER]}
     />
+    <Stack.Screen
+      component={KeyboardChatScrollViewPlayground}
+      name={ScreenNames.CHAT_KIT}
+      options={options[ScreenNames.CHAT_KIT]}
+    />
   </Stack.Navigator>
 );
 
diff --git a/example/src/screens/Examples/KeyboardChatScrollView/VirtualizedListScrollView.tsx b/example/src/screens/Examples/KeyboardChatScrollView/VirtualizedListScrollView.tsx
new file mode 100644
index 0000000000..8aef589f03
--- /dev/null
+++ b/example/src/screens/Examples/KeyboardChatScrollView/VirtualizedListScrollView.tsx
@@ -0,0 +1,82 @@
+import React, { forwardRef, useCallback, useMemo, useState } from "react";
+import {
+  type LayoutChangeEvent,
+  type ScrollViewProps,
+  StyleSheet,
+  Text,
+} from "react-native";
+import { KeyboardChatScrollView } from "react-native-keyboard-controller";
+import { useSafeAreaInsets } from "react-native-safe-area-context";
+
+import { useChatConfigStore } from "./store";
+import { MARGIN, TEXT_INPUT_HEIGHT } from "./styles";
+
+export type VirtualizedListScrollViewRef = React.ElementRef<
+  typeof KeyboardChatScrollView
+>;
+
+const VirtualizedListScrollView = forwardRef<
+  VirtualizedListScrollViewRef,
+  ScrollViewProps
+>(({ onLayout: onLayoutProp, ...props }, ref) => {
+  const [layoutPass, setLayoutPass] = useState(0);
+  const { bottom } = useSafeAreaInsets();
+  const chatKitOffset = bottom - MARGIN;
+
+  const { inverted, freeze, mode, keyboardLiftBehavior } = useChatConfigStore();
+
+  const contentContainerStyle = useMemo(
+    () => ({ paddingBottom: TEXT_INPUT_HEIGHT + MARGIN }),
+    [],
+  );
+  const invertedContentContainerStyle = useMemo(
+    () => ({ paddingTop: TEXT_INPUT_HEIGHT + MARGIN }),
+    [],
+  );
+  // on old arch only FlatList and FlashList supports `inverted` prop
+  const isInvertedSupported =
+    inverted && (mode === "flat" || mode === "flash") ? inverted : false;
+  const onLayout = useCallback(
+    (e: LayoutChangeEvent) => {
+      setLayoutPass((l) => l + 1);
+      onLayoutProp?.(e);
+    },
+    [onLayoutProp],
+  );
+
+  return (
+    <>
+      <KeyboardChatScrollView
+        ref={ref}
+        automaticallyAdjustContentInsets={false}
+        contentContainerStyle={
+          inverted ? invertedContentContainerStyle : contentContainerStyle
+        }
+        contentInsetAdjustmentBehavior="never"
+        freeze={freeze}
+        inverted={isInvertedSupported}
+        keyboardDismissMode="interactive"
+        keyboardLiftBehavior={keyboardLiftBehavior}
+        offset={chatKitOffset}
+        testID="chat.scroll"
+        onLayout={onLayout}
+        {...props}
+      />
+      <Text style={styles.counter} testID="layout_passes">
+        Layout pass: {layoutPass}
+      </Text>
+    </>
+  );
+});
+
+const styles = StyleSheet.create({
+  counter: {
+    position: "absolute",
+    color: "white",
+    top: 0,
+    padding: 12,
+    backgroundColor: "#3c3c3c",
+  },
+});
+
+export default VirtualizedListScrollView;
diff --git a/example/src/screens/Examples/KeyboardChatScrollView/components/Message.tsx b/example/src/screens/Examples/KeyboardChatScrollView/components/Message.tsx
new file mode 100644
index 0000000000..7d31f7940d
--- /dev/null
+++ b/example/src/screens/Examples/KeyboardChatScrollView/components/Message.tsx
@@ -0,0 +1,39 @@
+import React from "react";
+import { StyleSheet, Text, View } from "react-native";
+
+import type { MessageProps } from "../../../../components/Message/types";
+
+/**
+ * Fork of original Message component. Created in order not to break existing e2e tests (requires assets re-generation).
+ */
+export default function Message({ text, sender }: MessageProps) {
+  return (
+    <View style={sender ? styles.senderContainer : styles.recipientContainer}>
+      <Text style={styles.message}>{text}</Text>
+    </View>
+  );
+}
+
+const container = {
+  borderRadius: 10,
+  padding: 10,
+  margin: 10,
+  marginVertical: 5,
+  maxWidth: "80%" as const,
+};
+
+const styles = StyleSheet.create({
+  senderContainer: {
+    alignSelf: "flex-end",
+    backgroundColor: "#F8F8FC",
+    ...container,
+  },
+  recipientContainer: {
+    alignSelf: "flex-start",
+    backgroundColor: "#64D2FF",
+    ...container,
+  },
+  message: {
+    color: "#000000",
+  },
+});
diff --git a/example/src/screens/Examples/KeyboardChatScrollView/config.tsx b/example/src/screens/Examples/KeyboardChatScrollView/config.tsx
new file mode 100644
index 0000000000..df71884789
--- /dev/null
+++ b/example/src/screens/Examples/KeyboardChatScrollView/config.tsx
@@ -0,0 +1,166 @@
+import BottomSheet, { BottomSheetView } from "@gorhom/bottom-sheet";
+import { useNavigation } from "@react-navigation/native";
+import React, { useCallback, useEffect, useRef } from "react";
+import { Button, StyleSheet, Text, TouchableOpacity, View } from "react-native";
+import { KeyboardController } from "react-native-keyboard-controller";
+
+import Switch from "../../../components/Switch";
+
+import { useChatConfigStore } from "./store";
+
+function ConfigSheet() {
+  const navigation = useNavigation();
+  const bottomSheetModalRef = useRef<BottomSheet>(null);
+  const inverted = useChatConfigStore((state) => state.inverted);
+  const setInverted = useChatConfigStore((state) => state.setInverted);
+  const beginning = useChatConfigStore((state) => state.beginning);
+  const setBeginning = useChatConfigStore((state) => state.setBeginning);
+  const setFreeze = useChatConfigStore((state) => state.setFreeze);
+  const mode = useChatConfigStore((state) => state.mode);
+  const setMode = useChatConfigStore((state) => state.setMode);
+  const keyboardLiftBehavior = useChatConfigStore(
+    (state) => state.keyboardLiftBehavior,
+  );
+  const nextLiftBehavior = useChatConfigStore(
+    (state) => state.nextLiftBehavior,
+  );
+
+  const handlePresentModalPress = useCallback(async () => {
+    setFreeze(true);
+    requestAnimationFrame(async () => {
+      await KeyboardController.dismiss({ keepFocus: true });
+      bottomSheetModalRef.current?.expand();
+    });
+  }, [setFreeze]);
+
+  const handleSheetChange = useCallback(
+    (index: number) => {
+      if (index < 0) {
+        setFreeze(false);
+        KeyboardController.setFocusTo("current");
+      }
+    },
+    [setFreeze],
+  );
+
+  useEffect(() => {
+    navigation.setOptions({
+      headerRight: () => (
+        <Text
+          style={styles.header}
+          testID="open_bottom_sheet_modal"
+          onPress={handlePresentModalPress}
+        >
+          Open config
+        </Text>
+      ),
+    });
+  }, [navigation]);
+
+  return (
+    <BottomSheet
+      ref={bottomSheetModalRef}
+      index={-1}
+      snapPoints={["50%"]}
+      onChange={handleSheetChange}
+    >
+      <BottomSheetView style={styles.bottomSheetContent}>
+        <Button
+          testID="bottom_sheet_close_modal"
+          title="Close modal"
+          onPress={() => bottomSheetModalRef.current?.close()}
+        />
+        <View style={styles.switchContainer}>
+          <Text style={styles.text}>Toggle inverted</Text>
+          <Switch
+            testID="bottom_sheet_toggle_inverted_state"
+            value={inverted}
+            onChange={() => {
+              setInverted(!inverted);
+            }}
+          />
+        </View>
+        <View style={styles.switchContainer}>
+          <Text style={styles.text}>Toggle beginning</Text>
+          <Switch
+            testID="bottom_sheet_toggle_beginning_state"
+            value={beginning}
+            onChange={() => {
+              setBeginning(!beginning);
+            }}
+          />
+        </View>
+        <View style={styles.switchContainer}>
+          <Text style={styles.text}>Use Scroll View</Text>
+          <Switch
+            testID="bottom_sheet_toggle_scroll_view_list_state"
+            value={mode === "scroll"}
+            onChange={() => {
+              setMode("scroll");
+            }}
+          />
+        </View>
+        <View style={styles.switchContainer}>
+          <Text style={styles.text}>Use Flat List</Text>
+          <Switch
+            testID="bottom_sheet_toggle_flat_list_state"
+            value={mode === "flat"}
+            onChange={() => {
+              setMode("flat");
+            }}
+          />
+        </View>
+        <View style={styles.switchContainer}>
+          <Text style={styles.text}>Use Flash List</Text>
+          <Switch
+            testID="bottom_sheet_toggle_flash_list_state"
+            value={mode === "flash"}
+            onChange={() => {
+              setMode("flash");
+            }}
+          />
+        </View>
+        <View style={styles.switchContainer}>
+          <Text style={styles.text}>Use Legend List</Text>
+          <Switch
+            testID="bottom_sheet_toggle_legend_list_state"
+            value={mode === "legend"}
+            onChange={() => {
+              setMode("legend");
+            }}
+          />
+        </View>
+        <View style={styles.switchContainer}>
+          <Text style={styles.text}>Lifting mode</Text>
+          <TouchableOpacity
+            testID="bottom_sheet_next_keyboard_lift_behavior"
+            onPress={nextLiftBehavior}
+          >
+            <Text style={styles.text}>{keyboardLiftBehavior}</Text>
+          </TouchableOpacity>
+        </View>
+      </BottomSheetView>
+    </BottomSheet>
+  );
+}
+
+const styles = StyleSheet.create({
+  header: {
+    color: "white",
+    paddingRight: 12,
+  },
+  bottomSheetContent: {
+    flex: 1,
+  },
+  switchContainer: {
+    flexDirection: "row",
+    justifyContent: "space-between",
+    alignItems: "center",
+    margin: 16,
+  },
+  text: {
+    color: "black",
+  },
+});
+
+export default ConfigSheet;
diff --git a/example/src/screens/Examples/KeyboardChatScrollView/data.ts b/example/src/screens/Examples/KeyboardChatScrollView/data.ts
new file mode 100644
index 0000000000..71c6503d8f
--- /dev/null
+++ b/example/src/screens/Examples/KeyboardChatScrollView/data.ts
@@ -0,0 +1,25 @@
+import { history } from "../../../components/Message/data";
+
+export const messages = [
+  ...history,
+  // continue dialog further
+  { text: "Do you any other questions?", sender: true },
+  { text: "Yes, I have a question about teleport library" },
+  { text: "Do you know anything about it?", sender: true },
+  {
+    text: "I have seen some techno demos, but haven't tried it uet",
+    sender: true,
+  },
+  { text: "Yes, I already tried it in my project" },
+  {
+    text: "It's pretty cool. We were able to built gallery with share element transitions without any flickering or any other issues",
+    sender: true,
+  },
+  { text: "So far it looks cool!", sender: true },
+  { text: "And seems to be pretty stable", sender: true },
+  {
+    text: "This is a literally missing 'move' operation in react/react-native. Before we could only create/delete elements, but now you get power of zero-overhead 'move' operation and it can bring your app performance on the next level and also significantly boost your app UI cause it unlocks the power that we didn't have before",
+  },
+  { text: "Wow! That's awesome!" },
+  { text: "Yes! Totally agree!", sender: true },
+];
diff --git a/example/src/screens/Examples/KeyboardChatScrollView/index.tsx b/example/src/screens/Examples/KeyboardChatScrollView/index.tsx
new file mode 100644
index 0000000000..9a4c8c20d6
--- /dev/null
+++ b/example/src/screens/Examples/KeyboardChatScrollView/index.tsx
@@ -0,0 +1,172 @@
+import { LegendList, type LegendListRef } from "@legendapp/list";
+import { FlashList } from "@shopify/flash-list";
+import React, {
+  useCallback,
+  useEffect,
+  useMemo,
+  useRef,
+  useState,
+} from "react";
+import {
+  FlatList,
+  Image,
+  StyleSheet,
+  TextInput,
+  TouchableOpacity,
+  View,
+} from "react-native";
+import {
+  KeyboardGestureArea,
+  KeyboardStickyView,
+} from "react-native-keyboard-controller";
+import {
+  SafeAreaView,
+  useSafeAreaInsets,
+} from "react-native-safe-area-context";
+
+import BlurView from "../../../components/BlurView";
+
+import Message from "./components/Message";
+import ConfigSheet from "./config";
+import { useChatConfigStore } from "./store";
+import styles, { MARGIN, TEXT_INPUT_HEIGHT } from "./styles";
+import VirtualizedListScrollView, {
+  type VirtualizedListScrollViewRef,
+} from "./VirtualizedListScrollView";
+
+import type { MessageProps } from "../../../components/Message/types";
+import type { LayoutChangeEvent, ScrollViewProps } from "react-native";
+
+function KeyboardChatScrollViewPlayground() {
+  const legendRef = useRef<LegendListRef>(null);
+  const flashRef = useRef<FlashList<MessageProps>>(null);
+  const flatRef = useRef<FlatList<MessageProps>>(null);
+  const scrollRef = useRef<VirtualizedListScrollViewRef>(null);
+  const textInputRef = useRef<TextInput>(null);
+  const textRef = useRef("");
+  const [inputHeight, setInputHeight] = useState(TEXT_INPUT_HEIGHT);
+  const { inverted, messages, reversedMessages, addMessage, mode } =
+    useChatConfigStore();
+  const { bottom } = useSafeAreaInsets();
+
+  const stickyViewOffset = useMemo(
+    () => ({ opened: bottom - MARGIN }),
+    [bottom],
+  );
+
+  const onInputLayoutChanged = useCallback((e: LayoutChangeEvent) => {
+    setInputHeight(e.nativeEvent.layout.height);
+  }, []);
+  const onInput = useCallback((text: string) => {
+    textRef.current = text;
+  }, []);
+  const onSend = useCallback(() => {
+    const message = textRef.current.trim();
+
+    if (message === "") {
+      return;
+    }
+
+    addMessage({ text: message, sender: true });
+    textInputRef.current?.clear();
+    textRef.current = "";
+  }, [addMessage]);
+
+  useEffect(() => {
+    legendRef.current?.scrollToOffset({
+      animated: true,
+      offset: Number.MAX_SAFE_INTEGER,
+    });
+    flashRef.current?.scrollToEnd({ animated: true });
+    flatRef.current?.scrollToOffset({
+      animated: true,
+      offset: Number.MAX_SAFE_INTEGER,
+    });
+    scrollRef.current?.scrollToEnd({ animated: true });
+  }, [messages]);
+
+  const memoList = useCallback(
+    (props: ScrollViewProps) => <VirtualizedListScrollView {...props} />,
+    [],
+  );
+
+  return (
+    <SafeAreaView edges={["bottom"]} style={styles.container}>
+      <KeyboardGestureArea
+        interpolator="ios"
+        offset={inputHeight}
+        style={styles.container}
+        textInputNativeID="chat-input"
+      >
+        {mode === "legend" && (
+          <LegendList
+            ref={legendRef}
+            alignItemsAtEnd={inverted}
+            data={messages}
+            keyExtractor={(item) => item.text}
+            renderItem={({ item }) => <Message {...item} />}
+            renderScrollComponent={memoList}
+          />
+        )}
+        {mode === "flash" && (
+          <FlashList
+            ref={flashRef}
+            data={inverted ? reversedMessages : messages}
+            inverted={inverted}
+            keyExtractor={(item) => item.text}
+            renderItem={({ item }) => <Message {...item} />}
+            renderScrollComponent={VirtualizedListScrollView}
+          />
+        )}
+        {mode === "flat" && (
+          <FlatList
+            ref={flatRef}
+            data={inverted ? reversedMessages : messages}
+            inverted={inverted}
+            keyExtractor={(item) => item.text}
+            renderItem={({ item }) => <Message {...item} />}
+            renderScrollComponent={memoList}
+          />
+        )}
+        {mode === "scroll" && (
+          <VirtualizedListScrollView ref={scrollRef}>
+            {messages.map((message, index) => (
+              <Message key={index} {...message} />
+            ))}
+          </VirtualizedListScrollView>
+        )}
+        <KeyboardStickyView offset={stickyViewOffset} style={styles.composer}>
+          <View
+            style={[
+              StyleSheet.absoluteFillObject,
+              { overflow: "hidden" },
+              styles.input,
+            ]}
+          >
+            <BlurView
+              blurAmount={32}
+              blurType="light"
+              reducedTransparencyFallbackColor="white"
+              style={StyleSheet.absoluteFillObject}
+            />
+          </View>
+          <TextInput
+            ref={textInputRef}
+            multiline
+            nativeID="chat-input"
+            style={styles.input}
+            testID="chat.input"
+            onChangeText={onInput}
+            onLayout={onInputLayoutChanged}
+          />
+          <TouchableOpacity style={styles.send} onPress={onSend}>
+            <Image source={require("./send.png")} style={styles.icon} />
+          </TouchableOpacity>
+        </KeyboardStickyView>
+      </KeyboardGestureArea>
+      <ConfigSheet />
+    </SafeAreaView>
+  );
+}
+
+export default KeyboardChatScrollViewPlayground;
diff --git a/example/src/screens/Examples/KeyboardChatScrollView/send.png b/example/src/screens/Examples/KeyboardChatScrollView/send.png
new file mode 100644
index 0000000000..8df18e4776
Binary files /dev/null and b/example/src/screens/Examples/KeyboardChatScrollView/send.png differ
diff --git a/example/src/screens/Examples/KeyboardChatScrollView/store.ts b/example/src/screens/Examples/KeyboardChatScrollView/store.ts
new file mode 100644
index 0000000000..d8ff348956
--- /dev/null
+++ b/example/src/screens/Examples/KeyboardChatScrollView/store.ts
@@ -0,0 +1,81 @@
+import { create } from "zustand";
+
+import { messages as initialMessages } from "./data";
+
+import type { MessageProps } from "../../../components/Message/types";
+import type { KeyboardChatScrollViewProps } from "react-native-keyboard-controller";
+
+type ListMode = "scroll" | "flat" | "flash" | "legend";
+
+const liftModes: KeyboardChatScrollViewProps["keyboardLiftBehavior"][] = [
+  "always",
+  "whenAtEnd",
+  "persistent",
+  "never",
+];
+
+interface ChatConfigStore {
+  inverted: boolean;
+  setInverted: (inverted: boolean) => void;
+  beginning: boolean;
+  setBeginning: (beginning: boolean) => void;
+  freeze: boolean;
+  setFreeze: (freeze: boolean) => void;
+  messages: MessageProps[];
+  reversedMessages: MessageProps[];
+  setMessages: (messages: MessageProps[]) => void;
+  addMessage: (message: MessageProps) => void;
+  mode: ListMode;
+  setMode: (mode: ListMode) => void;
+  resetMessages: () => void;
+  keyboardLiftBehavior: KeyboardChatScrollViewProps["keyboardLiftBehavior"];
+  nextLiftBehavior: () => void;
+}
+
+export const useChatConfigStore = create<ChatConfigStore>((set, get) => ({
+  inverted: false,
+  setInverted: (inverted) => set({ inverted }),
+  freeze: false,
+  setFreeze: (freeze) => set({ freeze }),
+  beginning: false,
+  setBeginning: (beginning) => {
+    set(() => {
+      const newMessages = beginning ? [initialMessages[0]] : initialMessages;
+
+      return {
+        beginning,
+        messages: newMessages,
+        reversedMessages: [...newMessages].reverse(),
+      };
+    });
+  },
+  messages: initialMessages,
+  reversedMessages: [...initialMessages].reverse(),
+  setMessages: (messages) =>
+    set({ messages, reversedMessages: [...messages].reverse() }),
+  addMessage: (message) =>
+    set((state) => {
+      const newMessages = [...state.messages, message];
+
+      return {
+        messages: newMessages,
+        reversedMessages: [...newMessages].reverse(),
+      };
+    }),
+  mode: "scroll",
+  setMode: (mode) => set({ mode }),
+  resetMessages: () =>
+    set({
+      messages: initialMessages,
+      reversedMessages: [...initialMessages].reverse(),
+    }),
+  keyboardLiftBehavior: "always",
+  nextLiftBehavior: () => {
+    const idx = liftModes.indexOf(get().keyboardLiftBehavior);
+
+    set({
+      keyboardLiftBehavior:
+        liftModes[idx === liftModes.length - 1 ? 0 : idx + 1],
+    });
+  },
+}));
diff --git a/example/src/screens/Examples/KeyboardChatScrollView/styles.ts b/example/src/screens/Examples/KeyboardChatScrollView/styles.ts
new file mode 100644
index 0000000000..facb2c5cae
--- /dev/null
+++ b/example/src/screens/Examples/KeyboardChatScrollView/styles.ts
@@ -0,0 +1,44 @@
+import { StyleSheet } from "react-native";
+
+export const TEXT_INPUT_HEIGHT = 50;
+
+export const MARGIN = 16;
+
+export default StyleSheet.create({
+  container: {
+    justifyContent: "flex-end",
+    flex: 1,
+    backgroundColor: "#3A3A3C",
+  },
+  input: {
+    flex: 1,
+    margin: MARGIN,
+    marginBottom: 0,
+    padding: MARGIN,
+    borderRadius: 99,
+    borderWidth: 1,
+    borderColor: "#BCBCBC",
+    backgroundColor: "#3A3A3C66",
+  },
+  composer: {
+    position: "absolute",
+    width: "100%",
+    minHeight: TEXT_INPUT_HEIGHT,
+  },
+  send: {
+    position: "absolute",
+    top: MARGIN + (TEXT_INPUT_HEIGHT - MARGIN * 2) / 2,
+    right: MARGIN * 2,
+    padding: MARGIN,
+    backgroundColor: "white",
+    height: 24,
+    width: 24,
+    alignItems: "center",
+    justifyContent: "center",
+    borderRadius: 99,
+  },
+  icon: {
+    width: 20,
+    height: 20,
+  },
+});
diff --git a/example/src/screens/Examples/Main/constants.ts b/example/src/screens/Examples/Main/constants.ts
index b9cd7f6aab..e8d6dd5a82 100644
--- a/example/src/screens/Examples/Main/constants.ts
+++ b/example/src/screens/Examples/Main/constants.ts
@@ -153,4 +153,10 @@ export const examples: Example[] = [
     info: ScreenNames.KEYBOARD_EXTENDER,
     icons: "🧩",
   },
+  {
+    title: "Chat Kit",
+    testID: "chat_kit",
+    info: ScreenNames.CHAT_KIT,
+    icons: "🛠 💬",
+  },
 ];
diff --git a/example/yarn.lock b/example/yarn.lock
index 8b01998683..0fad353973 100644
--- a/example/yarn.lock
+++ b/example/yarn.lock
@@ -1309,6 +1309,13 @@
     "@jridgewell/resolve-uri" "^3.1.0"
     "@jridgewell/sourcemap-codec" "^1.4.14"
 
+"@legendapp/list@^2.0.19":
+  version "2.0.19"
+  resolved "https://registry.yarnpkg.com/@legendapp/list/-/list-2.0.19.tgz#86fcef3c07f2fa62e3faec002be82f177070b7ee"
+  integrity sha512-zDWg8yg0smKxxk+M7gwAbZAnf5uczohPA+IjqLSkImz7+e9ytxeT0Mq35RBO9RTKODOXfV/aIgm1uqUHLBEdmg==
+  dependencies:
+    use-sync-external-store "^1.5.0"
+
 "@nodelib/fs.scandir@2.1.5":
   version "2.1.5"
   resolved "https://registry.yarnpkg.com/@nodelib/fs.scandir/-/fs.scandir-2.1.5.tgz#7619c2eb21b25483f6d167548b4cfd5a7488c3d5"
@@ -5568,3 +5575,8 @@ yocto-queue@^0.1.0:
   version "0.1.0"
   resolved "https://registry.yarnpkg.com/yocto-queue/-/yocto-queue-0.1.0.tgz#0294eb3dee05028d31ee1a5fa2c556a6aaf10a1b"
   integrity sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==
+
+zustand@^5.0.11:
+  version "5.0.11"
+  resolved "https://registry.yarnpkg.com/zustand/-/zustand-5.0.11.tgz#99f912e590de1ca9ce6c6d1cab6cdb1f034ab494"
+  integrity sha512-fdZY+dk7zn/vbWNCYmzZULHRrss0jx5pPFiOuMZ/5HJN6Yv3u+1Wswy/4MpZEkEGhtNH+pwxZB8OKgUBPzYAGg==
diff --git a/jest/index.js b/jest/index.js
index 1a6b7ffc12..f1f79d5228 100644
--- a/jest/index.js
+++ b/jest/index.js
@@ -120,6 +120,7 @@ const mock = {
   KeyboardAvoidingView: View,
   KeyboardAwareScrollView: ScrollView,
   KeyboardToolbar: View,
+  KeyboardChatScrollView: ScrollView,
   // themes
   DefaultKeyboardToolbarTheme,
 };
diff --git a/jestSetup.js b/jestSetup.js
new file mode 100644
index 0000000000..08fa75ec72
--- /dev/null
+++ b/jestSetup.js
@@ -0,0 +1,5 @@
+require("react-native-reanimated/lib/module/jestUtils").setUpTests();
+
+jest.mock("react-native-reanimated", () =>
+  require("react-native-reanimated/mock"),
+);
diff --git a/package.json b/package.json
index 0dd0c5e314..15c271bd02 100644
--- a/package.json
+++ b/package.json
@@ -89,6 +89,7 @@
     "@react-native/eslint-config": "0.81.4",
     "@release-it/conventional-changelog": "^2.0.0",
     "@testing-library/react-hooks": "^8.0.1",
+    "@testing-library/react-native": "^13.3.3",
     "@types/jest": "^29.5.13",
     "@types/react": "^19.0.0",
     "@types/react-test-renderer": "^19.0.0",
@@ -115,7 +116,7 @@
     "react-native": "0.81.4",
     "react-native-builder-bob": "^0.18.0",
     "react-native-reanimated": "3.19.2",
-    "react-test-renderer": "19.0.0",
+    "react-test-renderer": "19.1.0",
     "release-it": "^14.2.2",
     "typescript": "5.8.3"
   },
@@ -129,6 +130,12 @@
     "modulePathIgnorePatterns": [
       "<rootDir>/example/node_modules",
       "<rootDir>/lib/"
+    ],
+    "transformIgnorePatterns": [
+      "node_modules/(?!((jest-)?react-native|@react-native(-community)?|react-native-reanimated)/)"
+    ],
+    "setupFiles": [
+      "./jestSetup.js"
     ]
   },
   "commitlint": {
@@ -187,5 +194,6 @@
         "KeyboardExtender": "KeyboardExtender"
       }
     }
-  }
+  },
+  "packageManager": "yarn@1.22.22+sha512.a6b2f7906b721bba3d67d4aff083df04dad64c399707841b7acf00f6b133b7ac24255f2652fa22ae3534329dc6180534e98d17432037ff6fd140556e2bb3137e"
 }
diff --git a/src/components/KeyboardChatScrollView/hooks.ts b/src/components/KeyboardChatScrollView/hooks.ts
new file mode 100644
index 0000000000..334412fe04
--- /dev/null
+++ b/src/components/KeyboardChatScrollView/hooks.ts
@@ -0,0 +1,2 @@
+export { useChatKeyboard } from "./useChatKeyboard";
+export type { KeyboardLiftBehavior } from "./useChatKeyboard/types";
diff --git a/src/components/KeyboardChatScrollView/index.tsx b/src/components/KeyboardChatScrollView/index.tsx
new file mode 100644
index 0000000000..2bb85525de
--- /dev/null
+++ b/src/components/KeyboardChatScrollView/index.tsx
@@ -0,0 +1,106 @@
+import React, { forwardRef, useCallback, useMemo } from "react";
+import { StyleSheet } from "react-native";
+import { useAnimatedRef, useAnimatedStyle } from "react-native-reanimated";
+import Reanimated from "react-native-reanimated";
+
+import useCombinedRef from "../hooks/useCombinedRef";
+import ScrollViewWithBottomPadding from "../ScrollViewWithBottomPadding";
+
+import { useChatKeyboard } from "./useChatKeyboard";
+
+import type { KeyboardChatScrollViewProps } from "./types";
+import type { LayoutChangeEvent } from "react-native";
+
+const KeyboardChatScrollView = forwardRef<
+  Reanimated.ScrollView,
+  React.PropsWithChildren<KeyboardChatScrollViewProps>
+>(
+  (
+    {
+      children,
+      ScrollViewComponent = Reanimated.ScrollView,
+      inverted = false,
+      keyboardLiftBehavior = "always",
+      freeze = false,
+      offset = 0,
+      onLayout: onLayoutProp,
+      onContentSizeChange: onContentSizeChangeProp,
+      ...rest
+    },
+    ref,
+  ) => {
+    const scrollViewRef = useAnimatedRef<Reanimated.ScrollView>();
+    const onRef = useCombinedRef(ref, scrollViewRef);
+
+    const {
+      padding,
+      currentHeight,
+      contentOffsetY,
+      onLayout: onLayoutInternal,
+      onContentSizeChange: onContentSizeChangeInternal,
+    } = useChatKeyboard(scrollViewRef, {
+      inverted,
+      keyboardLiftBehavior,
+      freeze,
+      offset,
+    });
+
+    const onLayout = useCallback(
+      (e: LayoutChangeEvent) => {
+        onLayoutInternal(e);
+        onLayoutProp?.(e);
+      },
+      [onLayoutInternal, onLayoutProp],
+    );
+
+    const onContentSizeChange = useCallback(
+      (w: number, h: number) => {
+        onContentSizeChangeInternal(w, h);
+        onContentSizeChangeProp?.(w, h);
+      },
+      [onContentSizeChangeInternal, onContentSizeChangeProp],
+    );
+
+    // Invisible view whose animated style changes every frame during keyboard
+    // animation. On Fabric, this forces Reanimated to schedule a commit,
+    // which flushes the scrollTo call in the same frame (fixing de-synchronization).
+    // see https://github.com/software-mansion/react-native-reanimated/issues/9000
+    const commitStyle = useAnimatedStyle(
+      () => ({
+        transform: [{ translateY: -currentHeight.value }],
+      }),
+      [],
+    );
+    const commit = useMemo(
+      () => [styles.commitView, commitStyle],
+      [commitStyle],
+    );
+
+    return (
+      <>
+        <ScrollViewWithBottomPadding
+          ref={onRef}
+          {...rest}
+          bottomPadding={padding}
+          contentOffsetY={contentOffsetY}
+          inverted={inverted}
+          ScrollViewComponent={ScrollViewComponent}
+          onContentSizeChange={onContentSizeChange}
+          onLayout={onLayout}
+        >
+          {children}
+        </ScrollViewWithBottomPadding>
+        <Reanimated.View style={commit} />
+      </>
+    );
+  },
+);
+
+const styles = StyleSheet.create({
+  commitView: {
+    display: "none",
+    position: "absolute",
+  },
+});
+
+export default KeyboardChatScrollView;
diff --git a/src/components/KeyboardChatScrollView/types.ts b/src/components/KeyboardChatScrollView/types.ts
new file mode 100644
index 0000000000..354f5538f2
--- /dev/null
+++ b/src/components/KeyboardChatScrollView/types.ts
@@ -0,0 +1,49 @@
+import type { AnimatedScrollViewComponent } from "../ScrollViewWithBottomPadding";
+import type { KeyboardLiftBehavior } from "./useChatKeyboard/types";
+import type { ScrollViewProps } from "react-native";
+
+export type KeyboardChatScrollViewProps = {
+  /** Custom component for `ScrollView`. Default is `ScrollView`. */
+  ScrollViewComponent?: AnimatedScrollViewComponent;
+  /** Whether list are using `inverted` prop. Default is `false`. */
+  inverted?: boolean;
+  /**
+   * The distance between the bottom of the screen and the `ScrollView`.
+   * When the keyboard appears, the `ScrollView` will only push content by the effective
+   * distance (`keyboardHeight - offset`) instead of the full keyboard height.
+   *
+   * Useful when the input is not at the very bottom of the screen (e.g., above safe area, above
+   * bottom tabs, etc. - in this case offset should be equal to the height of the elements between
+   * `ScrollView` and bottom of the screen).
+   *
+   * Default is `0`.
+   */
+  offset?: number;
+  /**
+   * Determines how the chat content should behave when the keyboard appears, specifically whether
+   * the scroll view should automatically lift its content to keep it visible above the keyboard.
+   *
+   * Possible values:
+   * - `'always'`: The content always lifts along with the keyboard, ensuring the messages from the bottom part of screen
+   * remain visible regardless of the current scroll position. This is the default behavior for most chat applications (used in Telegram).
+   * - `'whenAtEnd'`: The content lifts only if the scroll view is at the end (i.e., the last message
+   * is visible or near the bottom). This prevents unnecessary adjustments when the user is scrolling
+   * through older messages (ChatGPT mobile app behavior).
+   * - `'persistent'`: The content always lifts when the keyboard appears (similar to `'always'`), but
+   * does not reset (lower) when the keyboard hides. This mimics behaviors where the view remains adjusted
+   * after keyboard dismissal to maintain focus on the latest content without shifting back (Claude mobile app behavior).
+   * - `'never'`: The content does not lift at all when the keyboard appears. Use this for scenarios
+   * when you don't want to disturb user attention with animations (Perplexity mobile app behavior).
+   *
+   * Default is `'always'`.
+   */
+  keyboardLiftBehavior?: KeyboardLiftBehavior;
+  /**
+   * When `true`, freezes all keyboard-driven layout changes (padding, content offset, scroll position).
+   * Useful when dismissing the keyboard to open a bottom sheet — prevents visual disruption
+   * while the sheet is visible.
+   *
+   * Default is `false`.
+   */
+  freeze?: boolean;
+} & ScrollViewProps;
diff --git a/src/components/KeyboardChatScrollView/useChatKeyboard/__fixtures__/testUtils.ts b/src/components/KeyboardChatScrollView/useChatKeyboard/__fixtures__/testUtils.ts
new file mode 100644
index 0000000000..bc5051bc21
--- /dev/null
+++ b/src/components/KeyboardChatScrollView/useChatKeyboard/__fixtures__/testUtils.ts
@@ -0,0 +1,104 @@
+import { renderHook } from "@testing-library/react-native";
+import { useAnimatedRef } from "react-native-reanimated";
+
+import type { useChatKeyboard } from "..";
+import type Reanimated from "react-native-reanimated";
+
+export type KeyboardEvent = { height: number; duration?: number };
+export type Handlers = {
+  onStart: (e: KeyboardEvent) => void;
+  onMove: (e: KeyboardEvent) => void;
+  onInteractive: (e: KeyboardEvent) => void;
+  onEnd: (e: KeyboardEvent) => void;
+};
+
+export const mockOffset = { value: 0 };
+export const mockLayout = { value: { width: 390, height: 800 } };
+export const mockSize = { value: { width: 390, height: 2000 } };
+
+export const KEYBOARD = 300;
+export const mockScrollTo = jest.fn();
+
+/**
+ * Linear interpolate mock matching Reanimated's `interpolate` signature.
+ *
+ * @param value - The input value to interpolate.
+ * @param input - Input range `[min, max]`.
+ * @param output - Output range `[min, max]`.
+ * @returns The interpolated value.
+ * @example mockInterpolate(150, [0, 300], [0, 250]); // 125
+ */
+export function mockInterpolate(
+  value: number,
+  input: number[],
+  output: number[],
+): number {
+  "worklet";
+
+  if (input[1] === 0) {
+    return 0;
+  }
+
+  const progress = (value - input[0]) / (input[1] - input[0]);
+
+  return output[0] + progress * (output[1] - output[0]);
+}
+
+/** Reset mock scroll state to defaults. */
+export function reset() {
+  mockOffset.value = 0;
+  mockLayout.value = { width: 390, height: 800 };
+  mockSize.value = { width: 390, height: 2000 };
+}
+
+/**
+ * Common beforeEach: reset modules, inject trackable scrollTo, reset state.
+ *
+ * @example setupBeforeEach()
+ */
+export function setupBeforeEach() {
+  jest.resetModules();
+
+  jest.doMock("react-native-reanimated", () => ({
+    ...require("react-native-reanimated/mock"),
+    scrollTo: mockScrollTo,
+    interpolate: mockInterpolate,
+  }));
+
+  reset();
+  mockScrollTo.mockClear();
+}
+
+type RenderOptions = Omit<
+  Parameters<typeof useChatKeyboard>[1],
+  "freeze" | "offset"
+> & {
+  freeze?: boolean;
+  offset?: number;
+};
+
+/**
+ * Create a render function that loads the hook from the given module path.
+ *
+ * @param modulePath - Relative path to the hook module (e.g. `"../index.ios"` or `"../index"`).
+ * @returns A render function bound to that module.
+ * @example const render = createRender("../index.ios");
+ */
+export function createRender(modulePath: string) {
+  return function render(options: RenderOptions) {
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    const mod = require(modulePath) as {
+      useChatKeyboard: typeof useChatKeyboard;
+    };
+
+    return renderHook(() => {
+      const ref = useAnimatedRef<Reanimated.ScrollView>();
+
+      return mod.useChatKeyboard(ref, {
+        ...options,
+        freeze: options.freeze ?? false,
+        offset: options.offset ?? 0,
+      });
+    });
+  };
+}
diff --git a/src/components/KeyboardChatScrollView/useChatKeyboard/__tests__/behaviors.android.spec.ts b/src/components/KeyboardChatScrollView/useChatKeyboard/__tests__/behaviors.android.spec.ts
new file mode 100644
index 0000000000..7a9203f6bc
--- /dev/null
+++ b/src/components/KeyboardChatScrollView/useChatKeyboard/__tests__/behaviors.android.spec.ts
@@ -0,0 +1,183 @@
+import {
+  type Handlers,
+  KEYBOARD,
+  createRender,
+  mockLayout,
+  mockOffset,
+  mockScrollTo,
+  mockSize,
+  setupBeforeEach,
+} from "../__fixtures__/testUtils";
+
+const render = createRender("../index.ts");
+
+let handlers: Handlers = {
+  onStart: jest.fn(),
+  onMove: jest.fn(),
+  onInteractive: jest.fn(),
+  onEnd: jest.fn(),
+};
+
+jest.mock("../../../../hooks", () => ({
+  useKeyboardHandler: jest.fn((h: Handlers) => {
+    handlers = h;
+  }),
+  useResizeMode: jest.fn(),
+}));
+
+jest.mock("../../../hooks/useScrollState", () => ({
+  __esModule: true,
+  default: jest.fn(() => ({
+    offset: mockOffset,
+    layout: mockLayout,
+    size: mockSize,
+  })),
+}));
+
+beforeEach(() => {
+  setupBeforeEach();
+});
+
+describe("`useChatKeyboard` — Android behaviors", () => {
+  it("persistent inverted: should always reset padding on close", () => {
+    mockOffset.value = 500;
+    const { result } = render({
+      inverted: true,
+      keyboardLiftBehavior: "persistent",
+    });
+
+    handlers.onStart({ height: KEYBOARD });
+    handlers.onMove({ height: KEYBOARD });
+    handlers.onEnd({ height: 0 });
+
+    expect(result.current.padding.value).toBe(0);
+  });
+
+  it("persistent inverted: should not decrease shift when NOT at end", () => {
+    mockOffset.value = 500;
+    render({
+      inverted: true,
+      keyboardLiftBehavior: "persistent",
+    });
+
+    handlers.onStart({ height: KEYBOARD });
+    handlers.onMove({ height: KEYBOARD });
+    expect(mockScrollTo).toHaveBeenCalled();
+    mockScrollTo.mockClear();
+
+    // currentShift = offsetBeforeScroll(500) + padding(300) - scroll(500) = 300
+    // effective = 200 < 300 → return (not at end, so persistent holds)
+    handlers.onMove({ height: 200 });
+    expect(mockScrollTo).not.toHaveBeenCalled();
+  });
+
+  it("persistent inverted: should scrollTo on close when at end", () => {
+    mockOffset.value = 0;
+    render({
+      inverted: true,
+      keyboardLiftBehavior: "persistent",
+    });
+
+    handlers.onStart({ height: KEYBOARD });
+    handlers.onMove({ height: KEYBOARD });
+    mockScrollTo.mockClear();
+
+    // Simulate keyboard closing
+    handlers.onStart({ height: 0 });
+    // currentShift = 0 + 300 - 0 = 300, effective = 200 < 300
+    // but at end → scrollTo called with snap to end
+    handlers.onMove({ height: 200 });
+    expect(mockScrollTo).toHaveBeenCalled();
+  });
+
+  it("persistent non-inverted: should scroll back on close when at end", () => {
+    // Position at end: offset + layout >= content - threshold → 1200 + 800 >= 2000 - 20
+    mockOffset.value = 1200;
+    render({ inverted: false, keyboardLiftBehavior: "persistent" });
+
+    handlers.onStart({ height: KEYBOARD });
+    handlers.onMove({ height: KEYBOARD });
+    mockScrollTo.mockClear();
+
+    // Simulate keyboard closing (re-capture in onStart)
+    // offsetBeforeScroll = scroll(1200) - padding(300) = 900
+    // But wasAtEnd check uses offsetBeforeScroll + padding = 900 + 300 = 1200
+    // isScrollAtEnd(1200, 800, 2000) = 1200 + 800 >= 1980 → true
+    mockOffset.value = 1500;
+    handlers.onStart({ height: 0 });
+    handlers.onMove({ height: 200 });
+    expect(mockScrollTo).toHaveBeenCalled();
+  });
+
+  it("never non-inverted: should not scroll", () => {
+    mockOffset.value = 100;
+    render({ inverted: false, keyboardLiftBehavior: "never" });
+
+    handlers.onStart({ height: KEYBOARD });
+    handlers.onMove({ height: 200 });
+
+    expect(mockScrollTo).not.toHaveBeenCalled();
+  });
+
+  it("whenAtEnd non-inverted: should scroll when at end", () => {
+    mockOffset.value = 1180;
+    render({ inverted: false, keyboardLiftBehavior: "whenAtEnd" });
+
+    handlers.onStart({ height: KEYBOARD });
+    handlers.onMove({ height: 200 });
+
+    expect(mockScrollTo).toHaveBeenCalled();
+  });
+
+  it("whenAtEnd non-inverted: should NOT scroll when NOT at end", () => {
+    mockOffset.value = 100;
+    render({ inverted: false, keyboardLiftBehavior: "whenAtEnd" });
+
+    handlers.onStart({ height: KEYBOARD });
+    handlers.onMove({ height: 200 });
+
+    expect(mockScrollTo).not.toHaveBeenCalled();
+  });
+
+  it("whenAtEnd inverted: should scroll when at end (offset near 0)", () => {
+    mockOffset.value = 0;
+    render({ inverted: true, keyboardLiftBehavior: "whenAtEnd" });
+
+    handlers.onStart({ height: KEYBOARD });
+    handlers.onMove({ height: 200 });
+
+    expect(mockScrollTo).toHaveBeenCalled();
+  });
+
+  it("whenAtEnd inverted: should NOT scroll when scrolled away", () => {
+    mockOffset.value = 500;
+    render({ inverted: true, keyboardLiftBehavior: "whenAtEnd" });
+
+    handlers.onStart({ height: KEYBOARD });
+    handlers.onMove({ height: 200 });
+
+    expect(mockScrollTo).not.toHaveBeenCalled();
+  });
+
+  it("persistent non-inverted: should track effective during opening", () => {
+    mockOffset.value = 100;
+    render({ inverted: false, keyboardLiftBehavior: "persistent" });
+
+    handlers.onStart({ height: KEYBOARD });
+    handlers.onMove({ height: 200 });
+    expect(mockScrollTo).toHaveBeenCalled();
+    mockScrollTo.mockClear();
+
+    mockOffset.value = 300;
+    handlers.onMove({ height: 100 });
+
+    // effective=100: target = clampedScrollTarget(100, 100, 2000, 800)
+    // = min(200, 1300) = 200
+    expect(mockScrollTo).toHaveBeenLastCalledWith(
+      expect.anything(),
+      0,
+      200,
+      false,
+    );
+  });
+});
diff --git a/src/components/KeyboardChatScrollView/useChatKeyboard/__tests__/closing.android.spec.ts b/src/components/KeyboardChatScrollView/useChatKeyboard/__tests__/closing.android.spec.ts
new file mode 100644
index 0000000000..d8626ca01e
--- /dev/null
+++ b/src/components/KeyboardChatScrollView/useChatKeyboard/__tests__/closing.android.spec.ts
@@ -0,0 +1,208 @@
+import {
+  type Handlers,
+  KEYBOARD,
+  createRender,
+  mockLayout,
+  mockOffset,
+  mockScrollTo,
+  mockSize,
+  setupBeforeEach,
+} from "../__fixtures__/testUtils";
+
+const render = createRender("../index.ts");
+
+let handlers: Handlers = {
+  onStart: jest.fn(),
+  onMove: jest.fn(),
+  onInteractive: jest.fn(),
+  onEnd: jest.fn(),
+};
+
+jest.mock("../../../../hooks", () => ({
+  useKeyboardHandler: jest.fn((h: Handlers) => {
+    handlers = h;
+  }),
+  useResizeMode: jest.fn(),
+}));
+
+jest.mock("../../../hooks/useScrollState", () => ({
+  __esModule: true,
+  default: jest.fn(() => ({
+    offset: mockOffset,
+    layout: mockLayout,
+    size: mockSize,
+  })),
+}));
+
+beforeEach(() => {
+  setupBeforeEach();
+});
+
+describe("`useChatKeyboard` — Android closing behaviors", () => {
+  // --- whenAtEnd non-inverted ---
+
+  it("whenAtEnd non-inverted: should NOT scroll on close when open didn't shift", () => {
+    // Not at end: 100 + 800 < 2000 - 20
+    mockOffset.value = 100;
+    render({ inverted: false, keyboardLiftBehavior: "whenAtEnd" });
+
+    // Keyboard opens — sentinel set to -1 (not at end)
+    handlers.onStart({ height: KEYBOARD });
+    handlers.onMove({ height: 200 });
+    expect(mockScrollTo).not.toHaveBeenCalled();
+
+    // Keyboard closes — sentinel preserved, still no scroll
+    handlers.onStart({ height: 0 });
+    handlers.onMove({ height: 100 });
+    expect(mockScrollTo).not.toHaveBeenCalled();
+  });
+
+  it("whenAtEnd non-inverted: should scroll back on close when open DID shift", () => {
+    // At end: 1200 + 800 >= 2000 - 20
+    mockOffset.value = 1200;
+    render({ inverted: false, keyboardLiftBehavior: "whenAtEnd" });
+
+    handlers.onStart({ height: KEYBOARD });
+    handlers.onMove({ height: KEYBOARD });
+    mockScrollTo.mockClear();
+
+    // User at pushed position
+    mockOffset.value = 1500;
+    handlers.onStart({ height: 0 });
+    handlers.onMove({ height: 200 });
+    expect(mockScrollTo).toHaveBeenCalled();
+  });
+
+  // --- never non-inverted ---
+
+  it("never non-inverted: should not scroll on open even when at end", () => {
+    // At end: 1200 + 800 >= 2000 - 20
+    mockOffset.value = 1200;
+    render({ inverted: false, keyboardLiftBehavior: "never" });
+
+    handlers.onStart({ height: KEYBOARD });
+    handlers.onMove({ height: 200 });
+    expect(mockScrollTo).not.toHaveBeenCalled();
+  });
+
+  it("never non-inverted: should scroll back on close when at end", () => {
+    mockOffset.value = 1200;
+    render({ inverted: false, keyboardLiftBehavior: "never" });
+
+    handlers.onStart({ height: KEYBOARD });
+    handlers.onMove({ height: KEYBOARD });
+    expect(mockScrollTo).not.toHaveBeenCalled();
+
+    // Keyboard closes: offsetBeforeScroll = 1200 - 300 = 900
+    handlers.onStart({ height: 0 });
+    handlers.onMove({ height: 200 });
+    // wasAtEnd: isScrollAtEnd(900+300, 800, 2000) = 2000 >= 1980 → true
+    // target = clampedScrollTarget(900, 200, 2000, 800) = min(1100, 1400) = 1100
+    expect(mockScrollTo).toHaveBeenLastCalledWith(
+      expect.anything(),
+      0,
+      1100,
+      false,
+    );
+  });
+
+  // --- persistent non-inverted ---
+
+  it("persistent non-inverted: should maintain position on close (keepAt within range)", () => {
+    mockOffset.value = 100;
+    render({ inverted: false, keyboardLiftBehavior: "persistent" });
+
+    handlers.onStart({ height: KEYBOARD });
+    handlers.onMove({ height: KEYBOARD });
+    mockScrollTo.mockClear();
+
+    // User at pushed position = 400
+    mockOffset.value = 400;
+    handlers.onStart({ height: 0 }); // offsetBeforeScroll = 400 - 300 = 100
+    handlers.onMove({ height: 200 });
+    // keepAt = 100 + 300 = 400, maxScroll = 2000 - 800 + 200 = 1400
+    // target = min(400, 1400) = 400
+    expect(mockScrollTo).toHaveBeenLastCalledWith(
+      expect.anything(),
+      0,
+      400,
+      false,
+    );
+  });
+
+  it("persistent non-inverted: should clamp to max when position exceeds valid range", () => {
+    // Small content so position exceeds natural max scroll
+    mockSize.value = { width: 390, height: 1000 };
+    mockOffset.value = 100;
+    render({ inverted: false, keyboardLiftBehavior: "persistent" });
+
+    handlers.onStart({ height: KEYBOARD });
+    handlers.onMove({ height: KEYBOARD });
+    mockScrollTo.mockClear();
+
+    mockOffset.value = 400;
+    handlers.onStart({ height: 0 }); // offsetBeforeScroll = 400 - 300 = 100
+    handlers.onMove({ height: 0 });
+    // keepAt = 100 + 300 = 400, maxScroll = 1000 - 800 + 0 = 200
+    // target = min(400, 200) = 200
+    expect(mockScrollTo).toHaveBeenLastCalledWith(
+      expect.anything(),
+      0,
+      200,
+      false,
+    );
+  });
+
+  // --- inverted closing gap fixes ---
+
+  it("whenAtEnd inverted: should reduce padding on close when not at end", () => {
+    mockOffset.value = 100; // not at end for inverted (end is near 0)
+    const { result } = render({
+      inverted: true,
+      keyboardLiftBehavior: "whenAtEnd",
+    });
+
+    handlers.onStart({ height: KEYBOARD });
+    handlers.onMove({ height: KEYBOARD });
+    expect(mockScrollTo).not.toHaveBeenCalled();
+
+    // Close keyboard
+    handlers.onStart({ height: 0 });
+    handlers.onMove({ height: 200 });
+    // shouldShiftContent("whenAtEnd", false) → false
+    // closing && effective(200) < padding(300) → padding reduced
+    expect(result.current.padding.value).toBe(200);
+  });
+
+  it("never inverted: should reduce padding on close when not at end", () => {
+    mockOffset.value = 100;
+    const { result } = render({
+      inverted: true,
+      keyboardLiftBehavior: "never",
+    });
+
+    handlers.onStart({ height: KEYBOARD });
+    handlers.onMove({ height: KEYBOARD });
+
+    handlers.onStart({ height: 0 });
+    handlers.onMove({ height: 200 });
+    expect(result.current.padding.value).toBe(200);
+  });
+
+  it("persistent inverted: should reduce padding on close when not at end", () => {
+    mockOffset.value = 500;
+    const { result } = render({
+      inverted: true,
+      keyboardLiftBehavior: "persistent",
+    });
+
+    handlers.onStart({ height: KEYBOARD });
+    handlers.onMove({ height: KEYBOARD });
+    mockScrollTo.mockClear();
+
+    handlers.onStart({ height: 0 });
+    handlers.onMove({ height: 200 });
+    // persistent block: effective(200) < currentShift(300), !wasAtEnd, closing → true
+    expect(result.current.padding.value).toBe(200);
+  });
+});
diff --git a/src/components/KeyboardChatScrollView/useChatKeyboard/__tests__/freeze.android.spec.ts b/src/components/KeyboardChatScrollView/useChatKeyboard/__tests__/freeze.android.spec.ts
new file mode 100644
index 0000000000..c2c051f9d6
--- /dev/null
+++ b/src/components/KeyboardChatScrollView/useChatKeyboard/__tests__/freeze.android.spec.ts
@@ -0,0 +1,80 @@
+import {
+  type Handlers,
+  KEYBOARD,
+  createRender,
+  mockLayout,
+  mockOffset,
+  mockScrollTo,
+  mockSize,
+  setupBeforeEach,
+} from "../__fixtures__/testUtils";
+
+const render = createRender("../index.ts");
+
+let handlers: Handlers = {
+  onStart: jest.fn(),
+  onMove: jest.fn(),
+  onInteractive: jest.fn(),
+  onEnd: jest.fn(),
+};
+
+jest.mock("../../../../hooks", () => ({
+  useKeyboardHandler: jest.fn((h: Handlers) => {
+    handlers = h;
+  }),
+  useResizeMode: jest.fn(),
+}));
+
+jest.mock("../../../hooks/useScrollState", () => ({
+  __esModule: true,
+  default: jest.fn(() => ({
+    offset: mockOffset,
+    layout: mockLayout,
+    size: mockSize,
+  })),
+}));
+
+beforeEach(() => {
+  setupBeforeEach();
+});
+
+describe("`useChatKeyboard` — Android freeze", () => {
+  it("should not call scrollTo on keyboard open", () => {
+    mockOffset.value = 100;
+    render({
+      inverted: false,
+      keyboardLiftBehavior: "always",
+      freeze: true,
+    });
+
+    handlers.onStart({ height: KEYBOARD });
+    handlers.onMove({ height: 200 });
+
+    expect(mockScrollTo).not.toHaveBeenCalled();
+  });
+
+  it("should not change padding on inverted keyboard open", () => {
+    const { result } = render({
+      inverted: true,
+      keyboardLiftBehavior: "always",
+      freeze: true,
+    });
+
+    handlers.onStart({ height: KEYBOARD });
+    handlers.onMove({ height: 200 });
+
+    expect(result.current.padding.value).toBe(0);
+  });
+
+  it("should not change padding in onEnd", () => {
+    const { result } = render({
+      inverted: false,
+      keyboardLiftBehavior: "always",
+      freeze: true,
+    });
+
+    handlers.onEnd({ height: KEYBOARD });
+
+    expect(result.current.padding.value).toBe(0);
+  });
+});
diff --git a/src/components/KeyboardChatScrollView/useChatKeyboard/__tests__/helpers.spec.ts b/src/components/KeyboardChatScrollView/useChatKeyboard/__tests__/helpers.spec.ts
new file mode 100644
index 0000000000..42378e351d
--- /dev/null
+++ b/src/components/KeyboardChatScrollView/useChatKeyboard/__tests__/helpers.spec.ts
@@ -0,0 +1,190 @@
+jest.mock("react-native-reanimated", () => ({
+  ...require("react-native-reanimated/mock"),
+  // eslint-disable-next-line @typescript-eslint/no-var-requires
+  interpolate: require("../__fixtures__/testUtils").mockInterpolate,
+}));
+
+import {
+  clampedScrollTarget,
+  computeIOSContentOffset,
+  getEffectiveHeight,
+  isScrollAtEnd,
+  shouldShiftContent,
+} from "../helpers";
+
+describe("`isScrollAtEnd` specification", () => {
+  it("should return true when scrolled exactly to end", () => {
+    expect(isScrollAtEnd(200, 800, 1000)).toBe(true);
+  });
+
+  it("should return true when within threshold of end", () => {
+    // 190 + 800 = 990 >= 1000 - 20 = 980
+    expect(isScrollAtEnd(190, 800, 1000)).toBe(true);
+  });
+
+  it("should return false when far from end", () => {
+    // 100 + 800 = 900 < 1000 - 20 = 980
+    expect(isScrollAtEnd(100, 800, 1000)).toBe(false);
+  });
+
+  it("should return true when content is smaller than layout", () => {
+    expect(isScrollAtEnd(0, 800, 400)).toBe(true);
+  });
+
+  it("should return true when at scroll position 0 with matching content", () => {
+    expect(isScrollAtEnd(0, 800, 800)).toBe(true);
+  });
+
+  describe("inverted", () => {
+    it("should return true when scroll offset is 0 (latest messages)", () => {
+      expect(isScrollAtEnd(0, 800, 2000, true)).toBe(true);
+    });
+
+    it("should return true when within threshold of 0", () => {
+      expect(isScrollAtEnd(15, 800, 2000, true)).toBe(true);
+    });
+
+    it("should return false when scrolled away from latest messages", () => {
+      expect(isScrollAtEnd(100, 800, 2000, true)).toBe(false);
+    });
+
+    it("should return true for negative offsets (keyboard inset)", () => {
+      expect(isScrollAtEnd(-300, 800, 2000, true)).toBe(true);
+    });
+
+    it("should return false at traditional scroll end (oldest messages)", () => {
+      // offset 1200 = contentHeight(2000) - layoutHeight(800) → oldest messages
+      expect(isScrollAtEnd(1200, 800, 2000, true)).toBe(false);
+    });
+  });
+});
+
+describe("`shouldShiftContent` specification", () => {
+  it("should always return true for `always` behavior", () => {
+    expect(shouldShiftContent("always", false)).toBe(true);
+    expect(shouldShiftContent("always", true)).toBe(true);
+  });
+
+  it("should always return false for `never` behavior", () => {
+    expect(shouldShiftContent("never", false)).toBe(false);
+    expect(shouldShiftContent("never", true)).toBe(false);
+  });
+
+  it("should return `isAtEnd` for `whenAtEnd` behavior", () => {
+    expect(shouldShiftContent("whenAtEnd", true)).toBe(true);
+    expect(shouldShiftContent("whenAtEnd", false)).toBe(false);
+  });
+
+  it("should always return true for `persistent` behavior", () => {
+    expect(shouldShiftContent("persistent", false)).toBe(true);
+    expect(shouldShiftContent("persistent", true)).toBe(true);
+  });
+});
+
+describe("`clampedScrollTarget` specification", () => {
+  it("should add keyboard height to scroll offset", () => {
+    expect(clampedScrollTarget(100, 300, 1000, 800)).toBe(400);
+  });
+
+  it("should clamp to 0 when offset is negative", () => {
+    expect(clampedScrollTarget(-500, 300, 1000, 800)).toBe(0);
+  });
+
+  it("should clamp to maxScroll when target exceeds content", () => {
+    // maxScroll = 1000 - 800 + 300 = 500
+    // target = 400 + 300 = 700 > 500
+    expect(clampedScrollTarget(400, 300, 1000, 800)).toBe(500);
+  });
+
+  it("should handle single-message case (content smaller than layout)", () => {
+    // maxScroll = max(200 - 800 + 300, 0) = max(-300, 0) = 0
+    expect(clampedScrollTarget(0, 300, 200, 800)).toBe(0);
+  });
+
+  it("should return 0 when keyboard height is 0 and scroll is at top", () => {
+    expect(clampedScrollTarget(0, 0, 1000, 800)).toBe(0);
+  });
+});
+
+describe("`getEffectiveHeight` specification", () => {
+  it("should return height as-is when offset is 0", () => {
+    expect(getEffectiveHeight(300, 300, 0)).toBe(300);
+    expect(getEffectiveHeight(150, 300, 0)).toBe(150);
+  });
+
+  it("should return height as-is when targetKeyboardHeight is 0", () => {
+    expect(getEffectiveHeight(0, 0, 50)).toBe(0);
+  });
+
+  it("should subtract offset proportionally at full keyboard height", () => {
+    // interpolate(300, [0, 300], [0, 250]) = 250
+    expect(getEffectiveHeight(300, 300, 50)).toBe(250);
+  });
+
+  it("should interpolate proportionally at intermediate heights", () => {
+    // interpolate(150, [0, 300], [0, 250]) = 125
+    expect(getEffectiveHeight(150, 300, 50)).toBe(125);
+  });
+
+  it("should return 0 when height is 0", () => {
+    expect(getEffectiveHeight(0, 300, 50)).toBe(0);
+  });
+
+  it("should clamp effective target to 0 when offset exceeds keyboard height", () => {
+    // interpolate(300, [0, 300], [0, max(300 - 400, 0)]) = interpolate(300, [0, 300], [0, 0]) = 0
+    expect(getEffectiveHeight(300, 300, 400)).toBe(0);
+  });
+});
+
+describe("`computeIOSContentOffset` specification", () => {
+  describe("non-inverted", () => {
+    it("should add keyboard height to relative scroll", () => {
+      expect(computeIOSContentOffset(100, 300, 1000, 800, false)).toBe(400);
+    });
+
+    it("should clamp to 0 when result would be negative", () => {
+      expect(computeIOSContentOffset(-500, 300, 1000, 800, false)).toBe(0);
+    });
+
+    it("should clamp to maxScroll when target exceeds content", () => {
+      // maxScroll = 1000 - 800 + 300 = 500
+      expect(computeIOSContentOffset(400, 300, 1000, 800, false)).toBe(500);
+    });
+
+    it("should handle single-message case (content smaller than layout)", () => {
+      // maxScroll = max(200 - 800 + 300, 0) = 0
+      expect(computeIOSContentOffset(0, 300, 200, 800, false)).toBe(0);
+    });
+  });
+
+  describe("inverted", () => {
+    it("should subtract keyboard height from relative scroll", () => {
+      expect(computeIOSContentOffset(500, 300, 1000, 800, true)).toBe(200);
+    });
+
+    it("should allow negative values for inverted lists", () => {
+      expect(computeIOSContentOffset(100, 300, 1000, 800, true)).toBe(-200);
+    });
+
+    it("should return negative keyboard height when scroll is at 0", () => {
+      expect(computeIOSContentOffset(0, 300, 1000, 800, true)).toBe(-300);
+    });
+
+    it("should clamp to maxScroll when relativeScroll exceeds content", () => {
+      // relativeScroll=1500, keyboardHeight=0 → 1500 exceeds maxScroll=200
+      expect(computeIOSContentOffset(1500, 0, 1000, 800, true)).toBe(200);
+    });
+
+    it("should clamp to -keyboardHeight at minimum", () => {
+      // relativeScroll=-500, keyboardHeight=300 → -500-300=-800, clamped to -300
+      expect(computeIOSContentOffset(-500, 300, 1000, 800, true)).toBe(-300);
+    });
+
+    it("should handle single-message case (content smaller than layout)", () => {
+      // maxScroll = max(200 - 800, 0) = 0
+      // relativeScroll=100, keyboardHeight=300 → 100-300=-200, clamped to -300 min, but -200 > -300
+      // max(min(-200, 0), -300) = max(-200, -300) = -200
+      expect(computeIOSContentOffset(100, 300, 200, 800, true)).toBe(-200);
+    });
+  });
+});
diff --git a/src/components/KeyboardChatScrollView/useChatKeyboard/__tests__/index.android.spec.ts b/src/components/KeyboardChatScrollView/useChatKeyboard/__tests__/index.android.spec.ts
new file mode 100644
index 0000000000..831779033c
--- /dev/null
+++ b/src/components/KeyboardChatScrollView/useChatKeyboard/__tests__/index.android.spec.ts
@@ -0,0 +1,270 @@
+import {
+  type Handlers,
+  KEYBOARD,
+  createRender,
+  mockLayout,
+  mockOffset,
+  mockScrollTo,
+  mockSize,
+  setupBeforeEach,
+} from "../__fixtures__/testUtils";
+
+const render = createRender("../index.ts");
+
+let handlers: Handlers = {
+  onStart: jest.fn(),
+  onMove: jest.fn(),
+  onInteractive: jest.fn(),
+  onEnd: jest.fn(),
+};
+
+jest.mock("../../../../hooks", () => ({
+  useKeyboardHandler: jest.fn((h: Handlers) => {
+    handlers = h;
+  }),
+  useResizeMode: jest.fn(),
+}));
+
+jest.mock("../../../hooks/useScrollState", () => ({
+  __esModule: true,
+  default: jest.fn(() => ({
+    offset: mockOffset,
+    layout: mockLayout,
+    size: mockSize,
+  })),
+}));
+
+beforeEach(() => {
+  setupBeforeEach();
+});
+
+describe("`useChatKeyboard` — Android non-inverted + always", () => {
+  it("should set padding in onStart and scrollTo in onMove", () => {
+    mockOffset.value = 100;
+    const { result } = render({
+      inverted: false,
+      keyboardLiftBehavior: "always",
+    });
+
+    handlers.onStart({ height: KEYBOARD });
+    expect(result.current.padding.value).toBe(KEYBOARD);
+
+    handlers.onMove({ height: 200 });
+    expect(mockScrollTo).toHaveBeenCalledWith(expect.anything(), 0, 300, false);
+  });
+
+  it("should call scrollTo with growing values per-frame", () => {
+    mockOffset.value = 100;
+    render({ inverted: false, keyboardLiftBehavior: "always" });
+
+    handlers.onStart({ height: KEYBOARD });
+
+    handlers.onMove({ height: 150 });
+    expect(mockScrollTo).toHaveBeenLastCalledWith(
+      expect.anything(),
+      0,
+      250,
+      false,
+    );
+
+    handlers.onMove({ height: KEYBOARD });
+    expect(mockScrollTo).toHaveBeenLastCalledWith(
+      expect.anything(),
+      0,
+      400,
+      false,
+    );
+  });
+
+  it("should return undefined for contentOffsetY", () => {
+    const { result } = render({
+      inverted: false,
+      keyboardLiftBehavior: "always",
+    });
+
+    expect(result.current.contentOffsetY).toBeUndefined();
+  });
+
+  it("should scroll back from current position on keyboard close", () => {
+    mockOffset.value = 100;
+    render({ inverted: false, keyboardLiftBehavior: "always" });
+
+    // keyboard opens: offsetBeforeScroll = 100
+    handlers.onStart({ height: KEYBOARD });
+    handlers.onMove({ height: KEYBOARD });
+    mockScrollTo.mockClear();
+
+    // user scrolls up to 200 while keyboard is open
+    mockOffset.value = 200;
+
+    // keyboard starts closing: re-captures offsetBeforeScroll = 200 - 300 = -100
+    handlers.onStart({ height: 0 });
+
+    // dismiss frame: target = clamp(-100 + 150, 0, ...) = 50
+    handlers.onMove({ height: 150 });
+    expect(mockScrollTo).toHaveBeenLastCalledWith(
+      expect.anything(),
+      0,
+      50,
+      false,
+    );
+
+    // final frame: target = clamp(-100 + 0, 0, ...) = 0
+    handlers.onMove({ height: 0 });
+    expect(mockScrollTo).toHaveBeenLastCalledWith(
+      expect.anything(),
+      0,
+      0,
+      false,
+    );
+  });
+
+  it("should not regress when user did not scroll during keyboard open", () => {
+    mockOffset.value = 100;
+    render({ inverted: false, keyboardLiftBehavior: "always" });
+
+    handlers.onStart({ height: KEYBOARD });
+    // user did NOT scroll — offset stays at what scrollTo set (100 + 300 = 400)
+    mockOffset.value = 400;
+    mockScrollTo.mockClear();
+
+    // keyboard closes: re-captures offsetBeforeScroll = 400 - 300 = 100 (same as original)
+    handlers.onStart({ height: 0 });
+
+    handlers.onMove({ height: 150 });
+    // target = clamp(100 + 150, 0, ...) = 250
+    expect(mockScrollTo).toHaveBeenLastCalledWith(
+      expect.anything(),
+      0,
+      250,
+      false,
+    );
+  });
+
+  it("should finalize padding in onEnd", () => {
+    const { result } = render({
+      inverted: false,
+      keyboardLiftBehavior: "always",
+    });
+
+    handlers.onStart({ height: KEYBOARD });
+    handlers.onEnd({ height: KEYBOARD });
+    expect(result.current.padding.value).toBe(KEYBOARD);
+
+    handlers.onEnd({ height: 0 });
+    expect(result.current.padding.value).toBe(0);
+  });
+});
+
+describe("`useChatKeyboard` — Android inverted + always", () => {
+  it("should set padding in onStart and call scrollTo in onMove", () => {
+    const { result } = render({
+      inverted: true,
+      keyboardLiftBehavior: "always",
+    });
+
+    handlers.onStart({ height: KEYBOARD });
+    expect(result.current.padding.value).toBe(KEYBOARD);
+
+    handlers.onMove({ height: 200 });
+    // target = offsetBeforeScroll(0) + padding(300) - effective(200) = 100
+    expect(mockScrollTo).toHaveBeenCalledWith(expect.anything(), 0, 100, false);
+  });
+
+  it("should call scrollTo per-frame with correct targets", () => {
+    render({ inverted: true, keyboardLiftBehavior: "always" });
+
+    handlers.onStart({ height: KEYBOARD });
+
+    handlers.onMove({ height: 100 });
+    // target = 0 + 300 - 100 = 200
+    expect(mockScrollTo).toHaveBeenLastCalledWith(
+      expect.anything(),
+      0,
+      200,
+      false,
+    );
+
+    handlers.onMove({ height: 250 });
+    // target = 0 + 300 - 250 = 50
+    expect(mockScrollTo).toHaveBeenLastCalledWith(
+      expect.anything(),
+      0,
+      50,
+      false,
+    );
+  });
+
+  it("should return undefined for contentOffsetY", () => {
+    const { result } = render({
+      inverted: true,
+      keyboardLiftBehavior: "always",
+    });
+
+    expect(result.current.contentOffsetY).toBeUndefined();
+  });
+
+  it("should scroll back on keyboard close", () => {
+    render({ inverted: true, keyboardLiftBehavior: "always" });
+
+    handlers.onStart({ height: KEYBOARD });
+    handlers.onMove({ height: KEYBOARD });
+    mockScrollTo.mockClear();
+
+    // keyboard closes: offsetBeforeScroll = scroll.value = 0
+    handlers.onStart({ height: 0 });
+
+    handlers.onMove({ height: 150 });
+    // target = 0 + 300 - 150 = 150
+    expect(mockScrollTo).toHaveBeenLastCalledWith(
+      expect.anything(),
+      0,
+      150,
+      false,
+    );
+
+    handlers.onMove({ height: 0 });
+    // target = 0 + 300 - 0 = 300
+    expect(mockScrollTo).toHaveBeenLastCalledWith(
+      expect.anything(),
+      0,
+      300,
+      false,
+    );
+  });
+
+  it("should preserve user scroll position on close", () => {
+    render({ inverted: true, keyboardLiftBehavior: "always" });
+
+    handlers.onStart({ height: KEYBOARD });
+    handlers.onMove({ height: KEYBOARD });
+    mockScrollTo.mockClear();
+
+    // user scrolled to 50 while keyboard open
+    mockOffset.value = 50;
+    handlers.onStart({ height: 0 });
+
+    handlers.onMove({ height: 150 });
+    // target = 50 + 300 - 150 = 200
+    expect(mockScrollTo).toHaveBeenLastCalledWith(
+      expect.anything(),
+      0,
+      200,
+      false,
+    );
+  });
+
+  it("should finalize padding in onEnd", () => {
+    const { result } = render({
+      inverted: true,
+      keyboardLiftBehavior: "always",
+    });
+
+    handlers.onStart({ height: KEYBOARD });
+    handlers.onEnd({ height: KEYBOARD });
+    expect(result.current.padding.value).toBe(KEYBOARD);
+
+    handlers.onEnd({ height: 0 });
+    expect(result.current.padding.value).toBe(0);
+  });
+});
diff --git a/src/components/KeyboardChatScrollView/useChatKeyboard/__tests__/index.ios.spec.ts b/src/components/KeyboardChatScrollView/useChatKeyboard/__tests__/index.ios.spec.ts
new file mode 100644
index 0000000000..c23bac82d6
--- /dev/null
+++ b/src/components/KeyboardChatScrollView/useChatKeyboard/__tests__/index.ios.spec.ts
@@ -0,0 +1,354 @@
+import {
+  type Handlers,
+  KEYBOARD,
+  createRender,
+  mockLayout,
+  mockOffset,
+  mockScrollTo,
+  mockSize,
+  setupBeforeEach,
+} from "../__fixtures__/testUtils";
+
+const render = createRender("../index.ios");
+
+let handlers: Handlers = {
+  onStart: jest.fn(),
+  onMove: jest.fn(),
+  onInteractive: jest.fn(),
+  onEnd: jest.fn(),
+};
+
+jest.mock("../../../../hooks", () => ({
+  useKeyboardHandler: jest.fn((h: Handlers) => {
+    handlers = h;
+  }),
+  useResizeMode: jest.fn(),
+}));
+
+jest.mock("../../../hooks/useScrollState", () => ({
+  __esModule: true,
+  default: jest.fn(() => ({
+    offset: mockOffset,
+    layout: mockLayout,
+    size: mockSize,
+  })),
+}));
+
+beforeEach(() => {
+  setupBeforeEach();
+});
+
+describe("`useChatKeyboard` — iOS non-inverted + always", () => {
+  it("should set padding and contentOffsetY on keyboard open", () => {
+    mockOffset.value = 100;
+    const { result } = render({
+      inverted: false,
+      keyboardLiftBehavior: "always",
+    });
+
+    handlers.onStart({ height: KEYBOARD });
+
+    expect(result.current.padding.value).toBe(KEYBOARD);
+    expect(result.current.contentOffsetY!.value).toBe(400);
+  });
+
+  it("should restore contentOffsetY on keyboard close", () => {
+    mockOffset.value = 100;
+    const { result } = render({
+      inverted: false,
+      keyboardLiftBehavior: "always",
+    });
+
+    handlers.onStart({ height: KEYBOARD });
+    mockOffset.value = 400;
+    handlers.onStart({ height: 0 });
+
+    expect(result.current.padding.value).toBe(0);
+    expect(result.current.contentOffsetY!.value).toBe(100);
+  });
+
+  it("should handle keyboard resize (emoji toggle)", () => {
+    mockOffset.value = 100;
+    const { result } = render({
+      inverted: false,
+      keyboardLiftBehavior: "always",
+    });
+
+    handlers.onStart({ height: 300 });
+    mockOffset.value = 400;
+    handlers.onStart({ height: 350 });
+
+    expect(result.current.padding.value).toBe(350);
+    expect(result.current.contentOffsetY!.value).toBe(450);
+  });
+
+  it("should clamp contentOffsetY when content is short", () => {
+    mockSize.value = { width: 390, height: 500 };
+    mockOffset.value = 0;
+    const { result } = render({
+      inverted: false,
+      keyboardLiftBehavior: "always",
+    });
+
+    handlers.onStart({ height: KEYBOARD });
+
+    expect(result.current.contentOffsetY!.value).toBe(0);
+  });
+
+  it("should not call scrollTo on iOS", () => {
+    render({ inverted: false, keyboardLiftBehavior: "always" });
+
+    handlers.onStart({ height: KEYBOARD });
+    handlers.onMove({ height: 150 });
+
+    expect(mockScrollTo).not.toHaveBeenCalled();
+  });
+});
+
+describe("`useChatKeyboard` — iOS inverted + always", () => {
+  it("should set inverted contentOffsetY on keyboard open", () => {
+    const { result } = render({
+      inverted: true,
+      keyboardLiftBehavior: "always",
+    });
+
+    handlers.onStart({ height: KEYBOARD });
+
+    expect(result.current.contentOffsetY!.value).toBe(-KEYBOARD);
+  });
+
+  it("should restore contentOffsetY on keyboard close", () => {
+    const { result } = render({
+      inverted: true,
+      keyboardLiftBehavior: "always",
+    });
+
+    handlers.onStart({ height: KEYBOARD });
+    mockOffset.value = -300;
+    handlers.onStart({ height: 0 });
+
+    expect(result.current.contentOffsetY!.value).toBe(0);
+  });
+
+  it("should account for user scrolling while keyboard open", () => {
+    const { result } = render({
+      inverted: true,
+      keyboardLiftBehavior: "always",
+    });
+
+    handlers.onStart({ height: KEYBOARD });
+    mockOffset.value = -250;
+    handlers.onStart({ height: 0 });
+
+    expect(result.current.contentOffsetY!.value).toBe(50);
+  });
+
+  it("should handle keyboard resize (inverted)", () => {
+    const { result } = render({
+      inverted: true,
+      keyboardLiftBehavior: "always",
+    });
+
+    handlers.onStart({ height: 300 });
+    mockOffset.value = -300;
+    handlers.onStart({ height: 350 });
+
+    expect(result.current.contentOffsetY!.value).toBe(-350);
+  });
+
+  it("should clamp contentOffsetY when at max scroll on keyboard close", () => {
+    const { result } = render({
+      inverted: true,
+      keyboardLiftBehavior: "always",
+    });
+
+    // keyboard opens
+    handlers.onStart({ height: KEYBOARD });
+
+    // user scrolls to visual top (max scroll offset)
+    // maxScroll = contentHeight(2000) - layoutHeight(800) = 1200
+    mockOffset.value = 1200;
+    handlers.onStart({ height: 0 });
+
+    // relativeScroll = 1200 + 300 = 1500, but maxScroll without keyboard = 1200
+    // should be clamped to 1200, not 1500
+    expect(result.current.contentOffsetY!.value).toBe(1200);
+  });
+});
+
+describe("`useChatKeyboard` — iOS behaviors", () => {
+  it("never: should set padding but preserve current scroll position", () => {
+    mockOffset.value = 100;
+    const { result } = render({
+      inverted: false,
+      keyboardLiftBehavior: "never",
+    });
+
+    handlers.onStart({ height: KEYBOARD });
+
+    expect(result.current.padding.value).toBe(KEYBOARD);
+    // contentOffsetY must match current scroll position so animated props
+    // don't re-apply a stale contentOffset when padding changes
+    expect(result.current.contentOffsetY!.value).toBe(100);
+  });
+
+  it("never: should snap to end on close when at end to avoid ghost padding", () => {
+    mockOffset.value = 100;
+    const { result } = render({
+      inverted: false,
+      keyboardLiftBehavior: "never",
+    });
+
+    // open keyboard
+    handlers.onStart({ height: KEYBOARD });
+
+    // user scrolls to end while keyboard is open
+    // end with padding: contentHeight(2000) - layoutHeight(800) + padding(300) = 1500
+    mockOffset.value = 1500;
+    handlers.onStart({ height: 0 });
+
+    expect(result.current.padding.value).toBe(0);
+    // should snap to natural end (2000 - 800 = 1200), not stay at 1500
+    expect(result.current.contentOffsetY!.value).toBe(1200);
+  });
+
+  it("never: should preserve position on close when NOT at end", () => {
+    mockOffset.value = 100;
+    const { result } = render({
+      inverted: false,
+      keyboardLiftBehavior: "never",
+    });
+
+    handlers.onStart({ height: KEYBOARD });
+
+    // user stays in the middle
+    mockOffset.value = 500;
+    handlers.onStart({ height: 0 });
+
+    expect(result.current.padding.value).toBe(0);
+    expect(result.current.contentOffsetY!.value).toBe(500);
+  });
+
+  it("never + inverted: should snap to end on close when at end", () => {
+    mockOffset.value = 500;
+    const { result } = render({
+      inverted: true,
+      keyboardLiftBehavior: "never",
+    });
+
+    // open keyboard
+    handlers.onStart({ height: KEYBOARD });
+
+    // user scrolls to end (offset near 0 for inverted)
+    mockOffset.value = 0;
+    handlers.onStart({ height: 0 });
+
+    expect(result.current.padding.value).toBe(0);
+    expect(result.current.contentOffsetY!.value).toBe(-0);
+  });
+
+  it("whenAtEnd: should shift when at the end", () => {
+    mockOffset.value = 1180;
+    const { result } = render({
+      inverted: false,
+      keyboardLiftBehavior: "whenAtEnd",
+    });
+
+    handlers.onStart({ height: KEYBOARD });
+
+    expect(result.current.contentOffsetY!.value).toBe(1480);
+  });
+
+  it("whenAtEnd: should preserve scroll position when far from the end", () => {
+    mockOffset.value = 100;
+    const { result } = render({
+      inverted: false,
+      keyboardLiftBehavior: "whenAtEnd",
+    });
+
+    handlers.onStart({ height: KEYBOARD });
+
+    // contentOffsetY must match current scroll position so animated props
+    // don't re-apply a stale contentOffset when padding changes
+    expect(result.current.contentOffsetY!.value).toBe(100);
+  });
+
+  it("whenAtEnd + inverted: should shift when at latest messages (offset near 0)", () => {
+    mockOffset.value = 0;
+    const { result } = render({
+      inverted: true,
+      keyboardLiftBehavior: "whenAtEnd",
+    });
+
+    handlers.onStart({ height: KEYBOARD });
+
+    expect(result.current.contentOffsetY!.value).toBe(-KEYBOARD);
+  });
+
+  it("whenAtEnd + inverted: should preserve scroll position when scrolled to older messages", () => {
+    mockOffset.value = 500;
+    const { result } = render({
+      inverted: true,
+      keyboardLiftBehavior: "whenAtEnd",
+    });
+
+    handlers.onStart({ height: KEYBOARD });
+
+    // contentOffsetY must match current scroll position so animated props
+    // don't re-apply a stale contentOffset when padding changes
+    expect(result.current.contentOffsetY!.value).toBe(500);
+  });
+
+  it("onEnd: should finalize padding", () => {
+    const { result } = render({
+      inverted: false,
+      keyboardLiftBehavior: "always",
+    });
+
+    handlers.onEnd({ height: KEYBOARD });
+    expect(result.current.padding.value).toBe(KEYBOARD);
+
+    handlers.onEnd({ height: 0 });
+    expect(result.current.padding.value).toBe(0);
+  });
+});
+
+describe("`useChatKeyboard` — iOS freeze", () => {
+  it("should not change padding on keyboard open", () => {
+    mockOffset.value = 100;
+    const { result } = render({
+      inverted: false,
+      keyboardLiftBehavior: "always",
+      freeze: true,
+    });
+
+    handlers.onStart({ height: KEYBOARD });
+
+    expect(result.current.padding.value).toBe(0);
+  });
+
+  it("should not change contentOffsetY on keyboard open", () => {
+    mockOffset.value = 100;
+    const { result } = render({
+      inverted: false,
+      keyboardLiftBehavior: "always",
+      freeze: true,
+    });
+
+    handlers.onStart({ height: KEYBOARD });
+
+    expect(result.current.contentOffsetY!.value).toBe(0);
+  });
+
+  it("should not change padding in onEnd", () => {
+    const { result } = render({
+      inverted: false,
+      keyboardLiftBehavior: "always",
+      freeze: true,
+    });
+
+    handlers.onEnd({ height: KEYBOARD });
+
+    expect(result.current.padding.value).toBe(0);
+  });
+});
diff --git a/src/components/KeyboardChatScrollView/useChatKeyboard/__tests__/interactive.android.spec.ts b/src/components/KeyboardChatScrollView/useChatKeyboard/__tests__/interactive.android.spec.ts
new file mode 100644
index 0000000000..141b9e74c9
--- /dev/null
+++ b/src/components/KeyboardChatScrollView/useChatKeyboard/__tests__/interactive.android.spec.ts
@@ -0,0 +1,79 @@
+import {
+  type Handlers,
+  KEYBOARD,
+  createRender,
+  mockOffset,
+  mockScrollTo,
+  setupBeforeEach,
+} from "../__fixtures__/testUtils";
+
+const render = createRender("../index.ts");
+
+let handlers: Handlers = {
+  onStart: jest.fn(),
+  onMove: jest.fn(),
+  onInteractive: jest.fn(),
+  onEnd: jest.fn(),
+};
+
+jest.mock("../../../../hooks", () => ({
+  useKeyboardHandler: jest.fn((h: Handlers) => {
+    handlers = h;
+  }),
+  useResizeMode: jest.fn(),
+}));
+
+jest.mock("../../../hooks/useScrollState", () => ({
+  __esModule: true,
+  default: jest.fn(() => ({
+    offset: mockOffset,
+    layout: { value: { width: 390, height: 800 } },
+    size: { value: { width: 390, height: 2000 } },
+  })),
+}));
+
+beforeEach(() => {
+  setupBeforeEach();
+});
+
+describe("`useChatKeyboard` — Android post-interactive snap-back (inverted)", () => {
+  it("should skip snap-back (duration=-1) in onStart", () => {
+    const { result } = render({
+      inverted: true,
+      keyboardLiftBehavior: "always",
+    });
+
+    // snap-back event without prior open → padding stays 0
+    handlers.onStart({ height: KEYBOARD, duration: -1 });
+    expect(result.current.padding.value).toBe(0);
+  });
+
+  it("should skip snap-back (duration=-1) in onMove", () => {
+    render({ inverted: true, keyboardLiftBehavior: "always" });
+
+    // Normal keyboard open
+    handlers.onStart({ height: KEYBOARD });
+    handlers.onMove({ height: KEYBOARD });
+    mockScrollTo.mockClear();
+
+    // User scrolls while keyboard is open
+    mockOffset.value = 100;
+
+    // Post-interactive snap-back events — should be entirely skipped
+    handlers.onStart({ height: KEYBOARD, duration: -1 });
+    handlers.onMove({ height: 200, duration: -1 });
+
+    expect(mockScrollTo).not.toHaveBeenCalled();
+  });
+
+  it("should not skip normal events with duration !== -1", () => {
+    render({ inverted: true, keyboardLiftBehavior: "always" });
+
+    handlers.onStart({ height: KEYBOARD });
+    mockScrollTo.mockClear();
+
+    // Normal onMove (no duration or duration > 0)
+    handlers.onMove({ height: 200 });
+    expect(mockScrollTo).toHaveBeenCalled();
+  });
+});
diff --git a/src/components/KeyboardChatScrollView/useChatKeyboard/__tests__/offset.android.spec.ts b/src/components/KeyboardChatScrollView/useChatKeyboard/__tests__/offset.android.spec.ts
new file mode 100644
index 0000000000..10988fd78b
--- /dev/null
+++ b/src/components/KeyboardChatScrollView/useChatKeyboard/__tests__/offset.android.spec.ts
@@ -0,0 +1,167 @@
+import {
+  type Handlers,
+  KEYBOARD,
+  createRender,
+  mockLayout,
+  mockOffset,
+  mockScrollTo,
+  mockSize,
+  setupBeforeEach,
+} from "../__fixtures__/testUtils";
+
+const render = createRender("../index.ts");
+
+let handlers: Handlers = {
+  onStart: jest.fn(),
+  onMove: jest.fn(),
+  onInteractive: jest.fn(),
+  onEnd: jest.fn(),
+};
+
+jest.mock("../../../../hooks", () => ({
+  useKeyboardHandler: jest.fn((h: Handlers) => {
+    handlers = h;
+  }),
+  useResizeMode: jest.fn(),
+}));
+
+jest.mock("../../../hooks/useScrollState", () => ({
+  __esModule: true,
+  default: jest.fn(() => ({
+    offset: mockOffset,
+    layout: mockLayout,
+    size: mockSize,
+  })),
+}));
+
+beforeEach(() => {
+  setupBeforeEach();
+});
+
+const OFFSET = 50;
+
+describe("`useChatKeyboard` — Android non-inverted + offset", () => {
+  it("should set padding to effective height (keyboard - offset)", () => {
+    mockOffset.value = 100;
+    const { result } = render({
+      inverted: false,
+      keyboardLiftBehavior: "always",
+      offset: OFFSET,
+    });
+
+    handlers.onStart({ height: KEYBOARD });
+    // effective = interpolate(300, [0, 300], [0, 250]) = 250
+    expect(result.current.padding.value).toBe(KEYBOARD - OFFSET);
+  });
+
+  it("should scrollTo with effective height per-frame", () => {
+    mockOffset.value = 100;
+    render({
+      inverted: false,
+      keyboardLiftBehavior: "always",
+      offset: OFFSET,
+    });
+
+    handlers.onStart({ height: KEYBOARD });
+
+    handlers.onMove({ height: 150 });
+    // effective = interpolate(150, [0, 300], [0, 250]) = 125
+    expect(mockScrollTo).toHaveBeenLastCalledWith(
+      expect.anything(),
+      0,
+      225,
+      false,
+    );
+
+    handlers.onMove({ height: KEYBOARD });
+    // effective = 250
+    expect(mockScrollTo).toHaveBeenLastCalledWith(
+      expect.anything(),
+      0,
+      350,
+      false,
+    );
+  });
+
+  it("should scroll back correctly on keyboard close with offset", () => {
+    mockOffset.value = 100;
+    render({
+      inverted: false,
+      keyboardLiftBehavior: "always",
+      offset: OFFSET,
+    });
+
+    handlers.onStart({ height: KEYBOARD });
+    handlers.onMove({ height: KEYBOARD });
+    // user didn't scroll — offset stays at 100 + 250 = 350
+    mockOffset.value = 350;
+    mockScrollTo.mockClear();
+
+    // keyboard closes: offsetBeforeScroll = 350 - 250 = 100
+    handlers.onStart({ height: 0 });
+
+    handlers.onMove({ height: 150 });
+    // effective = interpolate(150, [0, 300], [0, 250]) = 125
+    // target = clamp(100 + 125, 0, ...) = 225
+    expect(mockScrollTo).toHaveBeenLastCalledWith(
+      expect.anything(),
+      0,
+      225,
+      false,
+    );
+  });
+
+  it("should finalize padding with effective height in onEnd", () => {
+    const { result } = render({
+      inverted: false,
+      keyboardLiftBehavior: "always",
+      offset: OFFSET,
+    });
+
+    handlers.onStart({ height: KEYBOARD });
+    handlers.onEnd({ height: KEYBOARD });
+    expect(result.current.padding.value).toBe(KEYBOARD - OFFSET);
+
+    handlers.onEnd({ height: 0 });
+    expect(result.current.padding.value).toBe(0);
+  });
+});
+
+describe("`useChatKeyboard` — Android inverted + offset", () => {
+  it("should call scrollTo with effective height per-frame", () => {
+    render({
+      inverted: true,
+      keyboardLiftBehavior: "always",
+      offset: OFFSET,
+    });
+
+    handlers.onStart({ height: KEYBOARD });
+    // padding = effective = interpolate(300, [0, 300], [0, 250]) = 250
+
+    handlers.onMove({ height: 200 });
+    // effective = interpolate(200, [0, 300], [0, 250]) = 166.67
+    // target = offsetBeforeScroll(0) + padding(250) - effective(166.67) = 83.33
+    const effective = 200 * ((KEYBOARD - OFFSET) / KEYBOARD);
+
+    expect(mockScrollTo).toHaveBeenLastCalledWith(
+      expect.anything(),
+      0,
+      expect.closeTo(KEYBOARD - OFFSET - effective),
+      false,
+    );
+  });
+
+  it("should reset padding on keyboard close", () => {
+    const { result } = render({
+      inverted: true,
+      keyboardLiftBehavior: "always",
+      offset: OFFSET,
+    });
+
+    handlers.onStart({ height: KEYBOARD });
+    handlers.onMove({ height: KEYBOARD });
+    handlers.onEnd({ height: 0 });
+
+    expect(result.current.padding.value).toBe(0);
+  });
+});
diff --git a/src/components/KeyboardChatScrollView/useChatKeyboard/__tests__/offset.ios.spec.ts b/src/components/KeyboardChatScrollView/useChatKeyboard/__tests__/offset.ios.spec.ts
new file mode 100644
index 0000000000..b71ff5678f
--- /dev/null
+++ b/src/components/KeyboardChatScrollView/useChatKeyboard/__tests__/offset.ios.spec.ts
@@ -0,0 +1,141 @@
+import {
+  type Handlers,
+  KEYBOARD,
+  createRender,
+  mockLayout,
+  mockOffset,
+  mockScrollTo,
+  mockSize,
+  setupBeforeEach,
+} from "../__fixtures__/testUtils";
+
+const render = createRender("../index.ios");
+
+let handlers: Handlers = {
+  onStart: jest.fn(),
+  onMove: jest.fn(),
+  onInteractive: jest.fn(),
+  onEnd: jest.fn(),
+};
+
+jest.mock("../../../../hooks", () => ({
+  useKeyboardHandler: jest.fn((h: Handlers) => {
+    handlers = h;
+  }),
+  useResizeMode: jest.fn(),
+}));
+
+jest.mock("../../../hooks/useScrollState", () => ({
+  __esModule: true,
+  default: jest.fn(() => ({
+    offset: mockOffset,
+    layout: mockLayout,
+    size: mockSize,
+  })),
+}));
+
+beforeEach(() => {
+  setupBeforeEach();
+});
+
+const OFFSET = 50;
+
+describe("`useChatKeyboard` — iOS non-inverted + offset", () => {
+  it("should set padding to effective height", () => {
+    mockOffset.value = 100;
+    const { result } = render({
+      inverted: false,
+      keyboardLiftBehavior: "always",
+      offset: OFFSET,
+    });
+
+    handlers.onStart({ height: KEYBOARD });
+
+    // effective = interpolate(300, [0, 300], [0, 250]) = 250
+    expect(result.current.padding.value).toBe(KEYBOARD - OFFSET);
+  });
+
+  it("should compute contentOffsetY with effective height", () => {
+    mockOffset.value = 100;
+    const { result } = render({
+      inverted: false,
+      keyboardLiftBehavior: "always",
+      offset: OFFSET,
+    });
+
+    handlers.onStart({ height: KEYBOARD });
+
+    // effective = 250
+    // contentOffsetY = computeIOSContentOffset(100, 250, 2000, 800, false)
+    //   = min(max(250 + 100, 0), max(2000 - 800 + 250, 0))
+    //   = min(350, 1450) = 350
+    expect(result.current.contentOffsetY!.value).toBe(350);
+  });
+
+  it("should restore contentOffsetY on keyboard close", () => {
+    mockOffset.value = 100;
+    const { result } = render({
+      inverted: false,
+      keyboardLiftBehavior: "always",
+      offset: OFFSET,
+    });
+
+    handlers.onStart({ height: KEYBOARD });
+    // effective padding = 250, user is now at scroll offset 350
+    mockOffset.value = 350;
+    handlers.onStart({ height: 0 });
+
+    // relativeScroll = 350 - 250 = 100 (original position)
+    // effective = interpolate(0, [0, 300], [0, 250]) = 0
+    // padding = 0
+    // contentOffsetY = computeIOSContentOffset(100, 0, 2000, 800, false)
+    //   = min(max(0 + 100, 0), max(2000 - 800, 0)) = 100
+    expect(result.current.padding.value).toBe(0);
+    expect(result.current.contentOffsetY!.value).toBe(100);
+  });
+
+  it("should not call scrollTo on iOS", () => {
+    render({
+      inverted: false,
+      keyboardLiftBehavior: "always",
+      offset: OFFSET,
+    });
+
+    handlers.onStart({ height: KEYBOARD });
+    handlers.onMove({ height: 150 });
+
+    expect(mockScrollTo).not.toHaveBeenCalled();
+  });
+
+  it("should finalize padding with effective height in onEnd", () => {
+    const { result } = render({
+      inverted: false,
+      keyboardLiftBehavior: "always",
+      offset: OFFSET,
+    });
+
+    handlers.onStart({ height: KEYBOARD });
+    handlers.onEnd({ height: KEYBOARD });
+    expect(result.current.padding.value).toBe(KEYBOARD - OFFSET);
+
+    handlers.onEnd({ height: 0 });
+    expect(result.current.padding.value).toBe(0);
+  });
+});
+
+describe("`useChatKeyboard` — iOS inverted + offset", () => {
+  it("should set inverted contentOffsetY with effective height", () => {
+    const { result } = render({
+      inverted: true,
+      keyboardLiftBehavior: "always",
+      offset: OFFSET,
+    });
+
+    handlers.onStart({ height: KEYBOARD });
+
+    // effective = 250
+    // contentOffsetY = computeIOSContentOffset(0, 250, 2000, 800, true)
+    //   = 0 - 250 = -250
+    expect(result.current.contentOffsetY!.value).toBe(-(KEYBOARD - OFFSET));
+  });
+});
diff --git a/src/components/KeyboardChatScrollView/useChatKeyboard/__tests__/persistent.ios.spec.ts b/src/components/KeyboardChatScrollView/useChatKeyboard/__tests__/persistent.ios.spec.ts
new file mode 100644
index 0000000000..b7bc00ea51
--- /dev/null
+++ b/src/components/KeyboardChatScrollView/useChatKeyboard/__tests__/persistent.ios.spec.ts
@@ -0,0 +1,180 @@
+import {
+  type Handlers,
+  KEYBOARD,
+  createRender,
+  mockOffset,
+  mockSize,
+  setupBeforeEach,
+} from "../__fixtures__/testUtils";
+
+const render = createRender("../index.ios");
+
+let handlers: Handlers = {
+  onStart: jest.fn(),
+  onMove: jest.fn(),
+  onInteractive: jest.fn(),
+  onEnd: jest.fn(),
+};
+
+jest.mock("../../../../hooks", () => ({
+  useKeyboardHandler: jest.fn((h: Handlers) => {
+    handlers = h;
+  }),
+  useResizeMode: jest.fn(),
+}));
+
+jest.mock("../../../hooks/useScrollState", () => ({
+  __esModule: true,
+  default: jest.fn(() => ({
+    offset: mockOffset,
+    layout: { value: { width: 390, height: 800 } },
+    size: mockSize,
+  })),
+}));
+
+beforeEach(() => {
+  setupBeforeEach();
+});
+
+describe("`useChatKeyboard` — iOS persistent non-inverted", () => {
+  it("should push content up on keyboard open", () => {
+    mockOffset.value = 100;
+    const { result } = render({
+      inverted: false,
+      keyboardLiftBehavior: "persistent",
+    });
+
+    handlers.onStart({ height: KEYBOARD });
+
+    expect(result.current.padding.value).toBe(KEYBOARD);
+    expect(result.current.contentOffsetY!.value).toBe(400);
+  });
+
+  it("should snap to end of content on keyboard close when at end", () => {
+    mockOffset.value = 1180;
+    const { result } = render({
+      inverted: false,
+      keyboardLiftBehavior: "persistent",
+    });
+
+    handlers.onStart({ height: KEYBOARD });
+    // keyboard pushed us to 1480, which is at end (1480+800 >= 1980)
+    mockOffset.value = 1480;
+    handlers.onStart({ height: 0 });
+
+    expect(result.current.padding.value).toBe(0);
+    // snaps to end of content (2000 - 800 = 1200), not back to 1180
+    expect(result.current.contentOffsetY!.value).toBe(1200);
+  });
+
+  it("should preserve current scroll position on close when NOT at end", () => {
+    mockOffset.value = 1180;
+    const { result } = render({
+      inverted: false,
+      keyboardLiftBehavior: "persistent",
+    });
+
+    handlers.onStart({ height: KEYBOARD });
+
+    // user scrolls away from end while keyboard is open
+    mockOffset.value = 500;
+    handlers.onStart({ height: 0 });
+
+    expect(result.current.padding.value).toBe(0);
+    // contentOffsetY must match current scroll position so animated props
+    // don't re-apply the stale offset from keyboard open
+    expect(result.current.contentOffsetY!.value).toBe(500);
+  });
+
+  it("should push content up again after close + re-open", () => {
+    mockOffset.value = 1180;
+    const { result } = render({
+      inverted: false,
+      keyboardLiftBehavior: "persistent",
+    });
+
+    // open → close (user scrolled away)
+    handlers.onStart({ height: KEYBOARD });
+    mockOffset.value = 500;
+    handlers.onStart({ height: 0 });
+
+    expect(result.current.padding.value).toBe(0);
+
+    // re-open → should push up from current position
+    handlers.onStart({ height: KEYBOARD });
+
+    expect(result.current.padding.value).toBe(KEYBOARD);
+    expect(result.current.contentOffsetY!.value).toBe(800);
+  });
+
+  it("should snap to end on keyboard resize when at end", () => {
+    mockOffset.value = 1180;
+    const { result } = render({
+      inverted: false,
+      keyboardLiftBehavior: "persistent",
+    });
+
+    handlers.onStart({ height: KEYBOARD });
+
+    // keyboard shrinks (e.g. emoji → text), user still at end
+    mockOffset.value = 1480;
+    handlers.onStart({ height: 200 });
+
+    expect(result.current.padding.value).toBe(200);
+    // end = 2000 - 800 + 200 = 1400
+    expect(result.current.contentOffsetY!.value).toBe(1400);
+  });
+});
+
+describe("`useChatKeyboard` — iOS persistent inverted", () => {
+  it("should push content up on keyboard open", () => {
+    mockOffset.value = 0;
+    const { result } = render({
+      inverted: true,
+      keyboardLiftBehavior: "persistent",
+    });
+
+    handlers.onStart({ height: KEYBOARD });
+
+    expect(result.current.padding.value).toBe(KEYBOARD);
+    expect(result.current.contentOffsetY!.value).toBe(-KEYBOARD);
+  });
+
+  it("should preserve current scroll position on close when NOT at end", () => {
+    // scrolled to older messages (not at end for inverted)
+    mockOffset.value = 500;
+    const { result } = render({
+      inverted: true,
+      keyboardLiftBehavior: "persistent",
+    });
+
+    handlers.onStart({ height: KEYBOARD });
+
+    // user scrolls further while keyboard is open
+    mockOffset.value = 400;
+    handlers.onStart({ height: 0 });
+
+    expect(result.current.padding.value).toBe(0);
+    // contentOffsetY must match current scroll position so animated props
+    // don't re-apply the stale offset from keyboard open
+    expect(result.current.contentOffsetY!.value).toBe(400);
+  });
+
+  it("should snap to end on keyboard close when at end", () => {
+    // at newest messages (at end for inverted = offset near 0)
+    mockOffset.value = 0;
+    const { result } = render({
+      inverted: true,
+      keyboardLiftBehavior: "persistent",
+    });
+
+    handlers.onStart({ height: KEYBOARD });
+    // user stays at newest messages with keyboard inset
+    mockOffset.value = -300;
+    handlers.onStart({ height: 0 });
+
+    expect(result.current.padding.value).toBe(0);
+    // -effective where effective = 0 produces -0
+    expect(result.current.contentOffsetY!.value).toBe(-0);
+  });
+});
diff --git a/src/components/KeyboardChatScrollView/useChatKeyboard/helpers.ts b/src/components/KeyboardChatScrollView/useChatKeyboard/helpers.ts
new file mode 100644
index 0000000000..5fdb840647
--- /dev/null
+++ b/src/components/KeyboardChatScrollView/useChatKeyboard/helpers.ts
@@ -0,0 +1,163 @@
+import { interpolate } from "react-native-reanimated";
+
+import type { KeyboardLiftBehavior } from "./types";
+
+const AT_END_THRESHOLD = 20;
+
+/**
+ * Map the current keyboard height to an effective height that accounts for a
+ * fixed offset (e.g. bottom safe-area or tab-bar height).
+ *
+ * @param height - Current keyboard height.
+ * @param targetKeyboardHeight - Full target keyboard height (captured on keyboard open).
+ * @param offset - Fixed distance between the scroll-view bottom and the screen bottom.
+ * @returns Effective height after subtracting the offset proportionally.
+ * @example
+ * ```ts
+ * getEffectiveHeight(300, 300, 50); // 250
+ * getEffectiveHeight(150, 300, 50); // 125
+ * ```
+ */
+export function getEffectiveHeight(
+  height: number,
+  targetKeyboardHeight: number,
+  offset: number,
+): number {
+  "worklet";
+
+  if (offset === 0 || targetKeyboardHeight === 0) {
+    return height;
+  }
+
+  return interpolate(
+    height,
+    [0, targetKeyboardHeight],
+    [0, Math.max(targetKeyboardHeight - offset, 0)],
+  );
+}
+
+/**
+ * Check whether the scroll view is at the end of its content.
+ *
+ * For non-inverted lists the "end" is the bottom of the content.
+ * For inverted lists the "end" is the top (scroll offset near 0),
+ * because that is where the latest messages are displayed.
+ *
+ * @param scrollOffset - Current vertical scroll offset.
+ * @param layoutHeight - Visible height of the scroll view.
+ * @param contentHeight - Total height of the scrollable content.
+ * @param inverted - Whether the list is inverted.
+ * @returns `true` if the scroll position is within the threshold of the content end.
+ * @example
+ * ```ts
+ * const atEnd = isScrollAtEnd(100, 800, 920); // true (100 + 800 >= 920 - 20)
+ * const atEndInverted = isScrollAtEnd(5, 800, 2000, true); // true (5 <= 20)
+ * ```
+ */
+export function isScrollAtEnd(
+  scrollOffset: number,
+  layoutHeight: number,
+  contentHeight: number,
+  inverted: boolean = false,
+): boolean {
+  "worklet";
+
+  if (inverted) {
+    return scrollOffset <= AT_END_THRESHOLD;
+  }
+
+  return scrollOffset + layoutHeight >= contentHeight - AT_END_THRESHOLD;
+}
+
+/**
+ * Decide whether content should be shifted based on the keyboard lift behavior.
+ *
+ * @param behavior - The configured keyboard lift behavior.
+ * @param isAtEnd - Whether the scroll view is currently at the end.
+ * @returns `true` if content should be shifted.
+ * @example
+ * ```ts
+ * shouldShiftContent("always", false); // true
+ * shouldShiftContent("whenAtEnd", false); // false
+ * ```
+ */
+export function shouldShiftContent(
+  behavior: KeyboardLiftBehavior,
+  isAtEnd: boolean,
+): boolean {
+  "worklet";
+
+  switch (behavior) {
+    case "always":
+      return true;
+    case "never":
+      return false;
+    case "whenAtEnd":
+      return isAtEnd;
+    case "persistent":
+      return true;
+  }
+}
+
+/**
+ * Compute the clamped scroll target for non-inverted lists.
+ *
+ * @param offsetBeforeScroll - Scroll position before keyboard appeared.
+ * @param keyboardHeight - Current keyboard height.
+ * @param contentHeight - Total height of the scrollable content.
+ * @param layoutHeight - Visible height of the scroll view.
+ * @returns Clamped scroll target between 0 and maxScroll.
+ * @example
+ * ```ts
+ * clampedScrollTarget(100, 300, 1000, 800); // 400
+ * ```
+ */
+export function clampedScrollTarget(
+  offsetBeforeScroll: number,
+  keyboardHeight: number,
+  contentHeight: number,
+  layoutHeight: number,
+): number {
+  "worklet";
+
+  const maxScroll = Math.max(contentHeight - layoutHeight + keyboardHeight, 0);
+
+  return Math.min(Math.max(offsetBeforeScroll + keyboardHeight, 0), maxScroll);
+}
+
+/**
+ * Compute contentOffset.y for iOS lists.
+ *
+ * @param relativeScroll - Scroll position relative to current inset.
+ * @param keyboardHeight - Target keyboard height.
+ * @param contentHeight - Total height of the scrollable content.
+ * @param layoutHeight - Visible height of the scroll view.
+ * @param inverted - Whether the list is inverted.
+ * @returns The absolute contentOffset.y to set.
+ * @example
+ * ```ts
+ * computeIOSContentOffset(100, 300, 1000, 800, false); // 400
+ * ```
+ */
+export function computeIOSContentOffset(
+  relativeScroll: number,
+  keyboardHeight: number,
+  contentHeight: number,
+  layoutHeight: number,
+  inverted: boolean,
+): number {
+  "worklet";
+
+  if (inverted) {
+    const maxScroll = Math.max(contentHeight - layoutHeight, 0);
+
+    return Math.max(
+      Math.min(relativeScroll - keyboardHeight, maxScroll),
+      -keyboardHeight,
+    );
+  }
+
+  const maxScroll = Math.max(contentHeight - layoutHeight + keyboardHeight, 0);
+
+  return Math.min(Math.max(keyboardHeight + relativeScroll, 0), maxScroll);
+}
diff --git a/src/components/KeyboardChatScrollView/useChatKeyboard/index.ios.ts b/src/components/KeyboardChatScrollView/useChatKeyboard/index.ios.ts
new file mode 100644
index 0000000000..06fa48736c
--- /dev/null
+++ b/src/components/KeyboardChatScrollView/useChatKeyboard/index.ios.ts
@@ -0,0 +1,180 @@
+import { useSharedValue } from "react-native-reanimated";
+
+import { useKeyboardHandler } from "../../../hooks";
+import useScrollState from "../../hooks/useScrollState";
+
+import {
+  computeIOSContentOffset,
+  getEffectiveHeight,
+  isScrollAtEnd,
+  shouldShiftContent,
+} from "./helpers";
+
+import type { UseChatKeyboardOptions, UseChatKeyboardReturn } from "./types";
+import type { AnimatedRef } from "react-native-reanimated";
+import type Reanimated from "react-native-reanimated";
+
+/**
+ * Hook that manages keyboard-driven scrolling for chat-style scroll views.
+ * Calculates padding (extra scrollable space) and content shift values,
+ * using iOS-specific strategy (contentOffset set once in onStart).
+ *
+ * @param scrollViewRef - Animated ref to the scroll view.
+ * @param options - Configuration for inverted and keyboardLiftBehavior.
+ * @returns Shared values for padding and contentOffsetY.
+ * @example
+ * ```tsx
+ * const { padding, contentOffsetY } = useChatKeyboard(ref, {
+ *   inverted: false,
+ *   keyboardLiftBehavior: "always",
+ * });
+ * ```
+ */
+function useChatKeyboard(
+  scrollViewRef: AnimatedRef<Reanimated.ScrollView>,
+  options: UseChatKeyboardOptions,
+): UseChatKeyboardReturn {
+  const { inverted, keyboardLiftBehavior, freeze, offset } = options;
+
+  const padding = useSharedValue(0);
+  const currentHeight = useSharedValue(0);
+  const contentOffsetY = useSharedValue(0);
+  const targetKeyboardHeight = useSharedValue(0);
+
+  const {
+    layout,
+    size,
+    offset: scroll,
+    onLayout,
+    onContentSizeChange,
+  } = useScrollState(scrollViewRef);
+
+  useKeyboardHandler(
+    {
+      onStart: (e) => {
+        "worklet";
+
+        if (freeze) {
+          return;
+        }
+
+        if (e.height > 0) {
+          // eslint-disable-next-line react-compiler/react-compiler
+          targetKeyboardHeight.value = e.height;
+        }
+
+        const effective = getEffectiveHeight(
+          e.height,
+          targetKeyboardHeight.value,
+          offset,
+        );
+
+        const atEnd = isScrollAtEnd(
+          scroll.value,
+          layout.value.height,
+          size.value.height,
+          inverted,
+        );
+
+        // persistent mode: when keyboard shrinks, snap to end or hold position
+        if (
+          keyboardLiftBehavior === "persistent" &&
+          effective < padding.value
+        ) {
+          padding.value = effective;
+
+          if (atEnd) {
+            if (inverted) {
+              contentOffsetY.value = -effective;
+            } else {
+              contentOffsetY.value = Math.max(
+                size.value.height - layout.value.height + effective,
+                0,
+              );
+            }
+          } else {
+            // Preserve current scroll position so the animated props
+            // don't re-apply the stale contentOffset from keyboard open
+            contentOffsetY.value = scroll.value;
+          }
+
+          return;
+        }
+
+        // never mode: when keyboard shrinks and at end, snap to end
+        // to avoid ghost padding
+        if (
+          keyboardLiftBehavior === "never" &&
+          effective < padding.value &&
+          atEnd
+        ) {
+          padding.value = effective;
+
+          if (inverted) {
+            contentOffsetY.value = -effective;
+          } else {
+            contentOffsetY.value = Math.max(
+              size.value.height - layout.value.height + effective,
+              0,
+            );
+          }
+
+          return;
+        }
+
+        const relativeScroll = inverted
+          ? scroll.value + padding.value
+          : scroll.value - padding.value;
+
+        padding.value = effective;
+
+        if (!shouldShiftContent(keyboardLiftBehavior, atEnd)) {
+          // Preserve current scroll position so animated props
+          // don't re-apply a stale contentOffset when padding changes
+          contentOffsetY.value = scroll.value;
+
+          return;
+        }
+
+        contentOffsetY.value = computeIOSContentOffset(
+          relativeScroll,
+          effective,
+          size.value.height,
+          layout.value.height,
+          inverted,
+        );
+      },
+      onMove: () => {
+        "worklet";
+
+        // iOS doesn't need per-frame updates (contentOffset handles it)
+      },
+      onEnd: (e) => {
+        "worklet";
+
+        if (freeze) {
+          return;
+        }
+
+        const effective = getEffectiveHeight(
+          e.height,
+          targetKeyboardHeight.value,
+          offset,
+        );
+
+        padding.value = effective;
+      },
+    },
+    [inverted, keyboardLiftBehavior, freeze, offset],
+  );
+
+  return {
+    padding,
+    currentHeight,
+    contentOffsetY,
+    onLayout,
+    onContentSizeChange,
+  };
+}
+
+export { useChatKeyboard };
diff --git a/src/components/KeyboardChatScrollView/useChatKeyboard/index.ts b/src/components/KeyboardChatScrollView/useChatKeyboard/index.ts
new file mode 100644
index 0000000000..b3e2d89c34
--- /dev/null
+++ b/src/components/KeyboardChatScrollView/useChatKeyboard/index.ts
@@ -0,0 +1,300 @@
+import { scrollTo, useSharedValue } from "react-native-reanimated";
+
+import { useKeyboardHandler } from "../../../hooks";
+import useScrollState from "../../hooks/useScrollState";
+
+import {
+  clampedScrollTarget,
+  getEffectiveHeight,
+  isScrollAtEnd,
+  shouldShiftContent,
+} from "./helpers";
+
+import type { UseChatKeyboardOptions, UseChatKeyboardReturn } from "./types";
+import type { AnimatedRef } from "react-native-reanimated";
+import type Reanimated from "react-native-reanimated";
+
+/**
+ * Hook that manages keyboard-driven scrolling for chat-style scroll views.
+ * Calculates padding (extra scrollable space) and content shift values,
+ * using per-frame scrollTo updates (Android and other platforms).
+ *
+ * @param scrollViewRef - Animated ref to the scroll view.
+ * @param options - Configuration for inverted and keyboardLiftBehavior.
+ * @returns Shared values for padding and contentOffsetY (always `undefined`).
+ * @example
+ * ```tsx
+ * const { padding, contentOffsetY } = useChatKeyboard(ref, {
+ *   inverted: false,
+ *   keyboardLiftBehavior: "always",
+ * });
+ * ```
+ */
+function useChatKeyboard(
+  scrollViewRef: AnimatedRef<Reanimated.ScrollView>,
+  options: UseChatKeyboardOptions,
+): UseChatKeyboardReturn {
+  const { inverted, keyboardLiftBehavior, freeze, offset } = options;
+
+  const padding = useSharedValue(0);
+  const currentHeight = useSharedValue(0);
+  const offsetBeforeScroll = useSharedValue(0);
+  const targetKeyboardHeight = useSharedValue(0);
+  const closing = useSharedValue(false);
+
+  const {
+    layout,
+    size,
+    offset: scroll,
+    onLayout,
+    onContentSizeChange,
+  } = useScrollState(scrollViewRef);
+
+  const clampScrollIfNeeded = (effective: number) => {
+    "worklet";
+
+    const maxScroll = Math.max(
+      size.value.height - layout.value.height + effective,
+      0,
+    );
+
+    if (scroll.value > maxScroll) {
+      scrollTo(scrollViewRef, 0, maxScroll, false);
+    }
+  };
+
+  useKeyboardHandler(
+    {
+      onStart: (e) => {
+        "worklet";
+
+        if (freeze) {
+          return;
+        }
+
+        if (e.height > 0) {
+          // eslint-disable-next-line react-compiler/react-compiler
+          targetKeyboardHeight.value = e.height;
+          closing.value = false;
+        } else {
+          closing.value = true;
+        }
+
+        const effective = getEffectiveHeight(
+          e.height,
+          targetKeyboardHeight.value,
+          offset,
+        );
+
+        const atEnd = isScrollAtEnd(
+          scroll.value,
+          layout.value.height,
+          size.value.height,
+          inverted,
+        );
+
+        if (inverted && e.duration === -1) {
+          // Android inverted: skip post-interactive snap-back events
+          // (duration === -1 means the keyboard is re-establishing its
+          // position after an interactive gesture, not a real animation)
+          return;
+        } else if (e.height > 0) {
+          // Android: keyboard opening — set padding + capture scroll position
+          padding.value = effective;
+          offsetBeforeScroll.value = scroll.value;
+
+          if (!inverted && keyboardLiftBehavior === "whenAtEnd" && !atEnd) {
+            // Sentinel: don't scroll in onMove (non-inverted only)
+            offsetBeforeScroll.value = -1;
+          }
+        } else {
+          // Android: keyboard closing — re-capture scroll position
+          if (inverted) {
+            offsetBeforeScroll.value = scroll.value;
+          } else {
+            // Preserve "whenAtEnd" sentinel: if open didn't shift, close shouldn't either
+            if (offsetBeforeScroll.value !== -1) {
+              // Non-inverted: subtract padding to get the "natural" position
+              // so onMove smoothly scrolls back from where the user is now
+              offsetBeforeScroll.value = scroll.value - padding.value;
+            }
+          }
+        }
+      },
+      onMove: (e) => {
+        "worklet";
+
+        if (freeze) {
+          return;
+        }
+
+        currentHeight.value = e.height;
+
+        if (inverted) {
+          // Skip post-interactive snap-back (duration === -1)
+          if (e.duration === -1) {
+            return;
+          }
+
+          const effective = getEffectiveHeight(
+            e.height,
+            targetKeyboardHeight.value,
+            offset,
+          );
+
+          // Check if we should shift content based on position when keyboard started
+          const wasAtEnd = isScrollAtEnd(
+            offsetBeforeScroll.value,
+            layout.value.height,
+            size.value.height,
+            inverted,
+          );
+
+          // "never" at end: scroll along when keyboard closes to avoid jump
+          if (
+            keyboardLiftBehavior === "never" &&
+            wasAtEnd &&
+            effective < padding.value
+          ) {
+            padding.value = effective;
+            scrollTo(scrollViewRef, 0, 0, false);
+
+            return;
+          }
+
+          if (!shouldShiftContent(keyboardLiftBehavior, wasAtEnd)) {
+            // Closing, not shifting: reduce padding to avoid gap
+            if (closing.value && effective < padding.value) {
+              padding.value = effective;
+              clampScrollIfNeeded(effective);
+            }
+
+            return;
+          }
+
+          // Persistent: don't let shift decrease
+          if (keyboardLiftBehavior === "persistent") {
+            const currentShift =
+              offsetBeforeScroll.value + padding.value - scroll.value;
+
+            if (effective < currentShift) {
+              // When at end, allow scrolling back (snap to end + reduce padding)
+              if (wasAtEnd) {
+                padding.value = effective;
+                scrollTo(scrollViewRef, 0, 0, false);
+              } else if (closing.value) {
+                // Not at end: reduce padding to avoid gap
+                padding.value = effective;
+                clampScrollIfNeeded(effective);
+              }
+
+              return;
+            }
+          }
+
+          const target = offsetBeforeScroll.value + padding.value - effective;
+
+          scrollTo(scrollViewRef, 0, target, false);
+        } else {
+          const effective = getEffectiveHeight(
+            e.height,
+            targetKeyboardHeight.value,
+            offset,
+          );
+
+          // "never" closing: scroll along when at end to avoid jump
+          if (
+            keyboardLiftBehavior === "never" &&
+            closing.value &&
+            effective < padding.value
+          ) {
+            const wasAtEnd = isScrollAtEnd(
+              offsetBeforeScroll.value + padding.value,
+              layout.value.height,
+              size.value.height,
+              false,
+            );
+
+            if (wasAtEnd) {
+              const target = clampedScrollTarget(
+                offsetBeforeScroll.value,
+                effective,
+                size.value.height,
+                layout.value.height,
+              );
+
+              scrollTo(scrollViewRef, 0, target, false);
+            } else {
+              // Clamp to valid range as padding shrinks
+              clampScrollIfNeeded(effective);
+            }
+
+            return;
+          }
+
+          if (!shouldShiftContent(keyboardLiftBehavior, true)) {
+            return;
+          }
+
+          // "whenAtEnd" sentinel check
+          if (offsetBeforeScroll.value === -1) {
+            if (closing.value) {
+              // Keyboard didn't shift on open; ensure valid position on close
+              clampScrollIfNeeded(effective);
+            }
+
+            return;
+          }
+
+          // "persistent" closing: maintain position, clamped to valid range
+          if (keyboardLiftBehavior === "persistent" && closing.value) {
+            const keepAt = offsetBeforeScroll.value + padding.value;
+            const maxScroll = Math.max(
+              size.value.height - layout.value.height + effective,
+              0,
+            );
+
+            scrollTo(scrollViewRef, 0, Math.min(keepAt, maxScroll), false);
+
+            return;
+          }
+
+          const target = clampedScrollTarget(
+            offsetBeforeScroll.value,
+            effective,
+            size.value.height,
+            layout.value.height,
+          );
+
+          scrollTo(scrollViewRef, 0, target, false);
+        }
+      },
+      onEnd: (e) => {
+        "worklet";
+
+        if (freeze) {
+          return;
+        }
+
+        const effective = getEffectiveHeight(
+          e.height,
+          targetKeyboardHeight.value,
+          offset,
+        );
+
+        padding.value = effective;
+      },
+    },
+    [inverted, keyboardLiftBehavior, freeze, offset],
+  );
+
+  return {
+    padding,
+    currentHeight,
+    contentOffsetY: undefined,
+    onLayout,
+    onContentSizeChange,
+  };
+}
+
+export { useChatKeyboard };
diff --git a/src/components/KeyboardChatScrollView/useChatKeyboard/types.ts b/src/components/KeyboardChatScrollView/useChatKeyboard/types.ts
new file mode 100644
index 0000000000..a4c9ca527a
--- /dev/null
+++ b/src/components/KeyboardChatScrollView/useChatKeyboard/types.ts
@@ -0,0 +1,30 @@
+import type { LayoutChangeEvent } from "react-native";
+import type { SharedValue } from "react-native-reanimated";
+
+type KeyboardLiftBehavior = "always" | "whenAtEnd" | "persistent" | "never";
+
+type UseChatKeyboardOptions = {
+  inverted: boolean;
+  keyboardLiftBehavior: KeyboardLiftBehavior;
+  freeze: boolean;
+  offset: number;
+};
+
+type UseChatKeyboardReturn = {
+  /** Extra scrollable space (= keyboard height). Used as contentInset on iOS, contentInsetBottom/contentInsetTop on Android. */
+  padding: SharedValue<number>;
+  /** Raw keyboard height updated every frame in onMove. Used to force Reanimated commits on Fabric. */
+  currentHeight: SharedValue<number>;
+  /** Absolute Y content offset for iOS (set once in onStart). `undefined` on Android. */
+  contentOffsetY: SharedValue<number> | undefined;
+  /** Callback to attach to ScrollView's onLayout prop to capture initial viewport dimensions. */
+  onLayout: (e: LayoutChangeEvent) => void;
+  /** Callback to attach to ScrollView's onContentSizeChange prop to capture initial content dimensions. */
+  onContentSizeChange: (w: number, h: number) => void;
+};
+
+export type {
+  KeyboardLiftBehavior,
+  UseChatKeyboardOptions,
+  UseChatKeyboardReturn,
+};
diff --git a/src/components/KeyboardStickyView/index.tsx b/src/components/KeyboardStickyView/index.tsx
index 13cab817e1..68baa1287e 100644
--- a/src/components/KeyboardStickyView/index.tsx
+++ b/src/components/KeyboardStickyView/index.tsx
@@ -64,11 +64,7 @@ const KeyboardStickyView = forwardRef<
 
       return [
         {
-          transform: [
-            {
-              translateY: enabled ? active : disabled,
-            },
-          ],
+          transform: [{ translateY: enabled ? active : disabled }],
         },
         style,
       ];
diff --git a/src/components/ScrollViewWithBottomPadding/index.tsx b/src/components/ScrollViewWithBottomPadding/index.tsx
index 2a70b06606..79132cf967 100644
--- a/src/components/ScrollViewWithBottomPadding/index.tsx
+++ b/src/components/ScrollViewWithBottomPadding/index.tsx
@@ -1,5 +1,5 @@
 import React, { forwardRef } from "react";
-import { Platform } from "react-native";
+import { Platform, View } from "react-native";
 import Reanimated, { useAnimatedProps } from "react-native-reanimated";
 
 import { ClippingScrollView } from "../../bindings";
@@ -9,8 +9,9 @@ import styles from "./styles";
 import type { ScrollViewProps } from "react-native";
 import type { SharedValue } from "react-native-reanimated";
 
+const OS = Platform.OS;
 const ReanimatedClippingScrollView =
-  Platform.OS === "android"
+  OS === "android"
     ? Reanimated.createAnimatedComponent(ClippingScrollView)
     : ClippingScrollView;
 
@@ -25,7 +26,10 @@ export type AnimatedScrollViewComponent = React.ForwardRefExoticComponent<
 type ScrollViewWithBottomPaddingProps = {
   ScrollViewComponent: AnimatedScrollViewComponent;
   children?: React.ReactNode;
+  inverted?: boolean;
   bottomPadding: SharedValue<number>;
+  /** Absolute Y content offset (iOS only, for KeyboardChatScrollView). */
+  contentOffsetY?: SharedValue<number>;
 } & ScrollViewProps;
 
 const ScrollViewWithBottomPadding = forwardRef<
@@ -33,28 +37,60 @@ const ScrollViewWithBottomPadding = forwardRef<
   ScrollViewWithBottomPaddingProps
 >(
   (
-    { ScrollViewComponent, bottomPadding, contentInset, children, ...rest },
+    {
+      ScrollViewComponent,
+      bottomPadding,
+      contentInset,
+      scrollIndicatorInsets,
+      inverted,
+      contentOffsetY,
+      children,
+      ...rest
+    },
     ref,
   ) => {
-    const animatedProps = useAnimatedProps(
-      () => ({
+    const animatedProps = useAnimatedProps(() => {
+      const insetTop = inverted ? bottomPadding.value : 0;
+      const insetBottom = !inverted ? bottomPadding.value : 0;
+      const bottom = insetBottom + (contentInset?.bottom || 0);
+      const top = insetTop + (contentInset?.top || 0);
+
+      const result: Record<string, unknown> = {
         // iOS prop
         contentInset: {
-          bottom: bottomPadding.value + (contentInset?.bottom || 0),
-          top: contentInset?.top,
+          bottom: bottom,
+          top: top,
           right: contentInset?.right,
           left: contentInset?.left,
         },
+        scrollIndicatorInsets: {
+          bottom: bottom,
+          top: top,
+          right: scrollIndicatorInsets?.right,
+          left: scrollIndicatorInsets?.left,
+        },
         // Android prop
-        contentInsetBottom: bottomPadding.value,
-      }),
-      [
-        contentInset?.bottom,
-        contentInset?.top,
-        contentInset?.right,
-        contentInset?.left,
-      ],
-    );
+        contentInsetBottom: insetBottom,
+        contentInsetTop: insetTop,
+      };
+
+      if (contentOffsetY) {
+        result.contentOffset = { x: 0, y: contentOffsetY.value };
+      }
+
+      return result;
+    }, [
+      contentInset?.bottom,
+      contentInset?.top,
+      contentInset?.right,
+      contentInset?.left,
+      scrollIndicatorInsets?.bottom,
+      scrollIndicatorInsets?.top,
+      scrollIndicatorInsets?.right,
+      scrollIndicatorInsets?.left,
+      inverted,
+      contentOffsetY,
+    ]);
 
     return (
       <ReanimatedClippingScrollView
@@ -62,7 +98,17 @@ const ScrollViewWithBottomPadding = forwardRef<
         style={styles.container}
       >
         <ScrollViewComponent ref={ref} animatedProps={animatedProps} {...rest}>
-          {children}
+          {inverted ? (
+            // The only thing it can break is `StickyHeader`, but it's already broken in FlatList and other lists
+            // don't support this functionality, so we can add additional view here
+            // The correct fix would be to add a new prop in ScrollView that allows
+            // to customize children extraction logic and skip custom view
+            <View collapsable={false} nativeID="container">
+              {children}
+            </View>
+          ) : (
+            children
+          )}
         </ScrollViewComponent>
       </ReanimatedClippingScrollView>
     );
diff --git a/src/components/hooks/useScrollState.ts b/src/components/hooks/useScrollState.ts
index 663df7ab45..74486ac33b 100644
--- a/src/components/hooks/useScrollState.ts
+++ b/src/components/hooks/useScrollState.ts
@@ -1,8 +1,9 @@
-import { useEffect } from "react";
+import { useCallback, useEffect } from "react";
 import { useEvent, useSharedValue } from "react-native-reanimated";
 
 import { useEventHandlerRegistration } from "../../internal";
 
+import type { LayoutChangeEvent } from "react-native";
 import type { AnimatedRef } from "react-native-reanimated";
 import type Reanimated from "react-native-reanimated";
 
@@ -53,7 +54,28 @@ const useScrollState = (ref: AnimatedRef<Reanimated.ScrollView>) => {
     };
   }, []);
 
-  return { offset, layout, size };
+  // `onContentSizeChange` is synthesized in JS (from the content container's
+  // onLayout) and `onLayout` has a different payload shape than scroll events,
+  // so neither can be reliably captured via native event registration.
+  // Instead we expose callbacks for the consumer to attach as props.
+  const onLayout = useCallback(
+    (e: LayoutChangeEvent) => {
+      layout.value = {
+        width: e.nativeEvent.layout.width,
+        height: e.nativeEvent.layout.height,
+      };
+    },
+    [layout],
+  );
+
+  const onContentSizeChange = useCallback(
+    (w: number, h: number) => {
+      size.value = { width: w, height: h };
+    },
+    [size],
+  );
+
+  return { offset, layout, size, onLayout, onContentSizeChange };
 };
 
 export default useScrollState;
diff --git a/src/components/index.ts b/src/components/index.ts
index 2a6983a1cb..3a05547bbe 100644
--- a/src/components/index.ts
+++ b/src/components/index.ts
@@ -5,6 +5,7 @@ export {
   default as KeyboardToolbar,
   DefaultKeyboardToolbarTheme,
 } from "./KeyboardToolbar";
+export { default as KeyboardChatScrollView } from "./KeyboardChatScrollView";
 export type { KeyboardAvoidingViewProps } from "./KeyboardAvoidingView";
 export type { KeyboardStickyViewProps } from "./KeyboardStickyView";
 export type {
@@ -12,3 +13,4 @@ export type {
   KeyboardAwareScrollViewRef,
 } from "./KeyboardAwareScrollView";
 export type { KeyboardToolbarProps } from "./KeyboardToolbar";
+export type { KeyboardChatScrollViewProps } from "./KeyboardChatScrollView/types";
diff --git a/src/index.ts b/src/index.ts
index b12a853a81..10f655b9e8 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -8,6 +8,7 @@ export * from "./types";
 export * from "./compat";
 
 export {
+  KeyboardChatScrollView,
   KeyboardAvoidingView,
   KeyboardStickyView,
   KeyboardAwareScrollView,
@@ -16,6 +17,7 @@ export {
   DefaultKeyboardToolbarTheme,
 } from "./components";
 export type {
+  KeyboardChatScrollViewProps,
   KeyboardAvoidingViewProps,
   KeyboardStickyViewProps,
   KeyboardAwareScrollViewProps,
diff --git a/src/specs/ClippingScrollViewDecoratorViewNativeComponent.ts b/src/specs/ClippingScrollViewDecoratorViewNativeComponent.ts
index 8c2a56fdec..0a331cd553 100644
--- a/src/specs/ClippingScrollViewDecoratorViewNativeComponent.ts
+++ b/src/specs/ClippingScrollViewDecoratorViewNativeComponent.ts
@@ -6,6 +6,7 @@ import type { Double } from "react-native/Libraries/Types/CodegenTypes";
 
 export interface NativeProps extends ViewProps {
   contentInsetBottom: Double;
+  contentInsetTop: Double;
 }
 
 export default codegenNativeComponent<NativeProps>(
diff --git a/src/types/views.ts b/src/types/views.ts
index ebbca2a35a..b961e9666e 100644
--- a/src/types/views.ts
+++ b/src/types/views.ts
@@ -53,5 +53,7 @@ export type ClippingScrollViewProps = PropsWithChildren<
   ViewProps & {
     /** An additional space that gets applied to the bottom of the `ScrollView` (inside a scrollable content). Default is `0`. */
     contentInsetBottom?: number;
+    /** An additional space that gets applied to the top of the `ScrollView` (inside a scrollable content). Default is `0`. */
+    contentInsetTop?: number;
   }
 >;
diff --git a/yarn.lock b/yarn.lock
index 43a2c7dbcb..8126fc2be9 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -1378,6 +1378,11 @@
   dependencies:
     "@jest/types" "^29.6.3"
 
+"@jest/diff-sequences@30.0.1":
+  version "30.0.1"
+  resolved "https://registry.yarnpkg.com/@jest/diff-sequences/-/diff-sequences-30.0.1.tgz#0ededeae4d071f5c8ffe3678d15f3a1be09156be"
+  integrity sha512-n5H8QLDJ47QqbCNn5SuFjCRDrOLEZ0h8vAHCK5RL9Ls7Xa8AQLa/YxAc9UjFqoEDM48muwtBGjtMY5cr0PLDCw==
+
 "@jest/environment@^29.7.0":
   version "29.7.0"
   resolved "https://registry.yarnpkg.com/@jest/environment/-/environment-29.7.0.tgz#24d61f54ff1f786f3cd4073b4b94416383baf2a7"
@@ -1415,6 +1420,11 @@
     jest-mock "^29.7.0"
     jest-util "^29.7.0"
 
+"@jest/get-type@30.1.0":
+  version "30.1.0"
+  resolved "https://registry.yarnpkg.com/@jest/get-type/-/get-type-30.1.0.tgz#4fcb4dc2ebcf0811be1c04fd1cb79c2dba431cbc"
+  integrity sha512-eMbZE2hUnx1WV0pmURZY9XoXPkUYjpc55mb0CrhtdWLtzMQPFvu/rZkTLZFTsdaVQa+Tr4eWAteqcUzoawq/uA==
+
 "@jest/globals@^29.7.0":
   version "29.7.0"
   resolved "https://registry.yarnpkg.com/@jest/globals/-/globals-29.7.0.tgz#8d9290f9ec47ff772607fa864ca1d5a2efae1d4d"
@@ -1455,6 +1465,13 @@
     strip-ansi "^6.0.0"
     v8-to-istanbul "^9.0.1"
 
+"@jest/schemas@30.0.5":
+  version "30.0.5"
+  resolved "https://registry.yarnpkg.com/@jest/schemas/-/schemas-30.0.5.tgz#7bdf69fc5a368a5abdb49fd91036c55225846473"
+  integrity sha512-DmdYgtezMkh3cpU8/1uyXakv3tJRcmcXxBOcO0tbaozPwpmh4YMsnWrQm9ZmZMfa5ocbxzbFk6O4bDPEc/iAnA==
+  dependencies:
+    "@sinclair/typebox" "^0.34.0"
+
 "@jest/schemas@^29.6.3":
   version "29.6.3"
   resolved "https://registry.yarnpkg.com/@jest/schemas/-/schemas-29.6.3.tgz#430b5ce8a4e0044a7e3819663305a7b3091c8e03"
@@ -1885,6 +1902,11 @@
   resolved "https://registry.yarnpkg.com/@sinclair/typebox/-/typebox-0.27.8.tgz#6667fac16c436b5434a387a34dedb013198f6e6e"
   integrity sha512-+Fj43pSMwJs4KRrH/938Uf+uAELIgVBmQzg/q1YG10djyfA3TnrU8N8XzqCh/okZdszqBQTZf96idMfE5lnwTA==
 
+"@sinclair/typebox@^0.34.0":
+  version "0.34.48"
+  resolved "https://registry.yarnpkg.com/@sinclair/typebox/-/typebox-0.34.48.tgz#75b0ead87e59e1adbd6dccdc42bad4fddee73b59"
+  integrity sha512-kKJTNuK3AQOrgjjotVxMrCn1sUJwM76wMszfq1kdU4uYVJjvEWuFQ6HgvLt4Xz3fSmZlTOxJ/Ie13KnIcWQXFA==
+
 "@sindresorhus/is@^0.14.0":
   version "0.14.0"
   resolved "https://registry.yarnpkg.com/@sindresorhus/is/-/is-0.14.0.tgz#9fb3a3cf3132328151f353de4632e01e52102bea"
@@ -1919,6 +1941,16 @@
     "@babel/runtime" "^7.12.5"
     react-error-boundary "^3.1.0"
 
+"@testing-library/react-native@^13.3.3":
+  version "13.3.3"
+  resolved "https://registry.yarnpkg.com/@testing-library/react-native/-/react-native-13.3.3.tgz#4bf02911c4e18075df40b5de0e029c209fb45bda"
+  integrity sha512-k6Mjsd9dbZgvY4Bl7P1NIpePQNi+dfYtlJ5voi9KQlynxSyQkfOgJmYGCYmw/aSgH/rUcFvG8u5gd4npzgRDyg==
+  dependencies:
+    jest-matcher-utils "^30.0.5"
+    picocolors "^1.1.1"
+    pretty-format "^30.0.5"
+    redent "^3.0.0"
+
 "@tootallnate/once@1":
   version "1.1.2"
   resolved "https://registry.yarnpkg.com/@tootallnate/once/-/once-1.1.2.tgz#ccb91445360179a04e7fe6aff78c00ffc1eeaf82"
@@ -2499,7 +2531,7 @@ ansi-styles@^4.0.0, ansi-styles@^4.1.0:
   dependencies:
     color-convert "^2.0.1"
 
-ansi-styles@^5.0.0:
+ansi-styles@^5.0.0, ansi-styles@^5.2.0:
   version "5.2.0"
   resolved "https://registry.yarnpkg.com/ansi-styles/-/ansi-styles-5.2.0.tgz#07449690ad45777d1924ac2abb2fc8895dba836b"
   integrity sha512-Cxwpt2SfTzTtXcfOlzGEee8O+c+MmUgGrNiBcXnuWxuFJHe6a5Hz7qwhwe5OgaSYI0IJvkLqWX1ASG+cJOkEiA==
@@ -2971,7 +3003,7 @@ chalk@4.1.0:
     ansi-styles "^4.1.0"
     supports-color "^7.1.0"
 
-chalk@4.1.2, chalk@^4.0.0, chalk@^4.1.0, chalk@^4.1.1:
+chalk@4.1.2, chalk@^4.0.0, chalk@^4.1.0, chalk@^4.1.1, chalk@^4.1.2:
   version "4.1.2"
   resolved "https://registry.yarnpkg.com/chalk/-/chalk-4.1.2.tgz#aac4e2b7734a740867aeb16bf02aad556a1e7a01"
   integrity sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==
@@ -5648,6 +5680,16 @@ jest-config@^29.7.0:
     slash "^3.0.0"
     strip-json-comments "^3.1.1"
 
+jest-diff@30.2.0:
+  version "30.2.0"
+  resolved "https://registry.yarnpkg.com/jest-diff/-/jest-diff-30.2.0.tgz#e3ec3a6ea5c5747f605c9e874f83d756cba36825"
+  integrity sha512-dQHFo3Pt4/NLlG5z4PxZ/3yZTZ1C7s9hveiOj+GCN+uT109NC2QgsoVZsVOAvbJ3RgKkvyLGXZV9+piDpWbm6A==
+  dependencies:
+    "@jest/diff-sequences" "30.0.1"
+    "@jest/get-type" "30.1.0"
+    chalk "^4.1.2"
+    pretty-format "30.2.0"
+
 jest-diff@^29.7.0:
   version "29.7.0"
   resolved "https://registry.yarnpkg.com/jest-diff/-/jest-diff-29.7.0.tgz#017934a66ebb7ecf6f205e84699be10afd70458a"
@@ -5730,6 +5772,16 @@ jest-matcher-utils@^29.7.0:
     jest-get-type "^29.6.3"
     pretty-format "^29.7.0"
 
+jest-matcher-utils@^30.0.5:
+  version "30.2.0"
+  resolved "https://registry.yarnpkg.com/jest-matcher-utils/-/jest-matcher-utils-30.2.0.tgz#69a0d4c271066559ec8b0d8174829adc3f23a783"
+  integrity sha512-dQ94Nq4dbzmUWkQ0ANAWS9tBRfqCrn0bV9AMYdOi/MHW726xn7eQmMeRTpX2ViC00bpNaWXq+7o4lIQ3AX13Hg==
+  dependencies:
+    "@jest/get-type" "30.1.0"
+    chalk "^4.1.2"
+    jest-diff "30.2.0"
+    pretty-format "30.2.0"
+
 jest-message-util@^29.7.0:
   version "29.7.0"
   resolved "https://registry.yarnpkg.com/jest-message-util/-/jest-message-util-29.7.0.tgz#8bc392e204e95dfe7564abbe72a404e28e51f7f3"
@@ -7147,6 +7199,15 @@ prettier@^2.8.8:
   resolved "https://registry.yarnpkg.com/prettier/-/prettier-2.8.8.tgz#e8c5d7e98a4305ffe3de2e1fc4aca1a71c28b1da"
   integrity sha512-tdN8qQGvNjw4CHbY+XXk0JgCXn9QiF21a55rBe5LJAU+kDyC4WQn4+awm2Xfk2lQMk5fKup9XgzTZtGkjBdP9Q==
 
+pretty-format@30.2.0, pretty-format@^30.0.5:
+  version "30.2.0"
+  resolved "https://registry.yarnpkg.com/pretty-format/-/pretty-format-30.2.0.tgz#2d44fe6134529aed18506f6d11509d8a62775ebe"
+  integrity sha512-9uBdv/B4EefsuAL+pWqueZyZS2Ba+LxfFeQ9DN14HU4bN8bhaxKdkpjpB6fs9+pSjIBu+FXQHImEg8j/Lw0+vA==
+  dependencies:
+    "@jest/schemas" "30.0.5"
+    ansi-styles "^5.2.0"
+    react-is "^18.3.1"
+
 pretty-format@^29.0.0, pretty-format@^29.7.0:
   version "29.7.0"
   resolved "https://registry.yarnpkg.com/pretty-format/-/pretty-format-29.7.0.tgz#ca42c758310f365bfa71a0bda0a807160b776812"
@@ -7335,15 +7396,15 @@ react-is@^16.13.1:
   resolved "https://registry.yarnpkg.com/react-is/-/react-is-16.13.1.tgz#789729a4dc36de2999dc156dd6c1d9c18cea56a4"
   integrity sha512-24e6ynE2H+OKt4kqsOvNd8kBpV65zoxbA4BVsEOB3ARVWQki/DHzaUoC5KuON/BiccDaCCTZBuOcfZs70kR8bQ==
 
-react-is@^18.0.0:
+react-is@^18.0.0, react-is@^18.3.1:
   version "18.3.1"
   resolved "https://registry.yarnpkg.com/react-is/-/react-is-18.3.1.tgz#e83557dc12eae63a99e003a46388b1dcbb44db7e"
   integrity sha512-/LLMVyas0ljjAtoYiPqYiL8VWXzUUdThrmU5+n20DZv+a+ClRoevUzw5JxU+Ieh5/c87ytoTBV9G1FiKfNJdmg==
 
-react-is@^19.0.0:
-  version "19.1.0"
-  resolved "https://registry.yarnpkg.com/react-is/-/react-is-19.1.0.tgz#805bce321546b7e14c084989c77022351bbdd11b"
-  integrity sha512-Oe56aUPnkHyyDxxkvqtd7KkdQP5uIUfHxd5XTb3wE9d/kRnZLmKbDB0GWk919tdQ+mxxPtG6EAs6RMT6i1qtHg==
+react-is@^19.1.0:
+  version "19.2.4"
+  resolved "https://registry.yarnpkg.com/react-is/-/react-is-19.2.4.tgz#a080758243c572ccd4a63386537654298c99d135"
+  integrity sha512-W+EWGn2v0ApPKgKKCy/7s7WHXkboGcsrXE+2joLyVxkbyVQfO3MUEaUQDHoSmb8TFFrSKYa9mw64WZHNHSDzYA==
 
 react-native-builder-bob@^0.18.0:
   version "0.18.3"
@@ -7445,13 +7506,13 @@ react-refresh@^0.14.0:
   resolved "https://registry.yarnpkg.com/react-refresh/-/react-refresh-0.14.2.tgz#3833da01ce32da470f1f936b9d477da5c7028bf9"
   integrity sha512-jCvmsr+1IUSMUyzOkRcvnVbX3ZYC6g9TDrDbFuFmRDq7PD4yaGbLKNQL6k2jnArV8hjYxh7hVhAZB6s9HDGpZA==
 
-react-test-renderer@19.0.0:
-  version "19.0.0"
-  resolved "https://registry.yarnpkg.com/react-test-renderer/-/react-test-renderer-19.0.0.tgz#ca6fa322c58d4bfa34635788fe242a8c3daa4c7d"
-  integrity sha512-oX5u9rOQlHzqrE/64CNr0HB0uWxkCQmZNSfozlYvwE71TLVgeZxVf0IjouGEr1v7r1kcDifdAJBeOhdhxsG/DA==
+react-test-renderer@19.1.0:
+  version "19.1.0"
+  resolved "https://registry.yarnpkg.com/react-test-renderer/-/react-test-renderer-19.1.0.tgz#89e1baa9e45a6da064b9760f92251d5b8e1f34ab"
+  integrity sha512-jXkSl3CpvPYEF+p/eGDLB4sPoDX8pKkYvRl9+rR8HxLY0X04vW7hCm1/0zHoUSjPZ3bDa+wXWNTDVIw/R8aDVw==
   dependencies:
-    react-is "^19.0.0"
-    scheduler "^0.25.0"
+    react-is "^19.1.0"
+    scheduler "^0.26.0"
 
 react@19.1.0:
   version "19.1.0"
@@ -7815,16 +7876,11 @@ safe-regex-test@^1.1.0:
   resolved "https://registry.yarnpkg.com/safer-buffer/-/safer-buffer-2.1.2.tgz#44fa161b0187b9549dd84bb91802f9bd8385cd6a"
   integrity sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==
 
-scheduler@0.26.0:
+scheduler@0.26.0, scheduler@^0.26.0:
   version "0.26.0"
   resolved "https://registry.yarnpkg.com/scheduler/-/scheduler-0.26.0.tgz#4ce8a8c2a2095f13ea11bf9a445be50c555d6337"
   integrity sha512-NlHwttCI/l5gCPR3D1nNXtWABUmBwvZpEQiD4IXSbIDq8BzLIK/7Ir5gTFSGZDUu37K5cMNp0hFtzO38sC7gWA==
 
-scheduler@^0.25.0:
-  version "0.25.0"
-  resolved "https://registry.yarnpkg.com/scheduler/-/scheduler-0.25.0.tgz#336cd9768e8cceebf52d3c80e3dcf5de23e7e015"
-  integrity sha512-xFVuu11jh+xcO7JOAGJNOXld8/TcEHK/4CituBUeUb5hqxJLj9YuemAEuvm9gQ/+pgXYfbQuqAkiYu+u7YEsNA==
-
 semver-diff@^3.1.1:
   version "3.1.1"
   resolved "https://registry.yarnpkg.com/semver-diff/-/semver-diff-3.1.1.tgz#05f77ce59f325e00e2706afd67bb506ddb1ca32b"