diff --git a/package.json b/package.json
index 9e4b84bff..dbbb2dbce 100644
--- a/package.json
+++ b/package.json
@@ -30,6 +30,7 @@
     "typecheck": "tsc",
     "lint": "eslint src --cache",
     "validate": "yarn prettier && yarn lint && yarn typecheck && yarn test",
+    "validate:write": "yarn prettier:write && yarn lint --fix && yarn typecheck && yarn test -u",
     "build:js": "babel src --out-dir build --extensions \".js,.ts,.jsx,.tsx\" --source-maps --ignore \"**/__tests__/**\"",
     "build:ts": "tsc --build tsconfig.release.json",
     "build": "yarn clean && yarn build:js && yarn build:ts",
diff --git a/src/__tests__/__snapshots__/render.test.tsx.snap b/src/__tests__/__snapshots__/unsafe-render-sync.test.tsx.snap
similarity index 100%
rename from src/__tests__/__snapshots__/render.test.tsx.snap
rename to src/__tests__/__snapshots__/unsafe-render-sync.test.tsx.snap
diff --git a/src/__tests__/act.test.tsx b/src/__tests__/act.test.tsx
index 036b80a14..c54e35c38 100644
--- a/src/__tests__/act.test.tsx
+++ b/src/__tests__/act.test.tsx
@@ -16,23 +16,23 @@ const Counter = () => {
   return <Text onPress={() => setCount(count + 1)}>{text}</Text>;
 };
 
-test('render should trigger useEffect', () => {
+test('render should trigger useEffect', async () => {
   const effectCallback = jest.fn();
-  render(<UseEffect callback={effectCallback} />);
+  await render(<UseEffect callback={effectCallback} />);
 
   expect(effectCallback).toHaveBeenCalledTimes(1);
 });
 
-test('rerender should trigger useEffect', () => {
+test('rerender should trigger useEffect', async () => {
   const effectCallback = jest.fn();
-  render(<UseEffect callback={effectCallback} />);
-  screen.rerender(<UseEffect callback={effectCallback} />);
+  await render(<UseEffect callback={effectCallback} />);
+  await screen.rerender(<UseEffect callback={effectCallback} />);
 
   expect(effectCallback).toHaveBeenCalledTimes(2);
 });
 
 test('fireEvent should trigger useState', async () => {
-  render(<Counter />);
+  await render(<Counter />);
   const counter = screen.getByText(/Total count/i);
 
   expect(counter.props.children).toEqual('Total count: 0');
diff --git a/src/__tests__/auto-cleanup-skip.test.tsx b/src/__tests__/auto-cleanup-skip.test.tsx
index d6d51c50f..1bf6c419a 100644
--- a/src/__tests__/auto-cleanup-skip.test.tsx
+++ b/src/__tests__/auto-cleanup-skip.test.tsx
@@ -29,9 +29,9 @@ class Test extends React.Component<{ onUnmount?(): void }> {
 
 // This just verifies that by importing RNTL in pure mode in an environment which supports
 // afterEach (like jest) we won't get automatic cleanup between tests.
-test('component is mounted, but not umounted before test ends', () => {
+test('component is mounted, but not umounted before test ends', async () => {
   const fn = jest.fn();
-  render(<Test onUnmount={fn} />);
+  await render(<Test onUnmount={fn} />);
   expect(fn).not.toHaveBeenCalled();
 });
 
diff --git a/src/__tests__/auto-cleanup.test.tsx b/src/__tests__/auto-cleanup.test.tsx
index 75453c93c..a4a3a6202 100644
--- a/src/__tests__/auto-cleanup.test.tsx
+++ b/src/__tests__/auto-cleanup.test.tsx
@@ -27,9 +27,9 @@ afterEach(() => {
 
 // This just verifies that by importing RNTL in an environment which supports afterEach (like jest)
 // we'll get automatic cleanup between tests.
-test('component is mounted, but not umounted before test ends', () => {
+test('component is mounted, but not umounted before test ends', async () => {
   const fn = jest.fn();
-  render(<Test onUnmount={fn} />);
+  await render(<Test onUnmount={fn} />);
   expect(isMounted).toEqual(true);
   expect(fn).not.toHaveBeenCalled();
 });
@@ -38,14 +38,14 @@ test('component is automatically umounted after first test ends', () => {
   expect(isMounted).toEqual(false);
 });
 
-test('does not time out with legacy fake timers', () => {
+test('does not time out with legacy fake timers', async () => {
   jest.useFakeTimers({ legacyFakeTimers: true });
-  render(<Test />);
+  await render(<Test />);
   expect(isMounted).toEqual(true);
 });
 
-test('does not time out with fake timers', () => {
+test('does not time out with fake timers', async () => {
   jest.useFakeTimers();
-  render(<Test />);
+  await render(<Test />);
   expect(isMounted).toEqual(true);
 });
diff --git a/src/__tests__/cleanup.test.tsx b/src/__tests__/cleanup.test.tsx
index e09f3ce9b..f6036d028 100644
--- a/src/__tests__/cleanup.test.tsx
+++ b/src/__tests__/cleanup.test.tsx
@@ -1,7 +1,7 @@
 import * as React from 'react';
 import { View } from 'react-native';
 
-import { cleanupAsync, render, renderAsync } from '../pure';
+import { cleanup, render, unsafe_renderSync } from '../pure';
 
 class Test extends React.Component<{ onUnmount: () => void }> {
   componentWillUnmount() {
@@ -17,21 +17,21 @@ class Test extends React.Component<{ onUnmount: () => void }> {
 test('cleanup after render', async () => {
   const fn = jest.fn();
 
-  render(<Test onUnmount={fn} />);
-  render(<Test onUnmount={fn} />);
+  await render(<Test onUnmount={fn} />);
+  await render(<Test onUnmount={fn} />);
   expect(fn).not.toHaveBeenCalled();
 
-  await cleanupAsync();
+  await cleanup();
   expect(fn).toHaveBeenCalledTimes(2);
 });
 
-test('cleanup after renderAsync', async () => {
+test('cleanup after unsafe_renderSync', async () => {
   const fn = jest.fn();
 
-  await renderAsync(<Test onUnmount={fn} />);
-  await renderAsync(<Test onUnmount={fn} />);
+  unsafe_renderSync(<Test onUnmount={fn} />);
+  unsafe_renderSync(<Test onUnmount={fn} />);
   expect(fn).not.toHaveBeenCalled();
 
-  await cleanupAsync();
+  await cleanup();
   expect(fn).toHaveBeenCalledTimes(2);
 });
diff --git a/src/__tests__/event-handler.test.tsx b/src/__tests__/event-handler.test.tsx
index 2c7f5ac43..0b200d7ca 100644
--- a/src/__tests__/event-handler.test.tsx
+++ b/src/__tests__/event-handler.test.tsx
@@ -4,11 +4,11 @@ import { Text, View } from 'react-native';
 import { render, screen } from '..';
 import { getEventHandlerFromProps } from '../event-handler';
 
-test('getEventHandler strict mode', () => {
+test('getEventHandler strict mode', async () => {
   const onPress = jest.fn();
   const testOnlyOnPress = jest.fn();
 
-  render(
+  await render(
     <View>
       <Text testID="regular" onPress={onPress} />
       {/* @ts-expect-error Intentionally passing such props */}
@@ -31,11 +31,11 @@ test('getEventHandler strict mode', () => {
   expect(getEventHandlerFromProps(both.props, 'onPress')).toBe(undefined);
 });
 
-test('getEventHandler loose mode', () => {
+test('getEventHandler loose mode', async () => {
   const onPress = jest.fn();
   const testOnlyOnPress = jest.fn();
 
-  render(
+  await render(
     <View>
       <Text testID="regular" onPress={onPress} />
       {/* @ts-expect-error Intentionally passing such props */}
diff --git a/src/__tests__/fire-event-textInput.test.tsx b/src/__tests__/fire-event-textInput.test.tsx
index 9e9f2ccb9..7223b1b21 100644
--- a/src/__tests__/fire-event-textInput.test.tsx
+++ b/src/__tests__/fire-event-textInput.test.tsx
@@ -20,7 +20,7 @@ test('should fire only non-touch-related events on non-editable TextInput', asyn
   const onSubmitEditing = jest.fn();
   const onLayout = jest.fn();
 
-  render(
+  await render(
     <TextInput
       editable={false}
       testID="subject"
@@ -49,7 +49,7 @@ test('should fire only non-touch-related events on non-editable TextInput with n
   const onSubmitEditing = jest.fn();
   const onLayout = jest.fn();
 
-  render(
+  await render(
     <TextInput
       editable={false}
       testID="subject"
@@ -100,7 +100,7 @@ test('should fire only non-touch-related events on non-editable wrapped TextInpu
   const onSubmitEditing = jest.fn();
   const onLayout = jest.fn();
 
-  render(
+  await render(
     <WrappedTextInput
       editable={false}
       testID="subject"
@@ -132,7 +132,7 @@ test('should fire only non-touch-related events on non-editable double wrapped T
   const onSubmitEditing = jest.fn();
   const onLayout = jest.fn();
 
-  render(
+  await render(
     <DoubleWrappedTextInput
       editable={false}
       testID="subject"
diff --git a/src/__tests__/fire-event.test.tsx b/src/__tests__/fire-event.test.tsx
index ebf47122c..9471b017b 100644
--- a/src/__tests__/fire-event.test.tsx
+++ b/src/__tests__/fire-event.test.tsx
@@ -52,7 +52,7 @@ const CustomEventComponentWithCustomName = ({
 describe('fireEvent', () => {
   test('should invoke specified event', async () => {
     const onPressMock = jest.fn();
-    render(<OnPressComponent onPress={onPressMock} text="Press me" />);
+    await render(<OnPressComponent onPress={onPressMock} text="Press me" />);
 
     await fireEvent(screen.getByText('Press me'), 'press');
 
@@ -62,7 +62,7 @@ describe('fireEvent', () => {
   test('should invoke specified event on parent element', async () => {
     const onPressMock = jest.fn();
     const text = 'New press text';
-    render(<OnPressComponent onPress={onPressMock} text={text} />);
+    await render(<OnPressComponent onPress={onPressMock} text={text} />);
 
     await fireEvent(screen.getByText(text), 'press');
     expect(onPressMock).toHaveBeenCalled();
@@ -72,7 +72,7 @@ describe('fireEvent', () => {
     const handlerMock = jest.fn();
     const EVENT_DATA = 'event data';
 
-    render(
+    await render(
       <View>
         <CustomEventComponent onCustomEvent={handlerMock} />
       </View>,
@@ -93,7 +93,7 @@ test('fireEvent.press', async () => {
       pageY: 30,
     },
   };
-  render(<OnPressComponent onPress={onPressMock} text={text} />);
+  await render(<OnPressComponent onPress={onPressMock} text={text} />);
 
   await fireEvent.press(screen.getByText(text), eventData);
 
@@ -110,7 +110,7 @@ test('fireEvent.scroll', async () => {
     },
   };
 
-  render(
+  await render(
     <ScrollView onScroll={onScrollMock}>
       <Text>XD</Text>
     </ScrollView>,
@@ -124,7 +124,7 @@ test('fireEvent.scroll', async () => {
 test('fireEvent.changeText', async () => {
   const onChangeTextMock = jest.fn();
 
-  render(
+  await render(
     <View>
       <TextInput placeholder="Customer placeholder" onChangeText={onChangeTextMock} />
     </View>,
@@ -136,7 +136,7 @@ test('fireEvent.changeText', async () => {
 });
 
 it('sets native state value for unmanaged text inputs', async () => {
-  render(<TextInput testID="input" />);
+  await render(<TextInput testID="input" />);
 
   const input = screen.getByTestId('input');
   expect(input).toHaveDisplayValue('');
@@ -148,7 +148,7 @@ it('sets native state value for unmanaged text inputs', async () => {
 test('custom component with custom event name', async () => {
   const handlePress = jest.fn();
 
-  render(<CustomEventComponentWithCustomName handlePress={handlePress} />);
+  await render(<CustomEventComponentWithCustomName handlePress={handlePress} />);
 
   await fireEvent(screen.getByText('Custom component'), 'handlePress');
 
@@ -158,7 +158,7 @@ test('custom component with custom event name', async () => {
 test('event with multiple handler parameters', async () => {
   const handlePress = jest.fn();
 
-  render(<CustomEventComponentWithCustomName handlePress={handlePress} />);
+  await render(<CustomEventComponentWithCustomName handlePress={handlePress} />);
 
   await fireEvent(screen.getByText('Custom component'), 'handlePress', 'param1', 'param2');
 
@@ -167,7 +167,7 @@ test('event with multiple handler parameters', async () => {
 
 test('should not fire on disabled TouchableOpacity', async () => {
   const handlePress = jest.fn();
-  render(
+  await render(
     <View>
       <TouchableOpacity onPress={handlePress} disabled={true}>
         <Text>Trigger</Text>
@@ -181,7 +181,7 @@ test('should not fire on disabled TouchableOpacity', async () => {
 
 test('should not fire on disabled Pressable', async () => {
   const handlePress = jest.fn();
-  render(
+  await render(
     <View>
       <Pressable onPress={handlePress} disabled={true}>
         <Text>Trigger</Text>
@@ -195,7 +195,7 @@ test('should not fire on disabled Pressable', async () => {
 
 test('should not fire inside View with pointerEvents="none"', async () => {
   const onPress = jest.fn();
-  render(
+  await render(
     <View pointerEvents="none">
       <Pressable onPress={onPress}>
         <Text>Trigger</Text>
@@ -210,7 +210,7 @@ test('should not fire inside View with pointerEvents="none"', async () => {
 
 test('should not fire inside View with pointerEvents="box-only"', async () => {
   const onPress = jest.fn();
-  render(
+  await render(
     <View pointerEvents="box-only">
       <Pressable onPress={onPress}>
         <Text>Trigger</Text>
@@ -225,7 +225,7 @@ test('should not fire inside View with pointerEvents="box-only"', async () => {
 
 test('should fire inside View with pointerEvents="box-none"', async () => {
   const onPress = jest.fn();
-  render(
+  await render(
     <View pointerEvents="box-none">
       <Pressable onPress={onPress}>
         <Text>Trigger</Text>
@@ -240,7 +240,7 @@ test('should fire inside View with pointerEvents="box-none"', async () => {
 
 test('should fire inside View with pointerEvents="auto"', async () => {
   const onPress = jest.fn();
-  render(
+  await render(
     <View pointerEvents="auto">
       <Pressable onPress={onPress}>
         <Text>Trigger</Text>
@@ -255,7 +255,7 @@ test('should fire inside View with pointerEvents="auto"', async () => {
 
 test('should not fire deeply inside View with pointerEvents="box-only"', async () => {
   const onPress = jest.fn();
-  render(
+  await render(
     <View pointerEvents="box-only">
       <View>
         <Pressable onPress={onPress}>
@@ -272,7 +272,7 @@ test('should not fire deeply inside View with pointerEvents="box-only"', async (
 
 test('should fire non-pointer events inside View with pointerEvents="box-none"', async () => {
   const onTouchStart = jest.fn();
-  render(<View testID="view" pointerEvents="box-none" onTouchStart={onTouchStart} />);
+  await render(<View testID="view" pointerEvents="box-none" onTouchStart={onTouchStart} />);
 
   await fireEvent(screen.getByTestId('view'), 'touchStart');
   expect(onTouchStart).toHaveBeenCalled();
@@ -280,7 +280,7 @@ test('should fire non-pointer events inside View with pointerEvents="box-none"',
 
 test('should fire non-touch events inside View with pointerEvents="box-none"', async () => {
   const onLayout = jest.fn();
-  render(<View testID="view" pointerEvents="box-none" onLayout={onLayout} />);
+  await render(<View testID="view" pointerEvents="box-none" onLayout={onLayout} />);
 
   await fireEvent(screen.getByTestId('view'), 'layout');
   expect(onLayout).toHaveBeenCalled();
@@ -290,7 +290,7 @@ test('should fire non-touch events inside View with pointerEvents="box-none"', a
 // the 'press' event on host View rendered by pressable.
 test('should fire on Pressable with pointerEvents="box-only', async () => {
   const onPress = jest.fn();
-  render(<Pressable testID="pressable" pointerEvents="box-only" onPress={onPress} />);
+  await render(<Pressable testID="pressable" pointerEvents="box-only" onPress={onPress} />);
 
   await fireEvent.press(screen.getByTestId('pressable'));
   expect(onPress).toHaveBeenCalled();
@@ -299,7 +299,7 @@ test('should fire on Pressable with pointerEvents="box-only', async () => {
 test('should pass event up on disabled TouchableOpacity', async () => {
   const handleInnerPress = jest.fn();
   const handleOuterPress = jest.fn();
-  render(
+  await render(
     <TouchableOpacity onPress={handleOuterPress}>
       <TouchableOpacity onPress={handleInnerPress} disabled={true}>
         <Text>Inner Trigger</Text>
@@ -315,7 +315,7 @@ test('should pass event up on disabled TouchableOpacity', async () => {
 test('should pass event up on disabled Pressable', async () => {
   const handleInnerPress = jest.fn();
   const handleOuterPress = jest.fn();
-  render(
+  await render(
     <Pressable onPress={handleOuterPress}>
       <Pressable onPress={handleInnerPress} disabled={true}>
         <Text>Inner Trigger</Text>
@@ -342,7 +342,7 @@ const TestComponent = ({ onPress }: TestComponentProps) => {
 
 test('is not fooled by non-native disabled prop', async () => {
   const handlePress = jest.fn();
-  render(<TestComponent onPress={handlePress} disabled={true} />);
+  await render(<TestComponent onPress={handlePress} disabled={true} />);
 
   await fireEvent.press(screen.getByText('Trigger Test'));
   expect(handlePress).toHaveBeenCalledTimes(1);
@@ -366,7 +366,7 @@ function TestChildTouchableComponent({ onPress, someProp }: TestChildTouchableCo
 test('is not fooled by non-responder wrapping host elements', async () => {
   const handlePress = jest.fn();
 
-  render(
+  await render(
     <View>
       <TestChildTouchableComponent onPress={handlePress} someProp={true} />
     </View>,
@@ -394,7 +394,7 @@ function TestDraggableComponent({ onDrag }: TestDraggableComponentProps) {
 test('has only onMove', async () => {
   const handleDrag = jest.fn();
 
-  render(<TestDraggableComponent onDrag={handleDrag} />);
+  await render(<TestDraggableComponent onDrag={handleDrag} />);
 
   await fireEvent(screen.getByText('Trigger'), 'responderMove', {
     touchHistory: { mostRecentTimeStamp: '2', touchBank: [] },
@@ -407,7 +407,7 @@ test('has only onMove', async () => {
 describe('native events', () => {
   test('triggers onScrollBeginDrag', async () => {
     const onScrollBeginDragSpy = jest.fn();
-    render(<ScrollView testID="test-id" onScrollBeginDrag={onScrollBeginDragSpy} />);
+    await render(<ScrollView testID="test-id" onScrollBeginDrag={onScrollBeginDragSpy} />);
 
     await fireEvent(screen.getByTestId('test-id'), 'onScrollBeginDrag');
     expect(onScrollBeginDragSpy).toHaveBeenCalled();
@@ -415,7 +415,7 @@ describe('native events', () => {
 
   test('triggers onScrollEndDrag', async () => {
     const onScrollEndDragSpy = jest.fn();
-    render(<ScrollView testID="test-id" onScrollEndDrag={onScrollEndDragSpy} />);
+    await render(<ScrollView testID="test-id" onScrollEndDrag={onScrollEndDragSpy} />);
 
     await fireEvent(screen.getByTestId('test-id'), 'onScrollEndDrag');
     expect(onScrollEndDragSpy).toHaveBeenCalled();
@@ -423,7 +423,7 @@ describe('native events', () => {
 
   test('triggers onMomentumScrollBegin', async () => {
     const onMomentumScrollBeginSpy = jest.fn();
-    render(<ScrollView testID="test-id" onMomentumScrollBegin={onMomentumScrollBeginSpy} />);
+    await render(<ScrollView testID="test-id" onMomentumScrollBegin={onMomentumScrollBeginSpy} />);
 
     await fireEvent(screen.getByTestId('test-id'), 'onMomentumScrollBegin');
     expect(onMomentumScrollBeginSpy).toHaveBeenCalled();
@@ -431,7 +431,7 @@ describe('native events', () => {
 
   test('triggers onMomentumScrollEnd', async () => {
     const onMomentumScrollEndSpy = jest.fn();
-    render(<ScrollView testID="test-id" onMomentumScrollEnd={onMomentumScrollEndSpy} />);
+    await render(<ScrollView testID="test-id" onMomentumScrollEnd={onMomentumScrollEndSpy} />);
 
     await fireEvent(screen.getByTestId('test-id'), 'onMomentumScrollEnd');
     expect(onMomentumScrollEndSpy).toHaveBeenCalled();
@@ -472,7 +472,7 @@ describe('React.Suspense integration', () => {
   test('should handle events after Suspense resolves', async () => {
     const onPressMock = jest.fn();
 
-    render(
+    await render(
       <SuspenseWrapper>
         <AsyncComponent onPress={onPressMock} shouldSuspend={true} />
       </SuspenseWrapper>,
@@ -483,8 +483,8 @@ describe('React.Suspense integration', () => {
 
     // Resolve the promise
     resolveMockPromise('loaded');
-    await waitFor(() => {
-      screen.rerender(
+    await waitFor(async () => {
+      await screen.rerender(
         <SuspenseWrapper>
           <AsyncComponent onPress={onPressMock} shouldSuspend={false} />
         </SuspenseWrapper>,
@@ -512,7 +512,7 @@ describe('React.Suspense integration', () => {
       );
     }
 
-    render(
+    await render(
       <React.Suspense fallback={<InteractiveFallback />}>
         <AsyncComponent onPress={jest.fn()} shouldSuspend={true} />
       </React.Suspense>,
@@ -547,7 +547,7 @@ describe('React.Suspense integration', () => {
       );
     }
 
-    const { rerender } = render(
+    const { rerender } = await render(
       <React.Suspense fallback={<Text>Outer Loading...</Text>}>
         <NestedAsync onPress={outerPressMock} shouldSuspend={false} level="Outer" />
         <React.Suspense fallback={<Text>Inner Loading...</Text>}>
@@ -566,8 +566,8 @@ describe('React.Suspense integration', () => {
 
     // Resolve inner component
     resolveMockPromise('inner-loaded');
-    await waitFor(() => {
-      rerender(
+    await waitFor(async () => {
+      await rerender(
         <React.Suspense fallback={<Text>Outer Loading...</Text>}>
           <NestedAsync onPress={outerPressMock} shouldSuspend={false} level="Outer" />
           <React.Suspense fallback={<Text>Inner Loading...</Text>}>
@@ -611,7 +611,7 @@ describe('React.Suspense integration', () => {
       );
     }
 
-    render(
+    await render(
       <View>
         <ButtonComponent />
         <React.Suspense fallback={<Text>Loading data...</Text>}>
@@ -628,7 +628,7 @@ describe('React.Suspense integration', () => {
     expect(onPressMock).toHaveBeenCalled();
 
     // Rerender - now DataComponent should suspend
-    screen.rerender(
+    await screen.rerender(
       <View>
         <ButtonComponent />
         <React.Suspense fallback={<Text>Loading data...</Text>}>
@@ -644,14 +644,14 @@ describe('React.Suspense integration', () => {
 
 test('should handle unmounted elements gracefully in async mode', async () => {
   const onPress = jest.fn();
-  render(
+  await render(
     <TouchableOpacity onPress={onPress}>
       <Text>Test</Text>
     </TouchableOpacity>,
   );
 
   const element = screen.getByText('Test');
-  screen.unmount();
+  await screen.unmount();
 
   // Firing async event on unmounted element should not crash
   await fireEvent.press(element);
diff --git a/src/__tests__/host-component-names.test.tsx b/src/__tests__/host-component-names.test.tsx
index 3e89dd84b..3fbf5fdf2 100644
--- a/src/__tests__/host-component-names.test.tsx
+++ b/src/__tests__/host-component-names.test.tsx
@@ -11,39 +11,39 @@ import {
   isHostTextInput,
 } from '../helpers/host-component-names';
 
-test('detects host Text component', () => {
-  render(<Text>Hello</Text>);
+test('detects host Text component', async () => {
+  await render(<Text>Hello</Text>);
   expect(isHostText(screen.root)).toBe(true);
 });
 
 // Some users might use the raw RCTText component directly for performance reasons.
 // See: https://blog.theodo.com/2023/10/native-views-rn-performance/
-test('detects raw RCTText component', () => {
-  render(React.createElement('RCTText', { testID: 'text' }, 'Hello'));
+test('detects raw RCTText component', async () => {
+  await render(React.createElement('RCTText', { testID: 'text' }, 'Hello'));
   expect(isHostText(screen.root)).toBe(true);
 });
 
-test('detects host TextInput component', () => {
-  render(<TextInput />);
+test('detects host TextInput component', async () => {
+  await render(<TextInput />);
   expect(isHostTextInput(screen.root)).toBe(true);
 });
 
-test('detects host Image component', () => {
-  render(<Image />);
+test('detects host Image component', async () => {
+  await render(<Image />);
   expect(isHostImage(screen.root)).toBe(true);
 });
 
-test('detects host Switch component', () => {
-  render(<Switch />);
+test('detects host Switch component', async () => {
+  await render(<Switch />);
   expect(isHostSwitch(screen.root)).toBe(true);
 });
 
-test('detects host ScrollView component', () => {
-  render(<ScrollView />);
+test('detects host ScrollView component', async () => {
+  await render(<ScrollView />);
   expect(isHostScrollView(screen.root)).toBe(true);
 });
 
-test('detects host Modal component', () => {
-  render(<Modal />);
+test('detects host Modal component', async () => {
+  await render(<Modal />);
   expect(isHostModal(screen.root)).toBe(true);
 });
diff --git a/src/__tests__/host-text-nesting.test.tsx b/src/__tests__/host-text-nesting.test.tsx
index 6e5b11915..c15c480d4 100644
--- a/src/__tests__/host-text-nesting.test.tsx
+++ b/src/__tests__/host-text-nesting.test.tsx
@@ -4,19 +4,19 @@ import { Pressable, Text, View } from 'react-native';
 import { render, screen } from '../pure';
 
 describe('nested text handling', () => {
-  test('basic', () => {
-    render(<Text testID="subject">Hello</Text>);
+  test('basic', async () => {
+    await render(<Text testID="subject">Hello</Text>);
     expect(screen.getByText('Hello')).toBeTruthy();
   });
 
-  test('role with direct text children', () => {
-    render(<Text accessibilityRole="header">About</Text>);
+  test('role with direct text children', async () => {
+    await render(<Text accessibilityRole="header">About</Text>);
 
     expect(screen.getByRole('header', { name: 'About' })).toBeTruthy();
   });
 
-  test('nested text with child with role', () => {
-    render(
+  test('nested text with child with role', async () => {
+    await render(
       <Text>
         <Text testID="child" accessibilityRole="header">
           About
@@ -27,8 +27,8 @@ describe('nested text handling', () => {
     expect(screen.getByRole('header', { name: 'About' }).props.testID).toBe('child');
   });
 
-  test('pressable within View, with text child', () => {
-    render(
+  test('pressable within View, with text child', async () => {
+    await render(
       <View>
         <Pressable testID="pressable" accessibilityRole="button">
           <Text>Save</Text>
@@ -39,8 +39,8 @@ describe('nested text handling', () => {
     expect(screen.getByRole('button', { name: 'Save' }).props.testID).toBe('pressable');
   });
 
-  test('pressable within View, with text child within view', () => {
-    render(
+  test('pressable within View, with text child within view', async () => {
+    await render(
       <View>
         <Pressable testID="pressable" accessibilityRole="button">
           <View>
@@ -53,8 +53,8 @@ describe('nested text handling', () => {
     expect(screen.getByRole('button', { name: 'Save' }).props.testID).toBe('pressable');
   });
 
-  test('Text within pressable', () => {
-    render(
+  test('Text within pressable', async () => {
+    await render(
       <Pressable testID="pressable" accessibilityRole="button">
         <Text testID="text">Save</Text>
       </Pressable>,
@@ -63,8 +63,8 @@ describe('nested text handling', () => {
     expect(screen.getByText('Save').props.testID).toBe('text');
   });
 
-  test('Text within view within pressable', () => {
-    render(
+  test('Text within view within pressable', async () => {
+    await render(
       <Pressable testID="pressable" accessibilityRole="button">
         <View>
           <Text testID="text">Save</Text>
diff --git a/src/__tests__/questionsBoard.test.tsx b/src/__tests__/questionsBoard.test.tsx
index c8be45eed..1eb97dcbb 100644
--- a/src/__tests__/questionsBoard.test.tsx
+++ b/src/__tests__/questionsBoard.test.tsx
@@ -44,7 +44,7 @@ test('form submits two answers', async () => {
   const onSubmit = jest.fn();
 
   const user = userEvent.setup();
-  render(<QuestionsBoard questions={questions} onSubmit={onSubmit} />);
+  await render(<QuestionsBoard questions={questions} onSubmit={onSubmit} />);
 
   const answerInputs = screen.getAllByLabelText('answer input');
   await user.type(answerInputs[0], 'a1');
diff --git a/src/__tests__/react-native-animated.test.tsx b/src/__tests__/react-native-animated.test.tsx
index 8d617fedd..87f3f582b 100644
--- a/src/__tests__/react-native-animated.test.tsx
+++ b/src/__tests__/react-native-animated.test.tsx
@@ -1,6 +1,6 @@
 import * as React from 'react';
 import type { ViewStyle } from 'react-native';
-import { Animated } from 'react-native';
+import { Animated, Text } from 'react-native';
 
 import { act, render, screen } from '..';
 
@@ -44,9 +44,9 @@ describe('AnimatedView', () => {
   });
 
   it('should use native driver when useNativeDriver is true', async () => {
-    render(
+    await render(
       <AnimatedView fadeInDuration={250} useNativeDriver={true}>
-        Test
+        <Text>Test</Text>
       </AnimatedView>,
     );
     expect(screen.root).toHaveStyle({ opacity: 0 });
@@ -57,9 +57,9 @@ describe('AnimatedView', () => {
   });
 
   it('should not use native driver when useNativeDriver is false', async () => {
-    render(
+    await render(
       <AnimatedView fadeInDuration={250} useNativeDriver={false}>
-        Test
+        <Text>Test</Text>
       </AnimatedView>,
     );
     expect(screen.root).toHaveStyle({ opacity: 0 });
diff --git a/src/__tests__/react-native-api.test.tsx b/src/__tests__/react-native-api.test.tsx
index b4926ccc9..76c2f0c03 100644
--- a/src/__tests__/react-native-api.test.tsx
+++ b/src/__tests__/react-native-api.test.tsx
@@ -10,8 +10,8 @@ import { getReactNativeVersion } from '../test-utils/version';
  * changed in a way that may impact our code like queries or event handling.
  */
 
-test('React Native API assumption: <View> renders a single host element', () => {
-  render(<View testID="test" />);
+test('React Native API assumption: <View> renders a single host element', async () => {
+  await render(<View testID="test" />);
 
   expect(screen).toMatchInlineSnapshot(`
     <View
@@ -20,8 +20,8 @@ test('React Native API assumption: <View> renders a single host element', () =>
   `);
 });
 
-test('React Native API assumption: <Text> renders a single host element', () => {
-  render(<Text testID="test">Hello</Text>);
+test('React Native API assumption: <Text> renders a single host element', async () => {
+  await render(<Text testID="test">Hello</Text>);
 
   expect(screen).toMatchInlineSnapshot(`
     <Text
@@ -32,8 +32,8 @@ test('React Native API assumption: <Text> renders a single host element', () =>
   `);
 });
 
-test('React Native API assumption: nested <Text> renders a single host element', () => {
-  render(
+test('React Native API assumption: nested <Text> renders a single host element', async () => {
+  await render(
     <Text testID="test">
       <Text testID="before">Before</Text>
       Hello
@@ -66,8 +66,8 @@ test('React Native API assumption: nested <Text> renders a single host element',
   `);
 });
 
-test('React Native API assumption: <TextInput> renders a single host element', () => {
-  render(
+test('React Native API assumption: <TextInput> renders a single host element', async () => {
+  await render(
     <TextInput
       testID="test"
       defaultValue="default"
@@ -86,8 +86,8 @@ test('React Native API assumption: <TextInput> renders a single host element', (
   `);
 });
 
-test('React Native API assumption: <TextInput> with nested Text renders single host element', () => {
-  render(
+test('React Native API assumption: <TextInput> with nested Text renders single host element', async () => {
+  await render(
     <TextInput testID="test" placeholder="Placeholder">
       <Text>Hello</Text>
     </TextInput>,
@@ -105,8 +105,8 @@ test('React Native API assumption: <TextInput> with nested Text renders single h
   `);
 });
 
-test('React Native API assumption: <Switch> renders a single host element', () => {
-  render(<Switch testID="test" value={true} onChange={jest.fn()} />);
+test('React Native API assumption: <Switch> renders a single host element', async () => {
+  await render(<Switch testID="test" value={true} onChange={jest.fn()} />);
 
   expect(
     mapJsonProps(screen.toJSON(), {
@@ -125,8 +125,10 @@ test('React Native API assumption: <Switch> renders a single host element', () =
   `);
 });
 
-test('React Native API assumption: <Image> renders a single host element', () => {
-  render(<Image testID="test" source={{ uri: 'https://fake.url/image.jpg' }} alt="Alt text" />);
+test('React Native API assumption: <Image> renders a single host element', async () => {
+  await render(
+    <Image testID="test" source={{ uri: 'https://fake.url/image.jpg' }} alt="Alt text" />,
+  );
 
   expect(screen).toMatchInlineSnapshot(`
     <Image
@@ -141,8 +143,8 @@ test('React Native API assumption: <Image> renders a single host element', () =>
   `);
 });
 
-test('React Native API assumption: <ScrollView> renders a single host element', () => {
-  render(
+test('React Native API assumption: <ScrollView> renders a single host element', async () => {
+  await render(
     <ScrollView testID="scrollView">
       <View testID="view" />
     </ScrollView>,
@@ -161,8 +163,8 @@ test('React Native API assumption: <ScrollView> renders a single host element',
   `);
 });
 
-test('React Native API assumption: <FlatList> renders a single host <ScrollView> element', () => {
-  render(
+test('React Native API assumption: <FlatList> renders a single host <ScrollView> element', async () => {
+  await render(
     <FlatList testID="flatList" data={[1, 2]} renderItem={({ item }) => <Text>{item}</Text>} />,
   );
 
@@ -215,8 +217,8 @@ test('React Native API assumption: <FlatList> renders a single host <ScrollView>
   `);
 });
 
-test('React Native API assumption: <Modal> renders a single host element', () => {
-  render(
+test('React Native API assumption: <Modal> renders a single host element', async () => {
+  await render(
     <Modal testID="test">
       <Text>Modal Content</Text>
     </Modal>,
@@ -250,8 +252,8 @@ test('React Native API assumption: <Modal> renders a single host element', () =>
   }
 });
 
-test('React Native API assumption: aria-* props render directly on host View', () => {
-  render(
+test('React Native API assumption: aria-* props render directly on host View', async () => {
+  await render(
     <View
       testID="test"
       aria-busy
@@ -298,8 +300,8 @@ test('React Native API assumption: aria-* props render directly on host View', (
   `);
 });
 
-test('React Native API assumption: aria-* props render directly on host Text', () => {
-  render(
+test('React Native API assumption: aria-* props render directly on host Text', async () => {
+  await render(
     <Text
       testID="test"
       aria-busy
@@ -346,8 +348,8 @@ test('React Native API assumption: aria-* props render directly on host Text', (
   `);
 });
 
-test('React Native API assumption: aria-* props render directly on host TextInput', () => {
-  render(
+test('React Native API assumption: aria-* props render directly on host TextInput', async () => {
+  await render(
     <TextInput
       testID="test"
       aria-busy
diff --git a/src/__tests__/react-native-gesture-handler.test.tsx b/src/__tests__/react-native-gesture-handler.test.tsx
index eead8ce31..bab0a354c 100644
--- a/src/__tests__/react-native-gesture-handler.test.tsx
+++ b/src/__tests__/react-native-gesture-handler.test.tsx
@@ -12,7 +12,7 @@ test('fireEvent can invoke press events for RNGH Pressable', async () => {
   const onPressOut = jest.fn();
   const onLongPress = jest.fn();
 
-  render(
+  await render(
     <View>
       <Pressable
         testID="pressable"
@@ -43,7 +43,7 @@ test('userEvent can invoke press events for RNGH Pressable', async () => {
   const { events, logEvent } = createEventLogger();
   const user = userEvent.setup();
 
-  render(
+  await render(
     <View>
       <Pressable
         testID="pressable"
diff --git a/src/__tests__/render-async.test.tsx b/src/__tests__/render-async.test.tsx
deleted file mode 100644
index 57147ec4c..000000000
--- a/src/__tests__/render-async.test.tsx
+++ /dev/null
@@ -1,88 +0,0 @@
-import * as React from 'react';
-import { Text, View } from 'react-native';
-
-import { renderAsync, screen } from '..';
-
-class Banana extends React.Component<any, { fresh: boolean }> {
-  state = {
-    fresh: false,
-  };
-
-  componentDidUpdate() {
-    if (this.props.onUpdate) {
-      this.props.onUpdate();
-    }
-  }
-
-  componentWillUnmount() {
-    if (this.props.onUnmount) {
-      this.props.onUnmount();
-    }
-  }
-
-  changeFresh = () => {
-    this.setState((state) => ({
-      fresh: !state.fresh,
-    }));
-  };
-
-  render() {
-    return (
-      <View>
-        <Text>Is the banana fresh?</Text>
-        <Text testID="bananaFresh">{this.state.fresh ? 'fresh' : 'not fresh'}</Text>
-      </View>
-    );
-  }
-}
-
-test('renderAsync renders component asynchronously', async () => {
-  await renderAsync(<View testID="test" />);
-  expect(screen.getByTestId('test')).toBeOnTheScreen();
-});
-
-test('renderAsync with wrapper option', async () => {
-  const WrapperComponent = ({ children }: { children: React.ReactNode }) => (
-    <View testID="wrapper">{children}</View>
-  );
-
-  await renderAsync(<View testID="inner" />, {
-    wrapper: WrapperComponent,
-  });
-
-  expect(screen.getByTestId('wrapper')).toBeTruthy();
-  expect(screen.getByTestId('inner')).toBeTruthy();
-});
-
-test('rerender function throws error when used with renderAsync', async () => {
-  await renderAsync(<Banana />);
-
-  expect(() => screen.rerender(<Banana />)).toThrowErrorMatchingInlineSnapshot(
-    `""rerender(...)" is not supported when using "renderAsync" use "await rerenderAsync(...)" instead"`,
-  );
-});
-
-test('rerenderAsync function updates component asynchronously', async () => {
-  const fn = jest.fn();
-  await renderAsync(<Banana onUpdate={fn} />);
-  expect(fn).toHaveBeenCalledTimes(0);
-
-  await screen.rerenderAsync(<Banana onUpdate={fn} />);
-  expect(fn).toHaveBeenCalledTimes(1);
-});
-
-test('unmount function throws error when used with renderAsync', async () => {
-  await renderAsync(<Banana />);
-
-  expect(() => screen.unmount()).toThrowErrorMatchingInlineSnapshot(
-    `""unmount()" is not supported when using "renderAsync" use "await unmountAsync()" instead"`,
-  );
-});
-
-test('unmountAsync function unmounts component asynchronously', async () => {
-  const fn = jest.fn();
-  await renderAsync(<Banana onUnmount={fn} />);
-
-  await screen.unmountAsync();
-  expect(fn).toHaveBeenCalled();
-});
diff --git a/src/__tests__/render-debug.test.tsx b/src/__tests__/render-debug.test.tsx
index 544c2e45a..21b37deb3 100644
--- a/src/__tests__/render-debug.test.tsx
+++ b/src/__tests__/render-debug.test.tsx
@@ -90,8 +90,8 @@ class Banana extends React.Component<any, { fresh: boolean }> {
   }
 }
 
-test('debug', () => {
-  render(<Banana />);
+test('debug', async () => {
+  await render(<Banana />);
 
   screen.debug();
   screen.debug({ message: 'another custom message' });
@@ -104,7 +104,7 @@ test('debug', () => {
 });
 
 test('debug changing component', async () => {
-  render(<Banana />);
+  await render(<Banana />);
   await fireEvent.press(screen.getByRole('button', { name: 'Change freshness!' }));
 
   screen.debug({ mapProps: null });
@@ -113,16 +113,16 @@ test('debug changing component', async () => {
   expect(mockCalls[0][0]).toMatchSnapshot('bananaFresh button message should now be "fresh"');
 });
 
-test('debug with only children prop', () => {
-  render(<Banana />);
+test('debug with only children prop', async () => {
+  await render(<Banana />);
   screen.debug({ mapProps: () => ({}) });
 
   const mockCalls = jest.mocked(logger.info).mock.calls;
   expect(mockCalls[0][0]).toMatchSnapshot();
 });
 
-test('debug with only prop whose value is bananaChef', () => {
-  render(<Banana />);
+test('debug with only prop whose value is bananaChef', async () => {
+  await render(<Banana />);
   screen.debug({
     mapProps: (props) => {
       const filterProps: Record<string, unknown> = {};
@@ -139,10 +139,10 @@ test('debug with only prop whose value is bananaChef', () => {
   expect(mockCalls[0][0]).toMatchSnapshot();
 });
 
-test('debug should use debugOptions from config when no option is specified', () => {
+test('debug should use debugOptions from config when no option is specified', async () => {
   configure({ defaultDebugOptions: { mapProps: () => ({}) } });
 
-  render(
+  await render(
     <View style={{ backgroundColor: 'red' }}>
       <Text>hello</Text>
     </View>,
@@ -153,17 +153,17 @@ test('debug should use debugOptions from config when no option is specified', ()
   expect(mockCalls[0][0]).toMatchSnapshot();
 });
 
-test('filtering out props through mapProps option should not modify component', () => {
-  render(<View testID="viewTestID" />);
+test('filtering out props through mapProps option should not modify component', async () => {
+  await render(<View testID="viewTestID" />);
   screen.debug({ mapProps: () => ({}) });
 
   expect(screen.getByTestId('viewTestID')).toBeTruthy();
 });
 
-test('debug should use given options over config debugOptions', () => {
+test('debug should use given options over config debugOptions', async () => {
   configure({ defaultDebugOptions: { mapProps: () => ({}) } });
 
-  render(
+  await render(
     <View style={{ backgroundColor: 'red' }}>
       <Text>hello</Text>
     </View>,
diff --git a/src/__tests__/render-hook.test.tsx b/src/__tests__/render-hook.test.tsx
index 782fec0d1..ca1f3f828 100644
--- a/src/__tests__/render-hook.test.tsx
+++ b/src/__tests__/render-hook.test.tsx
@@ -203,10 +203,10 @@ test('handles hook with suspense', async () => {
 });
 
 class ErrorBoundary extends React.Component<
-  { children: React.ReactNode; fallback: string },
+  { children: React.ReactNode; fallback: React.ReactNode },
   { hasError: boolean }
 > {
-  constructor(props: { children: React.ReactNode; fallback: string }) {
+  constructor(props: { children: React.ReactNode; fallback: React.ReactNode }) {
     super(props);
     this.state = { hasError: false };
   }
@@ -233,7 +233,7 @@ test('handles hook suspense with error boundary', async () => {
   const { result } = await renderHook(useSuspendingHook, {
     initialProps: promise,
     wrapper: ({ children }) => (
-      <ErrorBoundary fallback="error-fallback">
+      <ErrorBoundary fallback={<Text>Error Fallback</Text>}>
         <React.Suspense fallback={<Text>Loading...</Text>}>{children}</React.Suspense>
       </ErrorBoundary>
     ),
diff --git a/src/__tests__/render.test.tsx b/src/__tests__/render.test.tsx
index ae5c8d350..97cd6c732 100644
--- a/src/__tests__/render.test.tsx
+++ b/src/__tests__/render.test.tsx
@@ -1,25 +1,7 @@
 import * as React from 'react';
-import { Pressable, Text, TextInput, View } from 'react-native';
+import { Text, View } from 'react-native';
 
-import type { RenderAPI } from '..';
-import { fireEvent, render, screen } from '..';
-
-const PLACEHOLDER_FRESHNESS = 'Add custom freshness';
-const PLACEHOLDER_CHEF = 'Who inspected freshness?';
-const INPUT_FRESHNESS = 'Custom Freshie';
-const INPUT_CHEF = 'I inspected freshie';
-const DEFAULT_INPUT_CHEF = 'What did you inspect?';
-const DEFAULT_INPUT_CUSTOMER = 'What banana?';
-
-class MyButton extends React.Component<any> {
-  render() {
-    return (
-      <Pressable onPress={this.props.onPress}>
-        <Text>{this.props.children}</Text>
-      </Pressable>
-    );
-  }
-}
+import { render, screen } from '..';
 
 class Banana extends React.Component<any, { fresh: boolean }> {
   state = {
@@ -45,169 +27,46 @@ class Banana extends React.Component<any, { fresh: boolean }> {
   };
 
   render() {
-    const test = 0;
     return (
       <View>
         <Text>Is the banana fresh?</Text>
         <Text testID="bananaFresh">{this.state.fresh ? 'fresh' : 'not fresh'}</Text>
-        <TextInput
-          testID="bananaCustomFreshness"
-          placeholder={PLACEHOLDER_FRESHNESS}
-          value={INPUT_FRESHNESS}
-        />
-        <TextInput
-          testID="bananaChef"
-          placeholder={PLACEHOLDER_CHEF}
-          value={INPUT_CHEF}
-          defaultValue={DEFAULT_INPUT_CHEF}
-        />
-        <TextInput defaultValue={DEFAULT_INPUT_CUSTOMER} />
-        <TextInput defaultValue={'hello'} value="" />
-        <MyButton onPress={this.changeFresh} type="primary">
-          Change freshness!
-        </MyButton>
-        <Text testID="duplicateText">First Text</Text>
-        <Text testID="duplicateText">Second Text</Text>
-        <Text>{test}</Text>
       </View>
     );
   }
 }
 
-test('supports basic rendering', () => {
-  render(<View testID="test" />);
-  expect(screen.root).toBeOnTheScreen();
-});
-
-test('rerender', async () => {
-  const fn = jest.fn();
-  render(<Banana onUpdate={fn} />);
-  expect(fn).toHaveBeenCalledTimes(0);
-
-  await fireEvent.press(screen.getByText('Change freshness!'));
-  expect(fn).toHaveBeenCalledTimes(1);
-
-  screen.rerender(<Banana onUpdate={fn} />);
-  expect(fn).toHaveBeenCalledTimes(2);
-});
-
-test('unmount', () => {
-  const fn = jest.fn();
-  render(<Banana onUnmount={fn} />);
-  screen.unmount();
-  expect(fn).toHaveBeenCalled();
-});
-
-test('unmount should handle cleanup functions', () => {
-  const cleanup = jest.fn();
-  const Component = () => {
-    React.useEffect(() => cleanup);
-    return null;
-  };
-
-  render(<Component />);
-
-  screen.unmount();
-
-  expect(cleanup).toHaveBeenCalledTimes(1);
-});
-
-test('toJSON renders host output', () => {
-  render(<MyButton>press me</MyButton>);
-  expect(screen).toMatchSnapshot();
+test('render renders component asynchronously', async () => {
+  await render(<View testID="test" />);
+  expect(screen.getByTestId('test')).toBeOnTheScreen();
 });
 
-test('renders options.wrapper around node', () => {
-  type WrapperComponentProps = { children: React.ReactNode };
-  const WrapperComponent = ({ children }: WrapperComponentProps) => (
+test('render with wrapper option', async () => {
+  const WrapperComponent = ({ children }: { children: React.ReactNode }) => (
     <View testID="wrapper">{children}</View>
   );
 
-  render(<View testID="inner" />, {
+  await render(<View testID="inner" />, {
     wrapper: WrapperComponent,
   });
 
   expect(screen.getByTestId('wrapper')).toBeTruthy();
-  expect(screen).toMatchInlineSnapshot(`
-    <View
-      testID="wrapper"
-    >
-      <View
-        testID="inner"
-      />
-    </View>
-  `);
+  expect(screen.getByTestId('inner')).toBeTruthy();
 });
 
-test('renders options.wrapper around updated node', () => {
-  type WrapperComponentProps = { children: React.ReactNode };
-  const WrapperComponent = ({ children }: WrapperComponentProps) => (
-    <View testID="wrapper">{children}</View>
-  );
-
-  render(<View testID="inner" />, {
-    wrapper: WrapperComponent,
-  });
-
-  screen.rerender(<View testID="inner" accessibilityLabel="test" accessibilityHint="test" />);
-
-  expect(screen.getByTestId('wrapper')).toBeTruthy();
-  expect(screen).toMatchInlineSnapshot(`
-    <View
-      testID="wrapper"
-    >
-      <View
-        accessibilityHint="test"
-        accessibilityLabel="test"
-        testID="inner"
-      />
-    </View>
-  `);
-});
-
-test('returns host root', () => {
-  render(<View testID="inner" />);
-
-  expect(screen.root).toBeDefined();
-  expect(screen.root?.type).toBe('View');
-  expect(screen.root?.props.testID).toBe('inner');
-});
-
-test('RenderAPI type', () => {
-  render(<Banana />) as RenderAPI;
-  expect(true).toBeTruthy();
-});
-
-test('returned output can be spread using rest operator', () => {
-  // Next line should not throw
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  const { rerender, ...rest } = render(<View testID="test" />);
-  expect(rest).toBeTruthy();
-});
-
-test('rerenderAsync updates the component asynchronously', async () => {
+test('rerender function updates component asynchronously', async () => {
   const fn = jest.fn();
-  const result = render(<Banana onUpdate={fn} />);
-
-  await result.rerenderAsync(<Banana onUpdate={fn} />);
-
-  expect(fn).toHaveBeenCalledTimes(1);
-});
-
-test('updateAsync is an alias for rerenderAsync', async () => {
-  const fn = jest.fn();
-  const result = render(<Banana onUpdate={fn} />);
-
-  await result.updateAsync(<Banana onUpdate={fn} />);
+  await render(<Banana onUpdate={fn} />);
+  expect(fn).toHaveBeenCalledTimes(0);
 
+  await screen.rerender(<Banana onUpdate={fn} />);
   expect(fn).toHaveBeenCalledTimes(1);
 });
 
-test('unmountAsync unmounts the component asynchronously', async () => {
+test('unmount function unmounts component asynchronously', async () => {
   const fn = jest.fn();
-  const result = render(<Banana onUnmount={fn} />);
-
-  await result.unmountAsync();
+  await render(<Banana onUnmount={fn} />);
 
+  await screen.unmount();
   expect(fn).toHaveBeenCalled();
 });
diff --git a/src/__tests__/screen.test.tsx b/src/__tests__/screen.test.tsx
index d41bd4e29..59b95bf4b 100644
--- a/src/__tests__/screen.test.tsx
+++ b/src/__tests__/screen.test.tsx
@@ -3,8 +3,8 @@ import { Text, View } from 'react-native';
 
 import { render, screen } from '..';
 
-test('screen has the same queries as render result', () => {
-  const result = render(<Text>Mt. Everest</Text>);
+test('screen has the same queries as render result', async () => {
+  const result = await render(<Text>Mt. Everest</Text>);
   expect(screen).toBe(result);
 
   expect(screen.getByText('Mt. Everest')).toBeTruthy();
@@ -13,10 +13,10 @@ test('screen has the same queries as render result', () => {
   expect(screen.queryAllByText('Mt. Everest')).toHaveLength(1);
 });
 
-test('screen holds last render result', () => {
-  render(<Text>Mt. Everest</Text>);
-  render(<Text>Mt. Blanc</Text>);
-  const finalResult = render(<Text>Śnieżka</Text>);
+test('screen holds last render result', async () => {
+  await render(<Text>Mt. Everest</Text>);
+  await render(<Text>Mt. Blanc</Text>);
+  const finalResult = await render(<Text>Śnieżka</Text>);
   expect(screen).toBe(finalResult);
 
   expect(screen.getByText('Śnieżka')).toBeTruthy();
@@ -24,24 +24,24 @@ test('screen holds last render result', () => {
   expect(screen.queryByText('Mt. Blanc')).toBeFalsy();
 });
 
-test('screen works with updating rerender', () => {
-  const result = render(<Text>Mt. Everest</Text>);
+test('screen works with updating rerender', async () => {
+  const result = await render(<Text>Mt. Everest</Text>);
   expect(screen).toBe(result);
 
-  screen.rerender(<Text>Śnieżka</Text>);
+  await screen.rerender(<Text>Śnieżka</Text>);
   expect(screen).toBe(result);
   expect(screen.getByText('Śnieżka')).toBeTruthy();
 });
 
-test('screen works with nested re-mounting rerender', () => {
-  const result = render(
+test('screen works with nested re-mounting rerender', async () => {
+  const result = await render(
     <View>
       <Text>Mt. Everest</Text>
     </View>,
   );
   expect(screen).toBe(result);
 
-  screen.rerender(
+  await screen.rerender(
     <View>
       <View>
         <Text>Śnieżka</Text>
@@ -53,8 +53,8 @@ test('screen works with nested re-mounting rerender', () => {
 });
 
 test('screen throws without render', () => {
-  expect(() => screen.container).toThrow('`render` method has not been called');
-  expect(() => screen.root).toThrow('`render` method has not been called');
-  expect(() => screen.debug()).toThrow('`render` method has not been called');
-  expect(() => screen.getByText('Mt. Everest')).toThrow('`render` method has not been called');
+  expect(() => screen.container).toThrow('`render` function has not been called');
+  expect(() => screen.root).toThrow('`render` function has not been called');
+  expect(() => screen.debug()).toThrow('`render` function has not been called');
+  expect(() => screen.getByText('Mt. Everest')).toThrow('`render` function has not been called');
 });
diff --git a/src/__tests__/suspense-fake-timers.test.tsx b/src/__tests__/suspense-fake-timers.test.tsx
index efb09a8ec..495971337 100644
--- a/src/__tests__/suspense-fake-timers.test.tsx
+++ b/src/__tests__/suspense-fake-timers.test.tsx
@@ -1,7 +1,7 @@
 import * as React from 'react';
 import { Text, View } from 'react-native';
 
-import { act, renderAsync, screen } from '..';
+import { act, render, screen } from '..';
 import { excludeConsoleMessage } from '../test-utils/console';
 
 jest.useFakeTimers();
@@ -26,7 +26,7 @@ test('resolves manually-controlled promise', async () => {
     resolvePromise = resolve;
   });
 
-  await renderAsync(
+  await render(
     <View>
       <React.Suspense fallback={<Text>Loading...</Text>}>
         <Suspending promise={promise} testID="content" />
@@ -50,7 +50,7 @@ test('resolves timer-controlled promise', async () => {
     setTimeout(() => resolve(null), 100);
   });
 
-  await renderAsync(
+  await render(
     <View>
       <React.Suspense fallback={<Text>Loading...</Text>}>
         <Suspending promise={promise} testID="content" />
@@ -96,7 +96,7 @@ test('handles promise rejection with error boundary', async () => {
     rejectPromise = reject;
   });
 
-  await renderAsync(
+  await render(
     <ErrorBoundary fallback={<Text>Error occurred</Text>}>
       <React.Suspense fallback={<Text>Loading...</Text>}>
         <Suspending promise={promise} testID="content" />
@@ -126,7 +126,7 @@ test('handles multiple suspending components', async () => {
     resolvePromise2 = resolve;
   });
 
-  await renderAsync(
+  await render(
     <View>
       <React.Suspense fallback={<Text>Loading...</Text>}>
         <Suspending promise={promise1} testID="content-1" />
@@ -163,7 +163,7 @@ test('handles multiple suspense boundaries independently', async () => {
     resolvePromise2 = resolve;
   });
 
-  await renderAsync(
+  await render(
     <View>
       <React.Suspense fallback={<Text>First Loading...</Text>}>
         <Suspending promise={promise1} testID="content-1" />
diff --git a/src/__tests__/suspense.test.tsx b/src/__tests__/suspense.test.tsx
index c84e93b12..eded69052 100644
--- a/src/__tests__/suspense.test.tsx
+++ b/src/__tests__/suspense.test.tsx
@@ -1,7 +1,7 @@
 import * as React from 'react';
 import { Text, View } from 'react-native';
 
-import { act, renderAsync, screen } from '..';
+import { act, render, screen } from '..';
 import { excludeConsoleMessage } from '../test-utils/console';
 
 // eslint-disable-next-line no-console
@@ -24,7 +24,7 @@ test('resolves manually-controlled promise', async () => {
     resolvePromise = resolve;
   });
 
-  await renderAsync(
+  await render(
     <View>
       <React.Suspense fallback={<Text>Loading...</Text>}>
         <Suspending promise={promise} testID="content" />
@@ -48,7 +48,7 @@ test('resolves timer-controlled promise', async () => {
     setTimeout(() => resolve(null), 100);
   });
 
-  await renderAsync(
+  await render(
     <View>
       <React.Suspense fallback={<Text>Loading...</Text>}>
         <Suspending promise={promise} testID="content" />
@@ -93,7 +93,7 @@ test('handles promise rejection with error boundary', async () => {
     rejectPromise = reject;
   });
 
-  await renderAsync(
+  await render(
     <ErrorBoundary fallback={<Text>Error occurred</Text>}>
       <React.Suspense fallback={<Text>Loading...</Text>}>
         <Suspending promise={promise} testID="content" />
@@ -123,7 +123,7 @@ test('handles multiple suspending components', async () => {
     resolvePromise2 = resolve;
   });
 
-  await renderAsync(
+  await render(
     <View>
       <React.Suspense fallback={<Text>Loading...</Text>}>
         <Suspending promise={promise1} testID="content-1" />
@@ -160,7 +160,7 @@ test('handles multiple suspense boundaries independently', async () => {
     resolvePromise2 = resolve;
   });
 
-  await renderAsync(
+  await render(
     <View>
       <React.Suspense fallback={<Text>First Loading...</Text>}>
         <Suspending promise={promise1} testID="content-1" />
diff --git a/src/__tests__/timers.test.ts b/src/__tests__/timers.test.ts
index acb9ec4c5..2c3a40a75 100644
--- a/src/__tests__/timers.test.ts
+++ b/src/__tests__/timers.test.ts
@@ -1,4 +1,4 @@
-import waitFor from '../wait-for';
+import { waitFor } from '../wait-for';
 
 describe.each([false, true])('fake timers tests (legacyFakeTimers = %s)', (legacyFakeTimers) => {
   beforeEach(() => {
diff --git a/src/__tests__/deprecated/fire-event-sync.test.tsx b/src/__tests__/unsafe-fire-event-sync.test.tsx
similarity index 67%
rename from src/__tests__/deprecated/fire-event-sync.test.tsx
rename to src/__tests__/unsafe-fire-event-sync.test.tsx
index d87f09c7f..c1fae505b 100644
--- a/src/__tests__/deprecated/fire-event-sync.test.tsx
+++ b/src/__tests__/unsafe-fire-event-sync.test.tsx
@@ -9,7 +9,7 @@ import {
   View,
 } from 'react-native';
 
-import { deprecated_fireEventSync, render, screen } from '../..';
+import { screen, unsafe_fireEventSync, unsafe_renderSync } from '..';
 
 type OnPressComponentProps = {
   onPress: () => void;
@@ -36,6 +36,7 @@ type MyCustomButtonProps = {
   handlePress: () => void;
   text: string;
 };
+
 const MyCustomButton = ({ handlePress, text }: MyCustomButtonProps) => (
   <OnPressComponent onPress={handlePress} text={text} />
 );
@@ -43,18 +44,19 @@ const MyCustomButton = ({ handlePress, text }: MyCustomButtonProps) => (
 type CustomEventComponentWithCustomNameProps = {
   handlePress: () => void;
 };
+
 const CustomEventComponentWithCustomName = ({
   handlePress,
 }: CustomEventComponentWithCustomNameProps) => (
   <MyCustomButton handlePress={handlePress} text="Custom component" />
 );
 
-describe('deprecated_fireEventSync', () => {
+describe('unsafe_fireEventSync', () => {
   test('should invoke specified event', () => {
     const onPressMock = jest.fn();
-    render(<OnPressComponent onPress={onPressMock} text="Press me" />);
+    unsafe_renderSync(<OnPressComponent onPress={onPressMock} text="Press me" />);
 
-    deprecated_fireEventSync(screen.getByText('Press me'), 'press');
+    unsafe_fireEventSync(screen.getByText('Press me'), 'press');
 
     expect(onPressMock).toHaveBeenCalled();
   });
@@ -62,9 +64,9 @@ describe('deprecated_fireEventSync', () => {
   test('should invoke specified event on parent element', () => {
     const onPressMock = jest.fn();
     const text = 'New press text';
-    render(<OnPressComponent onPress={onPressMock} text={text} />);
+    unsafe_renderSync(<OnPressComponent onPress={onPressMock} text={text} />);
 
-    deprecated_fireEventSync(screen.getByText(text), 'press');
+    unsafe_fireEventSync(screen.getByText(text), 'press');
     expect(onPressMock).toHaveBeenCalled();
   });
 
@@ -72,19 +74,19 @@ describe('deprecated_fireEventSync', () => {
     const handlerMock = jest.fn();
     const EVENT_DATA = 'event data';
 
-    render(
+    unsafe_renderSync(
       <View>
         <CustomEventComponent onCustomEvent={handlerMock} />
       </View>,
     );
 
-    deprecated_fireEventSync(screen.getByText('Custom event component'), 'customEvent', EVENT_DATA);
+    unsafe_fireEventSync(screen.getByText('Custom event component'), 'customEvent', EVENT_DATA);
 
     expect(handlerMock).toHaveBeenCalledWith(EVENT_DATA);
   });
 });
 
-test('deprecated_fireEventSync.press', () => {
+test('unsafe_fireEventSync.press', () => {
   const onPressMock = jest.fn();
   const text = 'Fireevent press';
   const eventData = {
@@ -93,14 +95,14 @@ test('deprecated_fireEventSync.press', () => {
       pageY: 30,
     },
   };
-  render(<OnPressComponent onPress={onPressMock} text={text} />);
+  unsafe_renderSync(<OnPressComponent onPress={onPressMock} text={text} />);
 
-  deprecated_fireEventSync.press(screen.getByText(text), eventData);
+  unsafe_fireEventSync.press(screen.getByText(text), eventData);
 
   expect(onPressMock).toHaveBeenCalledWith(eventData);
 });
 
-test('deprecated_fireEventSync.scroll', () => {
+test('unsafe_fireEventSync.scroll', () => {
   const onScrollMock = jest.fn();
   const eventData = {
     nativeEvent: {
@@ -110,47 +112,47 @@ test('deprecated_fireEventSync.scroll', () => {
     },
   };
 
-  render(
+  unsafe_renderSync(
     <ScrollView onScroll={onScrollMock}>
       <Text>XD</Text>
     </ScrollView>,
   );
 
-  deprecated_fireEventSync.scroll(screen.getByText('XD'), eventData);
+  unsafe_fireEventSync.scroll(screen.getByText('XD'), eventData);
 
   expect(onScrollMock).toHaveBeenCalledWith(eventData);
 });
 
-test('deprecated_fireEventSync.changeText', () => {
+test('unsafe_fireEventSync.changeText', () => {
   const onChangeTextMock = jest.fn();
 
-  render(
+  unsafe_renderSync(
     <View>
       <TextInput placeholder="Customer placeholder" onChangeText={onChangeTextMock} />
     </View>,
   );
 
   const input = screen.getByPlaceholderText('Customer placeholder');
-  deprecated_fireEventSync.changeText(input, 'content');
+  unsafe_fireEventSync.changeText(input, 'content');
   expect(onChangeTextMock).toHaveBeenCalledWith('content');
 });
 
 it('sets native state value for unmanaged text inputs', () => {
-  render(<TextInput testID="input" />);
+  unsafe_renderSync(<TextInput testID="input" />);
 
   const input = screen.getByTestId('input');
   expect(input).toHaveDisplayValue('');
 
-  deprecated_fireEventSync.changeText(input, 'abc');
+  unsafe_fireEventSync.changeText(input, 'abc');
   expect(input).toHaveDisplayValue('abc');
 });
 
 test('custom component with custom event name', () => {
   const handlePress = jest.fn();
 
-  render(<CustomEventComponentWithCustomName handlePress={handlePress} />);
+  unsafe_renderSync(<CustomEventComponentWithCustomName handlePress={handlePress} />);
 
-  deprecated_fireEventSync(screen.getByText('Custom component'), 'handlePress');
+  unsafe_fireEventSync(screen.getByText('Custom component'), 'handlePress');
 
   expect(handlePress).toHaveBeenCalled();
 });
@@ -158,16 +160,16 @@ test('custom component with custom event name', () => {
 test('event with multiple handler parameters', () => {
   const handlePress = jest.fn();
 
-  render(<CustomEventComponentWithCustomName handlePress={handlePress} />);
+  unsafe_renderSync(<CustomEventComponentWithCustomName handlePress={handlePress} />);
 
-  deprecated_fireEventSync(screen.getByText('Custom component'), 'handlePress', 'param1', 'param2');
+  unsafe_fireEventSync(screen.getByText('Custom component'), 'handlePress', 'param1', 'param2');
 
   expect(handlePress).toHaveBeenCalledWith('param1', 'param2');
 });
 
 test('should not fire on disabled TouchableOpacity', () => {
   const handlePress = jest.fn();
-  render(
+  unsafe_renderSync(
     <View>
       <TouchableOpacity onPress={handlePress} disabled={true}>
         <Text>Trigger</Text>
@@ -175,13 +177,13 @@ test('should not fire on disabled TouchableOpacity', () => {
     </View>,
   );
 
-  deprecated_fireEventSync.press(screen.getByText('Trigger'));
+  unsafe_fireEventSync.press(screen.getByText('Trigger'));
   expect(handlePress).not.toHaveBeenCalled();
 });
 
 test('should not fire on disabled Pressable', () => {
   const handlePress = jest.fn();
-  render(
+  unsafe_renderSync(
     <View>
       <Pressable onPress={handlePress} disabled={true}>
         <Text>Trigger</Text>
@@ -189,13 +191,13 @@ test('should not fire on disabled Pressable', () => {
     </View>,
   );
 
-  deprecated_fireEventSync.press(screen.getByText('Trigger'));
+  unsafe_fireEventSync.press(screen.getByText('Trigger'));
   expect(handlePress).not.toHaveBeenCalled();
 });
 
 test('should not fire inside View with pointerEvents="none" in props', () => {
   const onPress = jest.fn();
-  render(
+  unsafe_renderSync(
     <View pointerEvents="none">
       <Pressable onPress={onPress}>
         <Text>Trigger</Text>
@@ -203,14 +205,14 @@ test('should not fire inside View with pointerEvents="none" in props', () => {
     </View>,
   );
 
-  deprecated_fireEventSync.press(screen.getByText('Trigger'));
-  deprecated_fireEventSync(screen.getByText('Trigger'), 'onPress');
+  unsafe_fireEventSync.press(screen.getByText('Trigger'));
+  unsafe_fireEventSync(screen.getByText('Trigger'), 'onPress');
   expect(onPress).not.toHaveBeenCalled();
 });
 
 test('should not fire inside View with pointerEvents="none" in styles', () => {
   const onPress = jest.fn();
-  render(
+  unsafe_renderSync(
     <View style={{ pointerEvents: 'none' }}>
       <Pressable onPress={onPress}>
         <Text>Trigger</Text>
@@ -218,14 +220,14 @@ test('should not fire inside View with pointerEvents="none" in styles', () => {
     </View>,
   );
 
-  deprecated_fireEventSync.press(screen.getByText('Trigger'));
-  deprecated_fireEventSync(screen.getByText('Trigger'), 'onPress');
+  unsafe_fireEventSync.press(screen.getByText('Trigger'));
+  unsafe_fireEventSync(screen.getByText('Trigger'), 'onPress');
   expect(onPress).not.toHaveBeenCalled();
 });
 
 test('should not fire inside View with pointerEvents="none" in styles array', () => {
   const onPress = jest.fn();
-  render(
+  unsafe_renderSync(
     <View style={[{ pointerEvents: 'none' }]}>
       <Pressable onPress={onPress}>
         <Text>Trigger</Text>
@@ -233,14 +235,14 @@ test('should not fire inside View with pointerEvents="none" in styles array', ()
     </View>,
   );
 
-  deprecated_fireEventSync.press(screen.getByText('Trigger'));
-  deprecated_fireEventSync(screen.getByText('Trigger'), 'onPress');
+  unsafe_fireEventSync.press(screen.getByText('Trigger'));
+  unsafe_fireEventSync(screen.getByText('Trigger'), 'onPress');
   expect(onPress).not.toHaveBeenCalled();
 });
 
 test('should not fire inside View with pointerEvents="box-only" in props', () => {
   const onPress = jest.fn();
-  render(
+  unsafe_renderSync(
     <View pointerEvents="box-only">
       <Pressable onPress={onPress}>
         <Text>Trigger</Text>
@@ -248,14 +250,14 @@ test('should not fire inside View with pointerEvents="box-only" in props', () =>
     </View>,
   );
 
-  deprecated_fireEventSync.press(screen.getByText('Trigger'));
-  deprecated_fireEventSync(screen.getByText('Trigger'), 'onPress');
+  unsafe_fireEventSync.press(screen.getByText('Trigger'));
+  unsafe_fireEventSync(screen.getByText('Trigger'), 'onPress');
   expect(onPress).not.toHaveBeenCalled();
 });
 
 test('should not fire inside View with pointerEvents="box-only" in styles', () => {
   const onPress = jest.fn();
-  render(
+  unsafe_renderSync(
     <View style={{ pointerEvents: 'box-only' }}>
       <Pressable onPress={onPress}>
         <Text>Trigger</Text>
@@ -263,14 +265,14 @@ test('should not fire inside View with pointerEvents="box-only" in styles', () =
     </View>,
   );
 
-  deprecated_fireEventSync.press(screen.getByText('Trigger'));
-  deprecated_fireEventSync(screen.getByText('Trigger'), 'onPress');
+  unsafe_fireEventSync.press(screen.getByText('Trigger'));
+  unsafe_fireEventSync(screen.getByText('Trigger'), 'onPress');
   expect(onPress).not.toHaveBeenCalled();
 });
 
 test('should fire inside View with pointerEvents="box-none" in props', () => {
   const onPress = jest.fn();
-  render(
+  unsafe_renderSync(
     <View pointerEvents="box-none">
       <Pressable onPress={onPress}>
         <Text>Trigger</Text>
@@ -278,14 +280,14 @@ test('should fire inside View with pointerEvents="box-none" in props', () => {
     </View>,
   );
 
-  deprecated_fireEventSync.press(screen.getByText('Trigger'));
-  deprecated_fireEventSync(screen.getByText('Trigger'), 'onPress');
+  unsafe_fireEventSync.press(screen.getByText('Trigger'));
+  unsafe_fireEventSync(screen.getByText('Trigger'), 'onPress');
   expect(onPress).toHaveBeenCalledTimes(2);
 });
 
 test('should fire inside View with pointerEvents="box-none" in styles', () => {
   const onPress = jest.fn();
-  render(
+  unsafe_renderSync(
     <View style={{ pointerEvents: 'box-none' }}>
       <Pressable onPress={onPress}>
         <Text>Trigger</Text>
@@ -293,14 +295,14 @@ test('should fire inside View with pointerEvents="box-none" in styles', () => {
     </View>,
   );
 
-  deprecated_fireEventSync.press(screen.getByText('Trigger'));
-  deprecated_fireEventSync(screen.getByText('Trigger'), 'onPress');
+  unsafe_fireEventSync.press(screen.getByText('Trigger'));
+  unsafe_fireEventSync(screen.getByText('Trigger'), 'onPress');
   expect(onPress).toHaveBeenCalledTimes(2);
 });
 
 test('should fire inside View with pointerEvents="auto" in props', () => {
   const onPress = jest.fn();
-  render(
+  unsafe_renderSync(
     <View pointerEvents="auto">
       <Pressable onPress={onPress}>
         <Text>Trigger</Text>
@@ -308,14 +310,14 @@ test('should fire inside View with pointerEvents="auto" in props', () => {
     </View>,
   );
 
-  deprecated_fireEventSync.press(screen.getByText('Trigger'));
-  deprecated_fireEventSync(screen.getByText('Trigger'), 'onPress');
+  unsafe_fireEventSync.press(screen.getByText('Trigger'));
+  unsafe_fireEventSync(screen.getByText('Trigger'), 'onPress');
   expect(onPress).toHaveBeenCalledTimes(2);
 });
 
 test('should fire inside View with pointerEvents="auto" in styles', () => {
   const onPress = jest.fn();
-  render(
+  unsafe_renderSync(
     <View style={{ pointerEvents: 'auto' }}>
       <Pressable onPress={onPress}>
         <Text>Trigger</Text>
@@ -323,14 +325,14 @@ test('should fire inside View with pointerEvents="auto" in styles', () => {
     </View>,
   );
 
-  deprecated_fireEventSync.press(screen.getByText('Trigger'));
-  deprecated_fireEventSync(screen.getByText('Trigger'), 'onPress');
+  unsafe_fireEventSync.press(screen.getByText('Trigger'));
+  unsafe_fireEventSync(screen.getByText('Trigger'), 'onPress');
   expect(onPress).toHaveBeenCalledTimes(2);
 });
 
 test('should not fire deeply inside View with pointerEvents="box-only" in props', () => {
   const onPress = jest.fn();
-  render(
+  unsafe_renderSync(
     <View pointerEvents="box-only">
       <View>
         <Pressable onPress={onPress}>
@@ -340,14 +342,14 @@ test('should not fire deeply inside View with pointerEvents="box-only" in props'
     </View>,
   );
 
-  deprecated_fireEventSync.press(screen.getByText('Trigger'));
-  deprecated_fireEventSync(screen.getByText('Trigger'), 'onPress');
+  unsafe_fireEventSync.press(screen.getByText('Trigger'));
+  unsafe_fireEventSync(screen.getByText('Trigger'), 'onPress');
   expect(onPress).not.toHaveBeenCalled();
 });
 
 test('should not fire deeply inside View with pointerEvents="box-only" in styles', () => {
   const onPress = jest.fn();
-  render(
+  unsafe_renderSync(
     <View style={{ pointerEvents: 'box-only' }}>
       <View>
         <Pressable onPress={onPress}>
@@ -357,40 +359,44 @@ test('should not fire deeply inside View with pointerEvents="box-only" in styles
     </View>,
   );
 
-  deprecated_fireEventSync.press(screen.getByText('Trigger'));
-  deprecated_fireEventSync(screen.getByText('Trigger'), 'onPress');
+  unsafe_fireEventSync.press(screen.getByText('Trigger'));
+  unsafe_fireEventSync(screen.getByText('Trigger'), 'onPress');
   expect(onPress).not.toHaveBeenCalled();
 });
 
 test('should fire non-pointer events inside View with pointerEvents="box-none" in props', () => {
   const onTouchStart = jest.fn();
-  render(<View testID="view" pointerEvents="box-none" onTouchStart={onTouchStart} />);
+  unsafe_renderSync(<View testID="view" pointerEvents="box-none" onTouchStart={onTouchStart} />);
 
-  deprecated_fireEventSync(screen.getByTestId('view'), 'touchStart');
+  unsafe_fireEventSync(screen.getByTestId('view'), 'touchStart');
   expect(onTouchStart).toHaveBeenCalled();
 });
 
 test('should fire non-pointer events inside View with pointerEvents="box-none" in styles', () => {
   const onTouchStart = jest.fn();
-  render(<View testID="view" style={{ pointerEvents: 'box-none' }} onTouchStart={onTouchStart} />);
+  unsafe_renderSync(
+    <View testID="view" style={{ pointerEvents: 'box-none' }} onTouchStart={onTouchStart} />,
+  );
 
-  deprecated_fireEventSync(screen.getByTestId('view'), 'touchStart');
+  unsafe_fireEventSync(screen.getByTestId('view'), 'touchStart');
   expect(onTouchStart).toHaveBeenCalled();
 });
 
 test('should fire non-touch events inside View with pointerEvents="box-none" in props', () => {
   const onLayout = jest.fn();
-  render(<View testID="view" pointerEvents="box-none" onLayout={onLayout} />);
+  unsafe_renderSync(<View testID="view" pointerEvents="box-none" onLayout={onLayout} />);
 
-  deprecated_fireEventSync(screen.getByTestId('view'), 'layout');
+  unsafe_fireEventSync(screen.getByTestId('view'), 'layout');
   expect(onLayout).toHaveBeenCalled();
 });
 
 test('should fire non-touch events inside View with pointerEvents="box-none" in styles', () => {
   const onLayout = jest.fn();
-  render(<View testID="view" style={{ pointerEvents: 'box-none' }} onLayout={onLayout} />);
+  unsafe_renderSync(
+    <View testID="view" style={{ pointerEvents: 'box-none' }} onLayout={onLayout} />,
+  );
 
-  deprecated_fireEventSync(screen.getByTestId('view'), 'layout');
+  unsafe_fireEventSync(screen.getByTestId('view'), 'layout');
   expect(onLayout).toHaveBeenCalled();
 });
 
@@ -398,24 +404,26 @@ test('should fire non-touch events inside View with pointerEvents="box-none" in
 // the 'press' event on host View rendered by pressable.
 test('should fire on Pressable with pointerEvents="box-only" in props', () => {
   const onPress = jest.fn();
-  render(<Pressable testID="pressable" pointerEvents="box-only" onPress={onPress} />);
+  unsafe_renderSync(<Pressable testID="pressable" pointerEvents="box-only" onPress={onPress} />);
 
-  deprecated_fireEventSync.press(screen.getByTestId('pressable'));
+  unsafe_fireEventSync.press(screen.getByTestId('pressable'));
   expect(onPress).toHaveBeenCalled();
 });
 
 test('should fire on Pressable with pointerEvents="box-only" in styles', () => {
   const onPress = jest.fn();
-  render(<Pressable testID="pressable" style={{ pointerEvents: 'box-only' }} onPress={onPress} />);
+  unsafe_renderSync(
+    <Pressable testID="pressable" style={{ pointerEvents: 'box-only' }} onPress={onPress} />,
+  );
 
-  deprecated_fireEventSync.press(screen.getByTestId('pressable'));
+  unsafe_fireEventSync.press(screen.getByTestId('pressable'));
   expect(onPress).toHaveBeenCalled();
 });
 
 test('should pass event up on disabled TouchableOpacity', () => {
   const handleInnerPress = jest.fn();
   const handleOuterPress = jest.fn();
-  render(
+  unsafe_renderSync(
     <TouchableOpacity onPress={handleOuterPress}>
       <TouchableOpacity onPress={handleInnerPress} disabled={true}>
         <Text>Inner Trigger</Text>
@@ -423,7 +431,7 @@ test('should pass event up on disabled TouchableOpacity', () => {
     </TouchableOpacity>,
   );
 
-  deprecated_fireEventSync.press(screen.getByText('Inner Trigger'));
+  unsafe_fireEventSync.press(screen.getByText('Inner Trigger'));
   expect(handleInnerPress).not.toHaveBeenCalled();
   expect(handleOuterPress).toHaveBeenCalledTimes(1);
 });
@@ -431,7 +439,7 @@ test('should pass event up on disabled TouchableOpacity', () => {
 test('should pass event up on disabled Pressable', () => {
   const handleInnerPress = jest.fn();
   const handleOuterPress = jest.fn();
-  render(
+  unsafe_renderSync(
     <Pressable onPress={handleOuterPress}>
       <Pressable onPress={handleInnerPress} disabled={true}>
         <Text>Inner Trigger</Text>
@@ -439,7 +447,7 @@ test('should pass event up on disabled Pressable', () => {
     </Pressable>,
   );
 
-  deprecated_fireEventSync.press(screen.getByText('Inner Trigger'));
+  unsafe_fireEventSync.press(screen.getByText('Inner Trigger'));
   expect(handleInnerPress).not.toHaveBeenCalled();
   expect(handleOuterPress).toHaveBeenCalledTimes(1);
 });
@@ -458,9 +466,9 @@ const TestComponent = ({ onPress }: TestComponentProps) => {
 
 test('is not fooled by non-native disabled prop', () => {
   const handlePress = jest.fn();
-  render(<TestComponent onPress={handlePress} disabled={true} />);
+  unsafe_renderSync(<TestComponent onPress={handlePress} disabled={true} />);
 
-  deprecated_fireEventSync.press(screen.getByText('Trigger Test'));
+  unsafe_fireEventSync.press(screen.getByText('Trigger Test'));
   expect(handlePress).toHaveBeenCalledTimes(1);
 });
 
@@ -482,13 +490,13 @@ function TestChildTouchableComponent({ onPress, someProp }: TestChildTouchableCo
 test('is not fooled by non-responder wrapping host elements', () => {
   const handlePress = jest.fn();
 
-  render(
+  unsafe_renderSync(
     <View>
       <TestChildTouchableComponent onPress={handlePress} someProp={true} />
     </View>,
   );
 
-  deprecated_fireEventSync.press(screen.getByText('Trigger'));
+  unsafe_fireEventSync.press(screen.getByText('Trigger'));
   expect(handlePress).not.toHaveBeenCalled();
 });
 
@@ -510,62 +518,64 @@ function TestDraggableComponent({ onDrag }: TestDraggableComponentProps) {
 test('has only onMove', () => {
   const handleDrag = jest.fn();
 
-  render(<TestDraggableComponent onDrag={handleDrag} />);
+  unsafe_renderSync(<TestDraggableComponent onDrag={handleDrag} />);
 
-  deprecated_fireEventSync(screen.getByText('Trigger'), 'responderMove', {
+  unsafe_fireEventSync(screen.getByText('Trigger'), 'responderMove', {
     touchHistory: { mostRecentTimeStamp: '2', touchBank: [] },
   });
   expect(handleDrag).toHaveBeenCalled();
 });
 
-// Those events ideally should be triggered through `deprecated_fireEventSync.scroll`, but they are handled at the
+// Those events ideally should be triggered through `unsafe_fireEventSync.scroll`, but they are handled at the
 // native level, so we need to support manually triggering them
 describe('native events', () => {
   test('triggers onScrollBeginDrag', () => {
     const onScrollBeginDragSpy = jest.fn();
-    render(<ScrollView testID="test-id" onScrollBeginDrag={onScrollBeginDragSpy} />);
+    unsafe_renderSync(<ScrollView testID="test-id" onScrollBeginDrag={onScrollBeginDragSpy} />);
 
-    deprecated_fireEventSync(screen.getByTestId('test-id'), 'onScrollBeginDrag');
+    unsafe_fireEventSync(screen.getByTestId('test-id'), 'onScrollBeginDrag');
     expect(onScrollBeginDragSpy).toHaveBeenCalled();
   });
 
   test('triggers onScrollEndDrag', () => {
     const onScrollEndDragSpy = jest.fn();
-    render(<ScrollView testID="test-id" onScrollEndDrag={onScrollEndDragSpy} />);
+    unsafe_renderSync(<ScrollView testID="test-id" onScrollEndDrag={onScrollEndDragSpy} />);
 
-    deprecated_fireEventSync(screen.getByTestId('test-id'), 'onScrollEndDrag');
+    unsafe_fireEventSync(screen.getByTestId('test-id'), 'onScrollEndDrag');
     expect(onScrollEndDragSpy).toHaveBeenCalled();
   });
 
   test('triggers onMomentumScrollBegin', () => {
     const onMomentumScrollBeginSpy = jest.fn();
-    render(<ScrollView testID="test-id" onMomentumScrollBegin={onMomentumScrollBeginSpy} />);
+    unsafe_renderSync(
+      <ScrollView testID="test-id" onMomentumScrollBegin={onMomentumScrollBeginSpy} />,
+    );
 
-    deprecated_fireEventSync(screen.getByTestId('test-id'), 'onMomentumScrollBegin');
+    unsafe_fireEventSync(screen.getByTestId('test-id'), 'onMomentumScrollBegin');
     expect(onMomentumScrollBeginSpy).toHaveBeenCalled();
   });
 
   test('triggers onMomentumScrollEnd', () => {
     const onMomentumScrollEndSpy = jest.fn();
-    render(<ScrollView testID="test-id" onMomentumScrollEnd={onMomentumScrollEndSpy} />);
+    unsafe_renderSync(<ScrollView testID="test-id" onMomentumScrollEnd={onMomentumScrollEndSpy} />);
 
-    deprecated_fireEventSync(screen.getByTestId('test-id'), 'onMomentumScrollEnd');
+    unsafe_fireEventSync(screen.getByTestId('test-id'), 'onMomentumScrollEnd');
     expect(onMomentumScrollEndSpy).toHaveBeenCalled();
   });
 });
 
 test('should handle unmounted elements gracefully', () => {
   const onPress = jest.fn();
-  render(
+  const { unmount } = unsafe_renderSync(
     <TouchableOpacity onPress={onPress}>
       <Text>Test</Text>
     </TouchableOpacity>,
   );
 
   const element = screen.getByText('Test');
-  screen.unmount();
+  unmount();
 
   // Firing event on unmounted element should not crash
-  deprecated_fireEventSync.press(element);
+  unsafe_fireEventSync.press(element);
   expect(onPress).not.toHaveBeenCalled();
 });
diff --git a/src/__tests__/deprecated/render-hook-sync.test.tsx b/src/__tests__/unsafe-render-hook-sync.test.tsx
similarity index 82%
rename from src/__tests__/deprecated/render-hook-sync.test.tsx
rename to src/__tests__/unsafe-render-hook-sync.test.tsx
index 53a5e2ca8..fd95f491d 100644
--- a/src/__tests__/deprecated/render-hook-sync.test.tsx
+++ b/src/__tests__/unsafe-render-hook-sync.test.tsx
@@ -1,10 +1,10 @@
 import type { ReactNode } from 'react';
 import * as React from 'react';
 
-import { deprecated_renderHookSync } from '../../pure';
+import { unsafe_renderHookSync } from '../pure';
 
 test('renders hook and returns committed result', () => {
-  const { result } = deprecated_renderHookSync(() => {
+  const { result } = unsafe_renderHookSync(() => {
     const [state, setState] = React.useState(1);
 
     React.useEffect(() => {
@@ -22,7 +22,7 @@ test('works with wrapper option', () => {
   function Wrapper({ children }: { children: ReactNode }) {
     return <Context.Provider value="provided">{children}</Context.Provider>;
   }
-  const { result } = deprecated_renderHookSync(
+  const { result } = unsafe_renderHookSync(
     () => {
       return React.useContext(Context);
     },
@@ -35,7 +35,7 @@ test('works with wrapper option', () => {
 });
 
 test('works with initialProps option', () => {
-  const { result } = deprecated_renderHookSync(
+  const { result } = unsafe_renderHookSync(
     (props: { branch: 'left' | 'right' }) => {
       const [left, setLeft] = React.useState('left');
       const [right, setRight] = React.useState('right');
@@ -61,12 +61,12 @@ test('works without initialProps option', () => {
     return { count, setCount };
   }
 
-  const { result } = deprecated_renderHookSync(useTestHook);
+  const { result } = unsafe_renderHookSync(useTestHook);
   expect(result.current.count).toBe(0);
 });
 
 test('rerender updates hook with new props', () => {
-  const { result, rerender } = deprecated_renderHookSync(
+  const { result, rerender } = unsafe_renderHookSync(
     (props: { branch: 'left' | 'right' }) => {
       const [left, setLeft] = React.useState('left');
       const [right, setRight] = React.useState('right');
@@ -102,7 +102,7 @@ test('unmount triggers cleanup effects', () => {
     return 'test';
   }
 
-  const { unmount } = deprecated_renderHookSync(useTestHook);
+  const { unmount } = unsafe_renderHookSync(useTestHook);
   expect(cleanupCalled).toBe(false);
 
   unmount();
@@ -114,7 +114,7 @@ function useMyHook<T>(param: T) {
 }
 
 test('props type is inferred correctly when initial props is defined', () => {
-  const { result, rerender } = deprecated_renderHookSync((num: number) => useMyHook(num), {
+  const { result, rerender } = unsafe_renderHookSync((num: number) => useMyHook(num), {
     initialProps: 5,
   });
   expect(result.current.param).toBe(5);
@@ -124,12 +124,9 @@ test('props type is inferred correctly when initial props is defined', () => {
 });
 
 test('props type is inferred correctly when initial props is explicitly undefined', () => {
-  const { result, rerender } = deprecated_renderHookSync(
-    (num: number | undefined) => useMyHook(num),
-    {
-      initialProps: undefined,
-    },
-  );
+  const { result, rerender } = unsafe_renderHookSync((num: number | undefined) => useMyHook(num), {
+    initialProps: undefined,
+  });
 
   expect(result.current.param).toBeUndefined();
 
diff --git a/src/__tests__/unsafe-render-sync.test.tsx b/src/__tests__/unsafe-render-sync.test.tsx
new file mode 100644
index 000000000..38596dd94
--- /dev/null
+++ b/src/__tests__/unsafe-render-sync.test.tsx
@@ -0,0 +1,185 @@
+import * as React from 'react';
+import { Pressable, Text, TextInput, View } from 'react-native';
+
+import { screen, unsafe_fireEventSync, unsafe_renderSync } from '..';
+
+const PLACEHOLDER_FRESHNESS = 'Add custom freshness';
+const PLACEHOLDER_CHEF = 'Who inspected freshness?';
+const INPUT_FRESHNESS = 'Custom Freshie';
+const INPUT_CHEF = 'I inspected freshie';
+const DEFAULT_INPUT_CHEF = 'What did you inspect?';
+const DEFAULT_INPUT_CUSTOMER = 'What banana?';
+
+class MyButton extends React.Component<any> {
+  render() {
+    return (
+      <Pressable onPress={this.props.onPress}>
+        <Text>{this.props.children}</Text>
+      </Pressable>
+    );
+  }
+}
+
+class Banana extends React.Component<any, { fresh: boolean }> {
+  state = {
+    fresh: false,
+  };
+
+  componentDidUpdate() {
+    if (this.props.onUpdate) {
+      this.props.onUpdate();
+    }
+  }
+
+  componentWillUnmount() {
+    if (this.props.onUnmount) {
+      this.props.onUnmount();
+    }
+  }
+
+  changeFresh = () => {
+    this.setState((state) => ({
+      fresh: !state.fresh,
+    }));
+  };
+
+  render() {
+    const test = 0;
+    return (
+      <View>
+        <Text>Is the banana fresh?</Text>
+        <Text testID="bananaFresh">{this.state.fresh ? 'fresh' : 'not fresh'}</Text>
+        <TextInput
+          testID="bananaCustomFreshness"
+          placeholder={PLACEHOLDER_FRESHNESS}
+          value={INPUT_FRESHNESS}
+        />
+        <TextInput
+          testID="bananaChef"
+          placeholder={PLACEHOLDER_CHEF}
+          value={INPUT_CHEF}
+          defaultValue={DEFAULT_INPUT_CHEF}
+        />
+        <TextInput defaultValue={DEFAULT_INPUT_CUSTOMER} />
+        <TextInput defaultValue={'hello'} value="" />
+        <MyButton onPress={this.changeFresh} type="primary">
+          Change freshness!
+        </MyButton>
+        <Text testID="duplicateText">First Text</Text>
+        <Text testID="duplicateText">Second Text</Text>
+        <Text>{test}</Text>
+      </View>
+    );
+  }
+}
+
+test('supports basic rendering', () => {
+  unsafe_renderSync(<View testID="test" />);
+  expect(screen.root).toBeOnTheScreen();
+});
+
+test('rerender', () => {
+  const fn = jest.fn();
+  const { rerender } = unsafe_renderSync(<Banana onUpdate={fn} />);
+  expect(fn).toHaveBeenCalledTimes(0);
+
+  unsafe_fireEventSync.press(screen.getByText('Change freshness!'));
+  expect(fn).toHaveBeenCalledTimes(1);
+
+  rerender(<Banana onUpdate={fn} />);
+  expect(fn).toHaveBeenCalledTimes(2);
+});
+
+test('unmount', () => {
+  const fn = jest.fn();
+  const { unmount } = unsafe_renderSync(<Banana onUnmount={fn} />);
+  unmount();
+  expect(fn).toHaveBeenCalled();
+});
+
+test('unmount should handle cleanup functions', () => {
+  const cleanup = jest.fn();
+  const Component = () => {
+    React.useEffect(() => cleanup);
+    return null;
+  };
+
+  const { unmount } = unsafe_renderSync(<Component />);
+
+  unmount();
+
+  expect(cleanup).toHaveBeenCalledTimes(1);
+});
+
+test('toJSON renders host output', () => {
+  unsafe_renderSync(<MyButton>press me</MyButton>);
+  expect(screen).toMatchSnapshot();
+});
+
+test('renders options.wrapper around node', () => {
+  type WrapperComponentProps = { children: React.ReactNode };
+  const WrapperComponent = ({ children }: WrapperComponentProps) => (
+    <View testID="wrapper">{children}</View>
+  );
+
+  unsafe_renderSync(<View testID="inner" />, {
+    wrapper: WrapperComponent,
+  });
+
+  expect(screen.getByTestId('wrapper')).toBeTruthy();
+  expect(screen).toMatchInlineSnapshot(`
+    <View
+      testID="wrapper"
+    >
+      <View
+        testID="inner"
+      />
+    </View>
+  `);
+});
+
+test('renders options.wrapper around updated node', () => {
+  type WrapperComponentProps = { children: React.ReactNode };
+  const WrapperComponent = ({ children }: WrapperComponentProps) => (
+    <View testID="wrapper">{children}</View>
+  );
+
+  unsafe_renderSync(<View testID="inner" />, {
+    wrapper: WrapperComponent,
+  });
+
+  void screen.rerender(<View testID="inner" accessibilityLabel="test" accessibilityHint="test" />);
+
+  expect(screen.getByTestId('wrapper')).toBeTruthy();
+  expect(screen).toMatchInlineSnapshot(`
+    <View
+      testID="wrapper"
+    >
+      <View
+        testID="inner"
+      />
+    </View>
+  `);
+});
+
+test('returns host root', () => {
+  unsafe_renderSync(<View testID="inner" />);
+
+  expect(screen.root).toBeDefined();
+  expect(screen.root?.type).toBe('View');
+  expect(screen.root?.props.testID).toBe('inner');
+});
+
+test('RenderAPI type', () => {
+  // This test verifies that unsafe_renderSync returns a compatible type
+  // Note: unsafe_renderSync has different method signatures (sync vs async)
+  const result = unsafe_renderSync(<Banana />);
+  expect(result).toBeTruthy();
+});
+
+test('returned output can be spread using rest operator', () => {
+  // Next line should not throw
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  const { rerender, ...rest } = unsafe_renderSync(<View testID="test" />);
+  expect(rest).toBeTruthy();
+});
diff --git a/src/__tests__/wait-for-element-to-be-removed.test.tsx b/src/__tests__/wait-for-element-to-be-removed.test.tsx
index 0dda4ae87..b40ab679b 100644
--- a/src/__tests__/wait-for-element-to-be-removed.test.tsx
+++ b/src/__tests__/wait-for-element-to-be-removed.test.tsx
@@ -30,7 +30,7 @@ afterEach(() => {
 });
 
 test('waits when using getBy query', async () => {
-  render(<TestSetup />);
+  await render(<TestSetup />);
 
   await fireEvent.press(screen.getByText('Remove Element'));
   const element = screen.getByText('Observed Element');
@@ -42,7 +42,7 @@ test('waits when using getBy query', async () => {
 });
 
 test('waits when using getAllBy query', async () => {
-  render(<TestSetup />);
+  await render(<TestSetup />);
 
   await fireEvent.press(screen.getByText('Remove Element'));
   const elements = screen.getAllByText('Observed Element');
@@ -54,7 +54,7 @@ test('waits when using getAllBy query', async () => {
 });
 
 test('waits when using queryBy query', async () => {
-  render(<TestSetup />);
+  await render(<TestSetup />);
 
   await fireEvent.press(screen.getByText('Remove Element'));
   const element = screen.getByText('Observed Element');
@@ -66,7 +66,7 @@ test('waits when using queryBy query', async () => {
 });
 
 test('waits when using queryAllBy query', async () => {
-  render(<TestSetup />);
+  await render(<TestSetup />);
 
   await fireEvent.press(screen.getByText('Remove Element'));
   const elements = screen.getAllByText('Observed Element');
@@ -78,7 +78,7 @@ test('waits when using queryAllBy query', async () => {
 });
 
 test('checks if elements exist at start', async () => {
-  render(<TestSetup shouldUseDelay={false} />);
+  await render(<TestSetup shouldUseDelay={false} />);
 
   await fireEvent.press(screen.getByText('Remove Element'));
   expect(screen.queryByText('Observed Element')).toBeNull();
@@ -91,7 +91,7 @@ test('checks if elements exist at start', async () => {
 });
 
 test('waits until timeout', async () => {
-  render(<TestSetup />);
+  await render(<TestSetup />);
 
   await fireEvent.press(screen.getByText('Remove Element'));
   expect(screen.getByText('Observed Element')).toBeTruthy();
diff --git a/src/__tests__/wait-for.test.tsx b/src/__tests__/wait-for.test.tsx
index 4efd0253c..b9235b3e9 100644
--- a/src/__tests__/wait-for.test.tsx
+++ b/src/__tests__/wait-for.test.tsx
@@ -38,7 +38,7 @@ afterEach(() => {
 });
 
 test('waits for element until it stops throwing', async () => {
-  render(<BananaContainer />);
+  await render(<BananaContainer />);
 
   await fireEvent.press(screen.getByText('Change freshness!'));
 
@@ -50,7 +50,7 @@ test('waits for element until it stops throwing', async () => {
 });
 
 test('waits for element until timeout is met', async () => {
-  render(<BananaContainer />);
+  await render(<BananaContainer />);
 
   await fireEvent.press(screen.getByText('Change freshness!'));
 
@@ -63,7 +63,7 @@ test('waits for element until timeout is met', async () => {
 
 test('waitFor defaults to asyncWaitTimeout config option', async () => {
   configure({ asyncUtilTimeout: 100 });
-  render(<BananaContainer />);
+  await render(<BananaContainer />);
 
   await fireEvent.press(screen.getByText('Change freshness!'));
   await expect(waitFor(() => screen.getByText('Fresh'))).rejects.toThrow();
@@ -75,7 +75,7 @@ test('waitFor defaults to asyncWaitTimeout config option', async () => {
 
 test('waitFor timeout option takes precendence over `asyncWaitTimeout` config option', async () => {
   configure({ asyncUtilTimeout: 2000 });
-  render(<BananaContainer />);
+  await render(<BananaContainer />);
 
   await fireEvent.press(screen.getByText('Change freshness!'));
   await expect(waitFor(() => screen.getByText('Fresh'), { timeout: 100 })).rejects.toThrow();
@@ -125,7 +125,7 @@ const Comp = ({ onPress }: { onPress: () => void }) => {
 
 test('waits for async event with fireEvent', async () => {
   const spy = jest.fn();
-  render(<Comp onPress={spy} />);
+  await render(<Comp onPress={spy} />);
 
   await fireEvent.press(screen.getByText('Trigger'));
 
@@ -138,7 +138,7 @@ test.each([false, true])(
   'waits for element until it stops throwing using fake timers (legacyFakeTimers = %s)',
   async (legacyFakeTimers) => {
     jest.useFakeTimers({ legacyFakeTimers });
-    render(<BananaContainer />);
+    await render(<BananaContainer />);
 
     await fireEvent.press(screen.getByText('Change freshness!'));
     expect(screen.queryByText('Fresh')).toBeNull();
@@ -294,7 +294,7 @@ test.each([
     }
 
     const onPress = jest.fn();
-    render(<Apple onPress={onPress} />);
+    await render(<Apple onPress={onPress} />);
 
     // Required: this `waitFor` will succeed on first check, because the "root" view is there
     // since the initial mount.
diff --git a/src/__tests__/within.test.tsx b/src/__tests__/within.test.tsx
index 105aa081d..bd6889d99 100644
--- a/src/__tests__/within.test.tsx
+++ b/src/__tests__/within.test.tsx
@@ -4,7 +4,7 @@ import { Text, TextInput, View } from 'react-native';
 import { getQueriesForElement, render, within } from '..';
 
 test('within() exposes basic queries', async () => {
-  const rootQueries = render(
+  const rootQueries = await render(
     <View>
       <View accessibilityHint="first">
         <Text>Same Text</Text>
@@ -41,7 +41,7 @@ test('within() exposes basic queries', async () => {
 });
 
 test('within() exposes a11y queries', async () => {
-  const rootQueries = render(
+  const rootQueries = await render(
     <View>
       <View accessibilityHint="first">
         <TextInput
diff --git a/src/cleanup.ts b/src/cleanup.ts
index f85524389..5b6f056c0 100644
--- a/src/cleanup.ts
+++ b/src/cleanup.ts
@@ -1,18 +1,10 @@
 import { clearRenderResult } from './screen';
 
-type CleanUpFunction = () => void;
-type CleanUpFunctionAsync = () => Promise<void>;
+type CleanUpFunction = () => Promise<void> | void;
 
-const cleanupQueue = new Set<CleanUpFunction | CleanUpFunctionAsync>();
+const cleanupQueue = new Set<CleanUpFunction>();
 
-export default function cleanup() {
-  clearRenderResult();
-
-  cleanupQueue.forEach((fn) => fn());
-  cleanupQueue.clear();
-}
-
-export async function cleanupAsync() {
+export async function cleanup() {
   clearRenderResult();
 
   for (const fn of cleanupQueue) {
@@ -22,6 +14,6 @@ export async function cleanupAsync() {
   cleanupQueue.clear();
 }
 
-export function addToCleanupQueue(fn: CleanUpFunction | CleanUpFunctionAsync) {
+export function addToCleanupQueue(fn: CleanUpFunction) {
   cleanupQueue.add(fn);
 }
diff --git a/src/fire-event.ts b/src/fire-event.ts
index 17e1fb119..1fe38367c 100644
--- a/src/fire-event.ts
+++ b/src/fire-event.ts
@@ -157,7 +157,7 @@ fireEvent.scroll = async (element: HostElement, ...data: unknown[]) =>
   await fireEvent(element, 'scroll', ...data);
 
 /** @deprecated - Use async `fireEvent` instead. */
-function deprecated_fireEventSync(element: HostElement, eventName: EventName, ...data: unknown[]) {
+function unsafe_fireEventSync(element: HostElement, eventName: EventName, ...data: unknown[]) {
   if (!isElementMounted(element)) {
     return;
   }
@@ -178,18 +178,18 @@ function deprecated_fireEventSync(element: HostElement, eventName: EventName, ..
 }
 
 /** @deprecated - Use async `fireEvent.press` instead. */
-deprecated_fireEventSync.press = (element: HostElement, ...data: unknown[]) =>
-  deprecated_fireEventSync(element, 'press', ...data);
+unsafe_fireEventSync.press = (element: HostElement, ...data: unknown[]) =>
+  unsafe_fireEventSync(element, 'press', ...data);
 
 /** @deprecated - Use async `fireEvent.changeText` instead. */
-deprecated_fireEventSync.changeText = (element: HostElement, ...data: unknown[]) =>
-  deprecated_fireEventSync(element, 'changeText', ...data);
+unsafe_fireEventSync.changeText = (element: HostElement, ...data: unknown[]) =>
+  unsafe_fireEventSync(element, 'changeText', ...data);
 
 /** @deprecated - Use async `fireEvent.scroll` instead. */
-deprecated_fireEventSync.scroll = (element: HostElement, ...data: unknown[]) =>
-  deprecated_fireEventSync(element, 'scroll', ...data);
+unsafe_fireEventSync.scroll = (element: HostElement, ...data: unknown[]) =>
+  unsafe_fireEventSync(element, 'scroll', ...data);
 
-export { fireEvent, deprecated_fireEventSync };
+export { fireEvent, unsafe_fireEventSync };
 
 const scrollEventNames = new Set([
   'scroll',
diff --git a/src/helpers/__tests__/accessiblity.test.tsx b/src/helpers/__tests__/accessiblity.test.tsx
index dd277c596..64331884d 100644
--- a/src/helpers/__tests__/accessiblity.test.tsx
+++ b/src/helpers/__tests__/accessiblity.test.tsx
@@ -5,10 +5,10 @@ import { isHiddenFromAccessibility, isInaccessible, render, screen } from '../..
 import { computeAriaDisabled, computeAriaLabel, isAccessibilityElement } from '../accessibility';
 
 describe('isHiddenFromAccessibility', () => {
-  test('returns false for accessible elements', () => {
+  test('returns false for accessible elements', async () => {
     expect(
       isHiddenFromAccessibility(
-        render(<View testID="subject" />).getByTestId('subject', {
+        (await render(<View testID="subject" />)).getByTestId('subject', {
           includeHiddenElements: true,
         }),
       ),
@@ -16,7 +16,7 @@ describe('isHiddenFromAccessibility', () => {
 
     expect(
       isHiddenFromAccessibility(
-        render(<Text testID="subject">Hello</Text>).getByTestId('subject', {
+        (await render(<Text testID="subject">Hello</Text>)).getByTestId('subject', {
           includeHiddenElements: true,
         }),
       ),
@@ -24,7 +24,7 @@ describe('isHiddenFromAccessibility', () => {
 
     expect(
       isHiddenFromAccessibility(
-        render(<TextInput testID="subject" />).getByTestId('subject', {
+        (await render(<TextInput testID="subject" />)).getByTestId('subject', {
           includeHiddenElements: true,
         }),
       ),
@@ -35,8 +35,8 @@ describe('isHiddenFromAccessibility', () => {
     expect(isHiddenFromAccessibility(null)).toBe(true);
   });
 
-  test('detects elements with aria-hidden prop', () => {
-    render(<View testID="subject" aria-hidden />);
+  test('detects elements with aria-hidden prop', async () => {
+    await render(<View testID="subject" aria-hidden />);
     expect(
       isHiddenFromAccessibility(
         screen.getByTestId('subject', {
@@ -46,8 +46,8 @@ describe('isHiddenFromAccessibility', () => {
     ).toBe(true);
   });
 
-  test('detects nested elements with aria-hidden prop', () => {
-    render(
+  test('detects nested elements with aria-hidden prop', async () => {
+    await render(
       <View aria-hidden>
         <View testID="subject" />
       </View>,
@@ -61,8 +61,8 @@ describe('isHiddenFromAccessibility', () => {
     ).toBe(true);
   });
 
-  test('detects elements with accessibilityElementsHidden prop', () => {
-    render(<View testID="subject" accessibilityElementsHidden />);
+  test('detects elements with accessibilityElementsHidden prop', async () => {
+    await render(<View testID="subject" accessibilityElementsHidden />);
     expect(
       isHiddenFromAccessibility(
         screen.getByTestId('subject', {
@@ -72,8 +72,8 @@ describe('isHiddenFromAccessibility', () => {
     ).toBe(true);
   });
 
-  test('detects nested elements with accessibilityElementsHidden prop', () => {
-    render(
+  test('detects nested elements with accessibilityElementsHidden prop', async () => {
+    await render(
       <View accessibilityElementsHidden>
         <View testID="subject" />
       </View>,
@@ -87,8 +87,8 @@ describe('isHiddenFromAccessibility', () => {
     ).toBe(true);
   });
 
-  test('detects deeply nested elements with accessibilityElementsHidden prop', () => {
-    render(
+  test('detects deeply nested elements with accessibilityElementsHidden prop', async () => {
+    await render(
       <View accessibilityElementsHidden>
         <View>
           <View>
@@ -106,8 +106,8 @@ describe('isHiddenFromAccessibility', () => {
     ).toBe(true);
   });
 
-  test('detects elements with importantForAccessibility="no-hide-descendants" prop', () => {
-    render(<View testID="subject" importantForAccessibility="no-hide-descendants" />);
+  test('detects elements with importantForAccessibility="no-hide-descendants" prop', async () => {
+    await render(<View testID="subject" importantForAccessibility="no-hide-descendants" />);
     expect(
       isHiddenFromAccessibility(
         screen.getByTestId('subject', {
@@ -117,8 +117,8 @@ describe('isHiddenFromAccessibility', () => {
     ).toBe(true);
   });
 
-  test('detects nested elements with importantForAccessibility="no-hide-descendants" prop', () => {
-    render(
+  test('detects nested elements with importantForAccessibility="no-hide-descendants" prop', async () => {
+    await render(
       <View importantForAccessibility="no-hide-descendants">
         <View testID="subject" />
       </View>,
@@ -132,8 +132,8 @@ describe('isHiddenFromAccessibility', () => {
     ).toBe(true);
   });
 
-  test('detects elements with display=none', () => {
-    render(<View testID="subject" style={{ display: 'none' }} />);
+  test('detects elements with display=none', async () => {
+    await render(<View testID="subject" style={{ display: 'none' }} />);
     expect(
       isHiddenFromAccessibility(
         screen.getByTestId('subject', {
@@ -143,8 +143,8 @@ describe('isHiddenFromAccessibility', () => {
     ).toBe(true);
   });
 
-  test('detects nested elements with display=none', () => {
-    render(
+  test('detects nested elements with display=none', async () => {
+    await render(
       <View style={{ display: 'none' }}>
         <View testID="subject" />
       </View>,
@@ -158,8 +158,8 @@ describe('isHiddenFromAccessibility', () => {
     ).toBe(true);
   });
 
-  test('detects deeply nested elements with display=none', () => {
-    render(
+  test('detects deeply nested elements with display=none', async () => {
+    await render(
       <View style={{ display: 'none' }}>
         <View>
           <View>
@@ -177,8 +177,8 @@ describe('isHiddenFromAccessibility', () => {
     ).toBe(true);
   });
 
-  test('detects elements with display=none with complex style', () => {
-    render(
+  test('detects elements with display=none with complex style', async () => {
+    await render(
       <View
         testID="subject"
         style={[{ display: 'flex' }, [{ display: 'flex' }], { display: 'none' }]}
@@ -193,8 +193,8 @@ describe('isHiddenFromAccessibility', () => {
     ).toBe(true);
   });
 
-  test('is not trigged by opacity = 0', () => {
-    render(<View testID="subject" style={{ opacity: 0 }} />);
+  test('is not trigged by opacity = 0', async () => {
+    await render(<View testID="subject" style={{ opacity: 0 }} />);
     expect(
       isHiddenFromAccessibility(
         screen.getByTestId('subject', {
@@ -204,8 +204,8 @@ describe('isHiddenFromAccessibility', () => {
     ).toBe(false);
   });
 
-  test('detects siblings of element with accessibilityViewIsModal prop', () => {
-    render(
+  test('detects siblings of element with accessibilityViewIsModal prop', async () => {
+    await render(
       <View>
         <View accessibilityViewIsModal />
         <View testID="subject" />
@@ -220,8 +220,8 @@ describe('isHiddenFromAccessibility', () => {
     ).toBe(true);
   });
 
-  test('detects deeply nested siblings of element with accessibilityViewIsModal prop', () => {
-    render(
+  test('detects deeply nested siblings of element with accessibilityViewIsModal prop', async () => {
+    await render(
       <View>
         <View accessibilityViewIsModal />
         <View>
@@ -236,8 +236,8 @@ describe('isHiddenFromAccessibility', () => {
     ).toBe(true);
   });
 
-  test('detects siblings of element with "aria-modal" prop', () => {
-    render(
+  test('detects siblings of element with "aria-modal" prop', async () => {
+    await render(
       <View>
         <View aria-modal />
         <View testID="subject" />
@@ -248,13 +248,13 @@ describe('isHiddenFromAccessibility', () => {
     ).toBe(true);
   });
 
-  test('is not triggered for element with accessibilityViewIsModal prop', () => {
-    render(<View accessibilityViewIsModal testID="subject" />);
+  test('is not triggered for element with accessibilityViewIsModal prop', async () => {
+    await render(<View accessibilityViewIsModal testID="subject" />);
     expect(isHiddenFromAccessibility(screen.getByTestId('subject'))).toBe(false);
   });
 
-  test('is not triggered for child of element with accessibilityViewIsModal prop', () => {
-    render(
+  test('is not triggered for child of element with accessibilityViewIsModal prop', async () => {
+    await render(
       <View accessibilityViewIsModal>
         <View testID="subject" />
       </View>,
@@ -262,8 +262,8 @@ describe('isHiddenFromAccessibility', () => {
     expect(isHiddenFromAccessibility(screen.getByTestId('subject'))).toBe(false);
   });
 
-  test('is not triggered for descendent of element with accessibilityViewIsModal prop', () => {
-    render(
+  test('is not triggered for descendent of element with accessibilityViewIsModal prop', async () => {
+    await render(
       <View accessibilityViewIsModal>
         <View>
           <View>
@@ -279,15 +279,15 @@ describe('isHiddenFromAccessibility', () => {
     expect(isInaccessible).toBe(isHiddenFromAccessibility);
   });
 
-  test('is not triggered for element with "aria-modal" prop', () => {
-    render(<View aria-modal testID="subject" />);
+  test('is not triggered for element with "aria-modal" prop', async () => {
+    await render(<View aria-modal testID="subject" />);
     expect(isHiddenFromAccessibility(screen.getByTestId('subject'))).toBe(false);
   });
 });
 
 describe('isAccessibilityElement', () => {
-  test('matches View component properly', () => {
-    render(
+  test('matches View component properly', async () => {
+    await render(
       <View>
         <View testID="default" />
         <View testID="true" accessible />
@@ -299,8 +299,8 @@ describe('isAccessibilityElement', () => {
     expect(isAccessibilityElement(screen.getByTestId('false'))).toBeFalsy();
   });
 
-  test('matches TextInput component properly', () => {
-    render(
+  test('matches TextInput component properly', async () => {
+    await render(
       <View>
         <TextInput testID="default" />
         <TextInput testID="true" accessible />
@@ -312,8 +312,8 @@ describe('isAccessibilityElement', () => {
     expect(isAccessibilityElement(screen.getByTestId('false'))).toBeFalsy();
   });
 
-  test('matches Text component properly', () => {
-    render(
+  test('matches Text component properly', async () => {
+    await render(
       <View>
         <Text testID="default">Default</Text>
         <Text testID="true" accessible>
@@ -329,8 +329,8 @@ describe('isAccessibilityElement', () => {
     expect(isAccessibilityElement(screen.getByTestId('false'))).toBeFalsy();
   });
 
-  test('matches Switch component properly', () => {
-    render(
+  test('matches Switch component properly', async () => {
+    await render(
       <View>
         <Switch testID="default" />
         <Switch testID="true" accessible />
@@ -342,8 +342,8 @@ describe('isAccessibilityElement', () => {
     expect(isAccessibilityElement(screen.getByTestId('false'))).toBeFalsy();
   });
 
-  test('matches Pressable component properly', () => {
-    render(
+  test('matches Pressable component properly', async () => {
+    await render(
       <View>
         <Pressable testID="default" />
         <Pressable testID="true" accessible />
@@ -355,8 +355,8 @@ describe('isAccessibilityElement', () => {
     expect(isAccessibilityElement(screen.getByTestId('false'))).toBeFalsy();
   });
 
-  test('matches TouchableOpacity component properly', () => {
-    render(
+  test('matches TouchableOpacity component properly', async () => {
+    await render(
       <View>
         <TouchableOpacity testID="default" />
         <TouchableOpacity testID="true" accessible />
@@ -374,8 +374,8 @@ describe('isAccessibilityElement', () => {
 });
 
 describe('computeAriaLabel', () => {
-  test('supports basic usage', () => {
-    render(
+  test('supports basic usage', async () => {
+    await render(
       <View>
         <View testID="label" aria-label="Internal Label" />
         <View testID="label-by-id" aria-labelledby="external-label" />
@@ -395,8 +395,8 @@ describe('computeAriaLabel', () => {
     expect(computeAriaLabel(screen.getByTestId('text-content'))).toBeUndefined();
   });
 
-  test('label priority', () => {
-    render(
+  test('label priority', async () => {
+    await render(
       <View>
         <View testID="subject" aria-label="Internal Label" aria-labelledby="external-content" />
         <View nativeID="external-content">
@@ -410,8 +410,8 @@ describe('computeAriaLabel', () => {
 });
 
 describe('computeAriaDisabled', () => {
-  test('supports basic usage', () => {
-    render(
+  test('supports basic usage', async () => {
+    await render(
       <View>
         <View testID="default" />
         <View testID="disabled" aria-disabled />
@@ -428,8 +428,8 @@ describe('computeAriaDisabled', () => {
     expect(computeAriaDisabled(screen.getByTestId('disabled-false-by-state'))).toBe(false);
   });
 
-  test('supports TextInput', () => {
-    render(
+  test('supports TextInput', async () => {
+    await render(
       <View>
         <TextInput testID="default" />
         <TextInput testID="editable" editable />
@@ -442,8 +442,8 @@ describe('computeAriaDisabled', () => {
     expect(computeAriaDisabled(screen.getByTestId('editable-false'))).toBe(true);
   });
 
-  test('supports Button', () => {
-    render(
+  test('supports Button', async () => {
+    await render(
       <View>
         <Pressable testID="default" role="button">
           <Text>Default Button</Text>
@@ -462,8 +462,8 @@ describe('computeAriaDisabled', () => {
     expect(computeAriaDisabled(screen.getByTestId('disabled-false'))).toBe(false);
   });
 
-  test('supports Text', () => {
-    render(
+  test('supports Text', async () => {
+    await render(
       <View>
         <Text>Default Text</Text>
         <Text disabled>Disabled Text</Text>
diff --git a/src/helpers/__tests__/component-tree.test.tsx b/src/helpers/__tests__/component-tree.test.tsx
index 8ec9715b2..18b8d2580 100644
--- a/src/helpers/__tests__/component-tree.test.tsx
+++ b/src/helpers/__tests__/component-tree.test.tsx
@@ -15,8 +15,8 @@ function MultipleHostChildren() {
 }
 
 describe('getHostSiblings()', () => {
-  it('returns host siblings for host component', () => {
-    render(
+  it('returns host siblings for host component', async () => {
+    await render(
       <View testID="grandparent">
         <View testID="parent">
           <View testID="siblingBefore" />
@@ -39,8 +39,8 @@ describe('getHostSiblings()', () => {
 });
 
 describe('getContainerElement()', () => {
-  it('returns container for mounted view', () => {
-    render(
+  it('returns container for mounted view', async () => {
+    await render(
       <View>
         <View testID="view" />
       </View>,
diff --git a/src/helpers/__tests__/format-element.test.tsx b/src/helpers/__tests__/format-element.test.tsx
index b27bde7a6..ffe8eaddc 100644
--- a/src/helpers/__tests__/format-element.test.tsx
+++ b/src/helpers/__tests__/format-element.test.tsx
@@ -4,8 +4,8 @@ import { Text, View } from 'react-native';
 import { render, screen } from '../..';
 import { formatElement } from '../format-element';
 
-test('formatElement', () => {
-  render(
+test('formatElement', async () => {
+  await render(
     <View testID="root">
       <View testID="view" />
       <Text>Hello</Text>
diff --git a/src/helpers/__tests__/include-hidden-elements.test.tsx b/src/helpers/__tests__/include-hidden-elements.test.tsx
index cffa8d234..03c9ddd3a 100644
--- a/src/helpers/__tests__/include-hidden-elements.test.tsx
+++ b/src/helpers/__tests__/include-hidden-elements.test.tsx
@@ -3,36 +3,36 @@ import { View } from 'react-native';
 
 import { configure, render, screen } from '../..';
 
-test('includeHiddenElements query option takes priority over hidden option and global config', () => {
+test('includeHiddenElements query option takes priority over hidden option and global config', async () => {
   configure({ defaultHidden: true, defaultIncludeHiddenElements: true });
-  render(<View testID="view" style={{ display: 'none' }} />);
+  await render(<View testID="view" style={{ display: 'none' }} />);
   expect(screen.queryByTestId('view', { includeHiddenElements: false, hidden: true })).toBeFalsy();
 });
 
-test('hidden option takes priority over global config when includeHiddenElements is not defined', () => {
+test('hidden option takes priority over global config when includeHiddenElements is not defined', async () => {
   configure({ defaultHidden: true, defaultIncludeHiddenElements: true });
-  render(<View testID="view" style={{ display: 'none' }} />);
+  await render(<View testID="view" style={{ display: 'none' }} />);
   expect(screen.queryByTestId('view', { hidden: false })).toBeFalsy();
 });
 
-test('global config defaultIncludeElements option takes priority over defaultHidden when set at the same time', () => {
+test('global config defaultIncludeElements option takes priority over defaultHidden when set at the same time', async () => {
   configure({ defaultHidden: false, defaultIncludeHiddenElements: true });
-  render(<View testID="view" style={{ display: 'none' }} />);
+  await render(<View testID="view" style={{ display: 'none' }} />);
   expect(screen.getByTestId('view')).toBeTruthy();
 });
 
-test('defaultHidden takes priority when it was set last', () => {
+test('defaultHidden takes priority when it was set last', async () => {
   // also simulates the case when defaultIncludeHiddenElements is true by default in the config
   configure({ defaultIncludeHiddenElements: true });
   configure({ defaultHidden: false });
-  render(<View testID="view" style={{ display: 'none' }} />);
+  await render(<View testID="view" style={{ display: 'none' }} />);
   expect(screen.queryByTestId('view')).toBeFalsy();
 });
 
-test('defaultIncludeHiddenElements takes priority when it was set last', () => {
+test('defaultIncludeHiddenElements takes priority when it was set last', async () => {
   // also simulates the case when defaultHidden is true by default in the config
   configure({ defaultHidden: true });
   configure({ defaultIncludeHiddenElements: false });
-  render(<View testID="view" style={{ display: 'none' }} />);
+  await render(<View testID="view" style={{ display: 'none' }} />);
   expect(screen.queryByTestId('view')).toBeFalsy();
 });
diff --git a/src/helpers/__tests__/text-content.test.tsx b/src/helpers/__tests__/text-content.test.tsx
index 42f4d3f1e..0c773f699 100644
--- a/src/helpers/__tests__/text-content.test.tsx
+++ b/src/helpers/__tests__/text-content.test.tsx
@@ -4,8 +4,8 @@ import { Text } from 'react-native';
 import { render, screen } from '../..';
 import { getTextContent } from '../text-content';
 
-test('getTextContent with simple content', () => {
-  render(<Text>Hello world</Text>);
+test('getTextContent with simple content', async () => {
+  await render(<Text>Hello world</Text>);
   expect(getTextContent(screen.root)).toBe('Hello world');
 });
 
@@ -13,8 +13,8 @@ test('getTextContent with null element', () => {
   expect(getTextContent(null)).toBe('');
 });
 
-test('getTextContent with single nested content', () => {
-  render(
+test('getTextContent with single nested content', async () => {
+  await render(
     <Text>
       <Text>Hello world</Text>
     </Text>,
@@ -22,8 +22,8 @@ test('getTextContent with single nested content', () => {
   expect(getTextContent(screen.root)).toBe('Hello world');
 });
 
-test('getTextContent with multiple nested content', () => {
-  render(
+test('getTextContent with multiple nested content', async () => {
+  await render(
     <Text>
       <Text>Hello</Text> <Text>world</Text>
     </Text>,
@@ -31,8 +31,8 @@ test('getTextContent with multiple nested content', () => {
   expect(getTextContent(screen.root)).toBe('Hello world');
 });
 
-test('getTextContent with multiple number content', () => {
-  render(
+test('getTextContent with multiple number content', async () => {
+  await render(
     <Text>
       <Text>Hello</Text> <Text>world</Text> <Text>{100}</Text>
     </Text>,
@@ -40,8 +40,8 @@ test('getTextContent with multiple number content', () => {
   expect(getTextContent(screen.root)).toBe('Hello world 100');
 });
 
-test('getTextContent with multiple boolean content', () => {
-  render(
+test('getTextContent with multiple boolean content', async () => {
+  await render(
     <Text>
       <Text>Hello{false}</Text> <Text>{true}world</Text>
     </Text>,
diff --git a/src/helpers/__tests__/text-input.test.tsx b/src/helpers/__tests__/text-input.test.tsx
index 60534dbb8..b3a6f72cf 100644
--- a/src/helpers/__tests__/text-input.test.tsx
+++ b/src/helpers/__tests__/text-input.test.tsx
@@ -4,8 +4,8 @@ import { TextInput, View } from 'react-native';
 import { render, screen } from '../..';
 import { getTextInputValue, isEditableTextInput } from '../text-input';
 
-test('getTextInputValue basic test', () => {
-  render(
+test('getTextInputValue basic test', async () => {
+  await render(
     <View>
       <TextInput testID="value" value="text-a" />
       <TextInput testID="default-value" defaultValue="text-b" />
@@ -22,8 +22,8 @@ test('getTextInputValue basic test', () => {
   );
 });
 
-test('isEditableTextInput basic test', () => {
-  render(
+test('isEditableTextInput basic test', async () => {
+  await render(
     <View>
       <TextInput testID="default" />
       <TextInput testID="editable" editable={true} />
diff --git a/src/helpers/host-component-names.ts b/src/helpers/host-component-names.ts
index 7eea2e9c5..39dc31925 100644
--- a/src/helpers/host-component-names.ts
+++ b/src/helpers/host-component-names.ts
@@ -1,6 +1,6 @@
 import type { HostElement } from 'universal-test-renderer';
 
-const HOST_TEXT_NAMES = ['Text', 'RCTText'];
+export const HOST_TEXT_NAMES = ['Text', 'RCTText'];
 const HOST_TEXT_INPUT_NAMES = ['TextInput'];
 const HOST_IMAGE_NAMES = ['Image'];
 const HOST_SWITCH_NAMES = ['RCTSwitch'];
diff --git a/src/index.ts b/src/index.ts
index 6a2e4ec4e..01a8f8ee9 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -2,7 +2,7 @@ import './matchers/extend-expect';
 
 import { getIsReactActEnvironment, setReactActEnvironment } from './act';
 import { flushMicroTasks } from './flush-micro-tasks';
-import { cleanupAsync } from './pure';
+import { cleanup } from './pure';
 
 if (!process?.env?.RNTL_SKIP_AUTO_CLEANUP) {
   // If we're running in a test runner that supports afterEach
@@ -13,7 +13,7 @@ if (!process?.env?.RNTL_SKIP_AUTO_CLEANUP) {
   if (typeof afterEach === 'function') {
     afterEach(async () => {
       await flushMicroTasks();
-      await cleanupAsync();
+      await cleanup();
     });
   }
 
diff --git a/src/matchers/__tests__/to-be-busy.test.tsx b/src/matchers/__tests__/to-be-busy.test.tsx
index e6684c242..cdd00bc7d 100644
--- a/src/matchers/__tests__/to-be-busy.test.tsx
+++ b/src/matchers/__tests__/to-be-busy.test.tsx
@@ -3,8 +3,8 @@ import { View } from 'react-native';
 
 import { render, screen } from '../..';
 
-test('toBeBusy() basic case', () => {
-  render(
+test('toBeBusy() basic case', async () => {
+  await render(
     <>
       <View testID="busy" accessibilityState={{ busy: true }} />
       <View testID="busy-aria" aria-busy />
@@ -21,8 +21,8 @@ test('toBeBusy() basic case', () => {
   expect(screen.getByTestId('default')).not.toBeBusy();
 });
 
-test('toBeBusy() error messages', () => {
-  render(
+test('toBeBusy() error messages', async () => {
+  await render(
     <>
       <View testID="busy" accessibilityState={{ busy: true }} />
       <View testID="busy-aria" aria-busy />
diff --git a/src/matchers/__tests__/to-be-checked.test.tsx b/src/matchers/__tests__/to-be-checked.test.tsx
index 2b0b3f22a..4020fa450 100644
--- a/src/matchers/__tests__/to-be-checked.test.tsx
+++ b/src/matchers/__tests__/to-be-checked.test.tsx
@@ -3,8 +3,8 @@ import { type AccessibilityRole, Switch, View } from 'react-native';
 
 import { render, screen } from '../..';
 
-function renderViewsWithRole(role: AccessibilityRole) {
-  render(
+async function renderViewsWithRole(role: AccessibilityRole) {
+  await render(
     <>
       <View
         testID={`${role}-checked`}
@@ -29,8 +29,8 @@ function renderViewsWithRole(role: AccessibilityRole) {
   );
 }
 
-test('toBeCheck() with Switch', () => {
-  render(
+test('toBeCheck() with Switch', async () => {
+  await render(
     <>
       <Switch testID="checked" value={true} />
       <Switch testID="unchecked" value={false} />
@@ -78,8 +78,8 @@ test('toBeCheck() with Switch', () => {
   `);
 });
 
-test('toBeCheck() with "checkbox" role', () => {
-  renderViewsWithRole('checkbox');
+test('toBeCheck() with "checkbox" role', async () => {
+  await renderViewsWithRole('checkbox');
 
   const checked = screen.getByTestId('checkbox-checked');
   const unchecked = screen.getByTestId('checkbox-unchecked');
@@ -148,8 +148,8 @@ test('toBeCheck() with "checkbox" role', () => {
   `);
 });
 
-test('toBeCheck() with "radio" role', () => {
-  renderViewsWithRole('radio');
+test('toBeCheck() with "radio" role', async () => {
+  await renderViewsWithRole('radio');
 
   const checked = screen.getByTestId('radio-checked');
   const unchecked = screen.getByTestId('radio-unchecked');
@@ -201,8 +201,8 @@ test('toBeCheck() with "radio" role', () => {
   `);
 });
 
-test('toBeCheck() with "switch" role', () => {
-  renderViewsWithRole('switch');
+test('toBeCheck() with "switch" role', async () => {
+  await renderViewsWithRole('switch');
 
   const checked = screen.getByTestId('switch-checked');
   const unchecked = screen.getByTestId('switch-unchecked');
@@ -254,8 +254,8 @@ test('toBeCheck() with "switch" role', () => {
   `);
 });
 
-test('throws error for invalid role', () => {
-  renderViewsWithRole('adjustable');
+test('throws error for invalid role', async () => {
+  await renderViewsWithRole('adjustable');
 
   const checked = screen.getByTestId('adjustable-checked');
   const unchecked = screen.getByTestId('adjustable-unchecked');
@@ -268,8 +268,8 @@ test('throws error for invalid role', () => {
   );
 });
 
-test('throws error for non-accessibility element', () => {
-  render(<View testID="test" />);
+test('throws error for non-accessibility element', async () => {
+  await render(<View testID="test" />);
 
   const view = screen.getByTestId('test');
   expect(() => expect(view).toBeChecked()).toThrowErrorMatchingInlineSnapshot(
diff --git a/src/matchers/__tests__/to-be-disabled.test.tsx b/src/matchers/__tests__/to-be-disabled.test.tsx
index 9a3a6dedf..da7916665 100644
--- a/src/matchers/__tests__/to-be-disabled.test.tsx
+++ b/src/matchers/__tests__/to-be-disabled.test.tsx
@@ -13,8 +13,8 @@ import {
 
 import { render, screen } from '../..';
 
-test('toBeDisabled()/toBeEnabled() supports basic case', () => {
-  render(
+test('toBeDisabled()/toBeEnabled() supports basic case', async () => {
+  await render(
     <View>
       <View testID="disabled-parent" aria-disabled>
         <View>
@@ -87,8 +87,8 @@ test('toBeDisabled()/toBeEnabled() supports basic case', () => {
   `);
 });
 
-test('toBeDisabled()/toBeEnabled() supports Pressable with "disabled" prop', () => {
-  render(
+test('toBeDisabled()/toBeEnabled() supports Pressable with "disabled" prop', async () => {
+  await render(
     <Pressable disabled testID="subject">
       <Text>Button</Text>
     </Pressable>,
@@ -157,28 +157,31 @@ test.each([
   ['TouchableHighlight', TouchableHighlight],
   ['TouchableWithoutFeedback', TouchableWithoutFeedback],
   ['TouchableNativeFeedback', TouchableNativeFeedback],
-] as const)('toBeDisabled()/toBeEnabled() supports %s with "disabled" prop', (_, Component) => {
-  render(
-    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-    // @ts-ignore - JSX element type 'Component' does not have any construct or call signatures.
-    <Component disabled testID="subject">
-      <Text>Button</Text>
-    </Component>,
-  );
+] as const)(
+  'toBeDisabled()/toBeEnabled() supports %s with "disabled" prop',
+  async (_, Component) => {
+    await render(
+      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+      // @ts-ignore - JSX element type 'Component' does not have any construct or call signatures.
+      <Component disabled testID="subject">
+        <Text>Button</Text>
+      </Component>,
+    );
 
-  const touchable = screen.getByTestId('subject');
-  expect(touchable).toBeDisabled();
-  expect(touchable).not.toBeEnabled();
+    const touchable = screen.getByTestId('subject');
+    expect(touchable).toBeDisabled();
+    expect(touchable).not.toBeEnabled();
 
-  const title = screen.getByText('Button');
-  expect(title).toBeDisabled();
-  expect(title).not.toBeEnabled();
+    const title = screen.getByText('Button');
+    expect(title).toBeDisabled();
+    expect(title).not.toBeEnabled();
 
-  expect(() => expect(touchable).toBeEnabled()).toThrow();
-  expect(() => expect(touchable).not.toBeDisabled()).toThrow();
-  expect(() => expect(title).toBeEnabled()).toThrow();
-  expect(() => expect(title).not.toBeDisabled()).toThrow();
-});
+    expect(() => expect(touchable).toBeEnabled()).toThrow();
+    expect(() => expect(touchable).not.toBeDisabled()).toThrow();
+    expect(() => expect(title).toBeEnabled()).toThrow();
+    expect(() => expect(title).not.toBeDisabled()).toThrow();
+  },
+);
 
 test.each([
   ['View', View],
@@ -190,8 +193,8 @@ test.each([
   ['TouchableNativeFeedback', TouchableNativeFeedback],
 ] as const)(
   'toBeDisabled()/toBeEnabled() supports %s with "aria-disabled" prop',
-  (_, Component) => {
-    render(
+  async (_, Component) => {
+    await render(
       // eslint-disable-next-line @typescript-eslint/ban-ts-comment
       // @ts-ignore - JSX element type 'Component' does not have any construct or call signatures.
       <Component testID="subject" aria-disabled>
@@ -218,8 +221,8 @@ test.each([
   ['TouchableNativeFeedback', TouchableNativeFeedback],
 ] as const)(
   'toBeDisabled()/toBeEnabled() supports %s with "accessibilityState.disabled" prop',
-  (_, Component) => {
-    render(
+  async (_, Component) => {
+    await render(
       // eslint-disable-next-line @typescript-eslint/ban-ts-comment
       // @ts-ignore - JSX element type 'Component' does not have any construct or call signatures.
       <Component testID="subject" accessibilityState={{ disabled: true }}>
@@ -235,8 +238,8 @@ test.each([
   },
 );
 
-test('toBeDisabled()/toBeEnabled() supports "editable" prop on TextInput', () => {
-  render(
+test('toBeDisabled()/toBeEnabled() supports "editable" prop on TextInput', async () => {
+  await render(
     <View>
       <TextInput testID="enabled-by-default" />
       <TextInput testID="enabled" editable />
@@ -253,8 +256,8 @@ test('toBeDisabled()/toBeEnabled() supports "editable" prop on TextInput', () =>
   expect(screen.getByTestId('disabled')).not.toBeEnabled();
 });
 
-test('toBeDisabled()/toBeEnabled() supports "disabled" prop on Button', () => {
-  render(
+test('toBeDisabled()/toBeEnabled() supports "disabled" prop on Button', async () => {
+  await render(
     <View>
       <Button testID="enabled" title="enabled" />
       <Button testID="disabled" title="disabled" disabled />
diff --git a/src/matchers/__tests__/to-be-empty-element.test.tsx b/src/matchers/__tests__/to-be-empty-element.test.tsx
index f38047db3..66942ab04 100644
--- a/src/matchers/__tests__/to-be-empty-element.test.tsx
+++ b/src/matchers/__tests__/to-be-empty-element.test.tsx
@@ -9,8 +9,8 @@ function DoNotRenderChildren({ children }: { children: React.ReactNode }) {
   return null;
 }
 
-test('toBeEmptyElement() base case', () => {
-  render(
+test('toBeEmptyElement() base case', async () => {
+  await render(
     <View testID="not-empty">
       <View testID="empty" />
     </View>,
@@ -37,8 +37,8 @@ test('toBeEmptyElement() base case', () => {
   `);
 });
 
-test('toBeEmptyElement() ignores composite-only children', () => {
-  render(
+test('toBeEmptyElement() ignores composite-only children', async () => {
+  await render(
     <View testID="view">
       <DoNotRenderChildren>
         <View testID="not-rendered" />
diff --git a/src/matchers/__tests__/to-be-expanded.test.tsx b/src/matchers/__tests__/to-be-expanded.test.tsx
index 489068e94..e24c77d5c 100644
--- a/src/matchers/__tests__/to-be-expanded.test.tsx
+++ b/src/matchers/__tests__/to-be-expanded.test.tsx
@@ -3,8 +3,8 @@ import { View } from 'react-native';
 
 import { render, screen } from '../..';
 
-test('toBeExpanded() basic case', () => {
-  render(
+test('toBeExpanded() basic case', async () => {
+  await render(
     <>
       <View testID="expanded" accessibilityState={{ expanded: true }} />
       <View testID="expanded-aria" aria-expanded />
@@ -21,8 +21,8 @@ test('toBeExpanded() basic case', () => {
   expect(screen.getByTestId('default')).not.toBeExpanded();
 });
 
-test('toBeExpanded() error messages', () => {
-  render(
+test('toBeExpanded() error messages', async () => {
+  await render(
     <>
       <View testID="expanded" accessibilityState={{ expanded: true }} />
       <View testID="expanded-aria" aria-expanded />
@@ -95,8 +95,8 @@ test('toBeExpanded() error messages', () => {
   `);
 });
 
-test('toBeCollapsed() basic case', () => {
-  render(
+test('toBeCollapsed() basic case', async () => {
+  await render(
     <>
       <View testID="expanded" accessibilityState={{ expanded: true }} />
       <View testID="expanded-aria" aria-expanded />
@@ -113,8 +113,8 @@ test('toBeCollapsed() basic case', () => {
   expect(screen.getByTestId('default')).not.toBeCollapsed();
 });
 
-test('toBeCollapsed() error messages', () => {
-  render(
+test('toBeCollapsed() error messages', async () => {
+  await render(
     <>
       <View testID="expanded" accessibilityState={{ expanded: true }} />
       <View testID="expanded-aria" aria-expanded />
diff --git a/src/matchers/__tests__/to-be-on-the-screen.test.tsx b/src/matchers/__tests__/to-be-on-the-screen.test.tsx
index d5a9512c7..cc125c77e 100644
--- a/src/matchers/__tests__/to-be-on-the-screen.test.tsx
+++ b/src/matchers/__tests__/to-be-on-the-screen.test.tsx
@@ -3,8 +3,8 @@ import { Text, View } from 'react-native';
 
 import { render, screen } from '../..';
 
-test('toBeOnTheScreen() example test', () => {
-  render(
+test('toBeOnTheScreen() example test', async () => {
+  await render(
     <View>
       <View testID="child" />
     </View>,
@@ -13,12 +13,12 @@ test('toBeOnTheScreen() example test', () => {
   const child = screen.getByTestId('child');
   expect(child).toBeOnTheScreen();
 
-  screen.update(<View />);
+  await screen.update(<View />);
   expect(child).not.toBeOnTheScreen();
 });
 
-test('toBeOnTheScreen() on attached element', () => {
-  render(<View testID="test" />);
+test('toBeOnTheScreen() on attached element', async () => {
+  await render(<View testID="test" />);
 
   const element = screen.getByTestId('test');
   expect(element).toBeOnTheScreen();
@@ -42,12 +42,12 @@ function ShowChildren({ show }: { show: boolean }) {
   );
 }
 
-test('toBeOnTheScreen() on detached element', () => {
-  render(<ShowChildren show={true} />);
+test('toBeOnTheScreen() on detached element', async () => {
+  await render(<ShowChildren show={true} />);
 
   const element = screen.getByTestId('text');
   // Next line will unmount the element, yet `element` variable will still hold reference to it.
-  screen.update(<ShowChildren show={false} />);
+  await screen.update(<ShowChildren show={false} />);
 
   expect(element).toBeTruthy();
   expect(element).not.toBeOnTheScreen();
diff --git a/src/matchers/__tests__/to-be-partially-checked.test.tsx b/src/matchers/__tests__/to-be-partially-checked.test.tsx
index 688bfb6ce..edb527094 100644
--- a/src/matchers/__tests__/to-be-partially-checked.test.tsx
+++ b/src/matchers/__tests__/to-be-partially-checked.test.tsx
@@ -29,8 +29,8 @@ function renderViewsWithRole(role: AccessibilityRole) {
   );
 }
 
-test('toBePartiallyCheck() with checkbox role', () => {
-  renderViewsWithRole('checkbox');
+test('toBePartiallyCheck() with checkbox role', async () => {
+  await renderViewsWithRole('checkbox');
 
   const checked = screen.getByTestId('checkbox-checked');
   const unchecked = screen.getByTestId('checkbox-unchecked');
@@ -86,8 +86,8 @@ test('toBePartiallyCheck() with checkbox role', () => {
   `);
 });
 
-test('toBeCheck() with radio role', () => {
-  renderViewsWithRole('radio');
+test('toBeCheck() with radio role', async () => {
+  await renderViewsWithRole('radio');
 
   const checked = screen.getByTestId('radio-checked');
   const mixed = screen.getByTestId('radio-mixed');
diff --git a/src/matchers/__tests__/to-be-selected.test.tsx b/src/matchers/__tests__/to-be-selected.test.tsx
index 3660bdf3a..107dc8f7a 100644
--- a/src/matchers/__tests__/to-be-selected.test.tsx
+++ b/src/matchers/__tests__/to-be-selected.test.tsx
@@ -3,8 +3,8 @@ import { View } from 'react-native';
 
 import { render, screen } from '../..';
 
-test('toBeSelected() basic case', () => {
-  render(
+test('toBeSelected() basic case', async () => {
+  await render(
     <>
       <View testID="selected" accessibilityState={{ selected: true }} />
       <View testID="selected-aria" aria-selected />
@@ -21,8 +21,8 @@ test('toBeSelected() basic case', () => {
   expect(screen.getByTestId('default')).not.toBeSelected();
 });
 
-test('toBeSelected() error messages', () => {
-  render(
+test('toBeSelected() error messages', async () => {
+  await render(
     <>
       <View testID="selected" accessibilityState={{ selected: true }} />
       <View testID="selected-aria" aria-selected />
diff --git a/src/matchers/__tests__/to-be-visible.test.tsx b/src/matchers/__tests__/to-be-visible.test.tsx
index be4f82da6..fc39e855f 100644
--- a/src/matchers/__tests__/to-be-visible.test.tsx
+++ b/src/matchers/__tests__/to-be-visible.test.tsx
@@ -3,8 +3,8 @@ import { Modal, View } from 'react-native';
 
 import { render, screen } from '../..';
 
-test('toBeVisible() on empty view', () => {
-  render(<View testID="view" />);
+test('toBeVisible() on empty view', async () => {
+  await render(<View testID="view" />);
 
   const view = screen.getByTestId('view');
   expect(view).toBeVisible();
@@ -18,8 +18,8 @@ test('toBeVisible() on empty view', () => {
   `);
 });
 
-test('toBeVisible() on view with opacity', () => {
-  render(<View testID="view" style={{ opacity: 0.2 }} />);
+test('toBeVisible() on view with opacity', async () => {
+  await render(<View testID="view" style={{ opacity: 0.2 }} />);
 
   const view = screen.getByTestId('view');
   expect(view).toBeVisible();
@@ -33,8 +33,8 @@ test('toBeVisible() on view with opacity', () => {
   `);
 });
 
-test('toBeVisible() on view with 0 opacity', () => {
-  render(<View testID="view" style={{ opacity: 0 }} />);
+test('toBeVisible() on view with 0 opacity', async () => {
+  await render(<View testID="view" style={{ opacity: 0 }} />);
 
   const view = screen.getByTestId('view');
   expect(view).not.toBeVisible();
@@ -53,8 +53,8 @@ test('toBeVisible() on view with 0 opacity', () => {
   `);
 });
 
-test('toBeVisible() on view with display "none"', () => {
-  render(<View testID="view" style={{ display: 'none' }} />);
+test('toBeVisible() on view with display "none"', async () => {
+  await render(<View testID="view" style={{ display: 'none' }} />);
 
   const view = screen.getByTestId('view', { includeHiddenElements: true });
   expect(view).not.toBeVisible();
@@ -73,8 +73,8 @@ test('toBeVisible() on view with display "none"', () => {
   `);
 });
 
-test('toBeVisible() on ancestor view with 0 opacity', () => {
-  render(
+test('toBeVisible() on ancestor view with 0 opacity', async () => {
+  await render(
     <View style={{ opacity: 0 }}>
       <View>
         <View testID="view" />
@@ -94,8 +94,8 @@ test('toBeVisible() on ancestor view with 0 opacity', () => {
   `);
 });
 
-test('toBeVisible() on ancestor view with display "none"', () => {
-  render(
+test('toBeVisible() on ancestor view with display "none"', async () => {
+  await render(
     <View style={{ display: 'none' }}>
       <View>
         <View testID="view" />
@@ -115,8 +115,8 @@ test('toBeVisible() on ancestor view with display "none"', () => {
   `);
 });
 
-test('toBeVisible() on empty Modal', () => {
-  render(<Modal testID="modal" />);
+test('toBeVisible() on empty Modal', async () => {
+  await render(<Modal testID="modal" />);
 
   const modal = screen.getByTestId('modal');
   expect(modal).toBeVisible();
@@ -130,8 +130,8 @@ test('toBeVisible() on empty Modal', () => {
   `);
 });
 
-test('toBeVisible() on view within Modal', () => {
-  render(
+test('toBeVisible() on view within Modal', async () => {
+  await render(
     <Modal visible>
       <View>
         <View testID="view-within-modal" />
@@ -141,8 +141,8 @@ test('toBeVisible() on view within Modal', () => {
   expect(screen.getByTestId('view-within-modal')).toBeVisible();
 });
 
-test('toBeVisible() on not visible Modal', () => {
-  render(
+test('toBeVisible() on not visible Modal', async () => {
+  await render(
     <Modal testID="modal" visible={false}>
       <View>
         <View testID="view-within-modal" />
@@ -163,18 +163,18 @@ test('toBeVisible() on not visible Modal', () => {
   `);
 });
 
-test('toBeVisible() on inaccessible view', () => {
-  render(<View testID="test" aria-hidden />);
+test('toBeVisible() on inaccessible view', async () => {
+  await render(<View testID="test" aria-hidden />);
 
   const test = screen.getByTestId('test', { includeHiddenElements: true });
   expect(test).not.toBeVisible();
 
-  screen.update(<View testID="test" />);
+  await screen.update(<View testID="test" />);
   expect(test).toBeVisible();
 });
 
-test('toBeVisible() on view within inaccessible view', () => {
-  render(
+test('toBeVisible() on view within inaccessible view', async () => {
+  await render(
     <View aria-hidden>
       <View>
         <View testID="test" />
@@ -184,18 +184,18 @@ test('toBeVisible() on view within inaccessible view', () => {
   expect(screen.getByTestId('test', { includeHiddenElements: true })).not.toBeVisible();
 });
 
-test('toBeVisible() on inaccessible view (iOS)', () => {
-  render(<View testID="test" accessibilityElementsHidden />);
+test('toBeVisible() on inaccessible view (iOS)', async () => {
+  await render(<View testID="test" accessibilityElementsHidden />);
 
   const test = screen.getByTestId('test', { includeHiddenElements: true });
   expect(test).not.toBeVisible();
 
-  screen.update(<View testID="test" accessibilityElementsHidden={false} />);
+  await screen.update(<View testID="test" accessibilityElementsHidden={false} />);
   expect(test).toBeVisible();
 });
 
-test('toBeVisible() on view within inaccessible view (iOS)', () => {
-  render(
+test('toBeVisible() on view within inaccessible view (iOS)', async () => {
+  await render(
     <View accessibilityElementsHidden>
       <View>
         <View testID="test" />
@@ -205,18 +205,18 @@ test('toBeVisible() on view within inaccessible view (iOS)', () => {
   expect(screen.getByTestId('test', { includeHiddenElements: true })).not.toBeVisible();
 });
 
-test('toBeVisible() on inaccessible view (Android)', () => {
-  render(<View testID="test" importantForAccessibility="no-hide-descendants" />);
+test('toBeVisible() on inaccessible view (Android)', async () => {
+  await render(<View testID="test" importantForAccessibility="no-hide-descendants" />);
 
   const test = screen.getByTestId('test', { includeHiddenElements: true });
   expect(test).not.toBeVisible();
 
-  screen.update(<View testID="test" importantForAccessibility="auto" />);
+  await screen.update(<View testID="test" importantForAccessibility="auto" />);
   expect(test).toBeVisible();
 });
 
-test('toBeVisible() on view within inaccessible view (Android)', () => {
-  render(
+test('toBeVisible() on view within inaccessible view (Android)', async () => {
+  await render(
     <View importantForAccessibility="no-hide-descendants">
       <View>
         <View testID="test" />
@@ -255,10 +255,10 @@ test('toBeVisible() on non-React elements', () => {
     `);
 });
 
-test('toBeVisible() does not throw on invalid style', () => {
+test('toBeVisible() does not throw on invalid style', async () => {
   // @ts-expect-error: intentionally passing invalid style to
   // trigger StyleSheet.flatten() returning undefined.
-  render(<View testID="view" style={0} />);
+  await render(<View testID="view" style={0} />);
 
   const view = screen.getByTestId('view');
   expect(view).toBeVisible();
diff --git a/src/matchers/__tests__/to-contain-element.test.tsx b/src/matchers/__tests__/to-contain-element.test.tsx
index 9b6aa5a25..d041b8523 100644
--- a/src/matchers/__tests__/to-contain-element.test.tsx
+++ b/src/matchers/__tests__/to-contain-element.test.tsx
@@ -3,8 +3,8 @@ import { View } from 'react-native';
 
 import { render, screen } from '../..';
 
-test('toContainElement() supports basic case', () => {
-  render(
+test('toContainElement() supports basic case', async () => {
+  await render(
     <View testID="parent">
       <View testID="child" />
     </View>,
@@ -31,8 +31,8 @@ test('toContainElement() supports basic case', () => {
   `);
 });
 
-test('toContainElement() supports negative case', () => {
-  render(
+test('toContainElement() supports negative case', async () => {
+  await render(
     <>
       <View testID="view1" />
       <View testID="view2" />
@@ -61,8 +61,8 @@ test('toContainElement() supports negative case', () => {
   `);
 });
 
-test('toContainElement() handles null container', () => {
-  render(<View testID="view" />);
+test('toContainElement() handles null container', async () => {
+  await render(<View testID="view" />);
 
   const view = screen.getByTestId('view');
 
@@ -74,8 +74,8 @@ test('toContainElement() handles null container', () => {
   `);
 });
 
-test('toContainElement() handles null element', () => {
-  render(<View testID="view" />);
+test('toContainElement() handles null element', async () => {
+  await render(<View testID="view" />);
 
   const view = screen.getByTestId('view');
 
@@ -95,8 +95,8 @@ test('toContainElement() handles null element', () => {
   `);
 });
 
-test('toContainElement() handles non-element container', () => {
-  render(<View testID="view" />);
+test('toContainElement() handles non-element container', async () => {
+  await render(<View testID="view" />);
 
   const view = screen.getByTestId('view');
 
@@ -118,8 +118,8 @@ test('toContainElement() handles non-element container', () => {
     `);
 });
 
-test('toContainElement() handles non-element element', () => {
-  render(<View testID="view" />);
+test('toContainElement() handles non-element element', async () => {
+  await render(<View testID="view" />);
 
   const view = screen.getByTestId('view');
 
diff --git a/src/matchers/__tests__/to-have-accessibility-value.test.tsx b/src/matchers/__tests__/to-have-accessibility-value.test.tsx
index f700f2ada..5dab7cb9c 100644
--- a/src/matchers/__tests__/to-have-accessibility-value.test.tsx
+++ b/src/matchers/__tests__/to-have-accessibility-value.test.tsx
@@ -4,60 +4,60 @@ import { View } from 'react-native';
 import { render, screen } from '../..';
 
 describe('toHaveAccessibilityValue', () => {
-  it('supports "accessibilityValue.min"', () => {
-    render(<View accessibilityValue={{ min: 0 }} />);
+  it('supports "accessibilityValue.min"', async () => {
+    await render(<View accessibilityValue={{ min: 0 }} />);
     expect(screen.root).toHaveAccessibilityValue({ min: 0 });
     expect(screen.root).not.toHaveAccessibilityValue({ min: 1 });
   });
 
-  it('supports "accessibilityValue.max"', () => {
-    render(<View accessibilityValue={{ max: 100 }} />);
+  it('supports "accessibilityValue.max"', async () => {
+    await render(<View accessibilityValue={{ max: 100 }} />);
     expect(screen.root).toHaveAccessibilityValue({ max: 100 });
     expect(screen.root).not.toHaveAccessibilityValue({ max: 99 });
   });
 
-  it('supports "accessibilityValue.now"', () => {
-    render(<View accessibilityValue={{ now: 33 }} />);
+  it('supports "accessibilityValue.now"', async () => {
+    await render(<View accessibilityValue={{ now: 33 }} />);
     expect(screen.root).toHaveAccessibilityValue({ now: 33 });
     expect(screen.root).not.toHaveAccessibilityValue({ now: 34 });
   });
 
-  it('supports "accessibilityValue.text"', () => {
-    render(<View testID="view" accessibilityValue={{ text: 'Hello' }} />);
+  it('supports "accessibilityValue.text"', async () => {
+    await render(<View testID="view" accessibilityValue={{ text: 'Hello' }} />);
     expect(screen.root).toHaveAccessibilityValue({ text: 'Hello' });
     expect(screen.root).toHaveAccessibilityValue({ text: /He/ });
     expect(screen.root).not.toHaveAccessibilityValue({ text: 'Hi' });
     expect(screen.root).not.toHaveAccessibilityValue({ text: /Hi/ });
   });
 
-  it('supports "aria-valuemin"', () => {
-    render(<View testID="view" aria-valuemin={0} />);
+  it('supports "aria-valuemin"', async () => {
+    await render(<View testID="view" aria-valuemin={0} />);
     expect(screen.root).toHaveAccessibilityValue({ min: 0 });
     expect(screen.root).not.toHaveAccessibilityValue({ min: 1 });
   });
 
-  it('supports "aria-valuemax"', () => {
-    render(<View testID="view" aria-valuemax={100} />);
+  it('supports "aria-valuemax"', async () => {
+    await render(<View testID="view" aria-valuemax={100} />);
     expect(screen.root).toHaveAccessibilityValue({ max: 100 });
     expect(screen.root).not.toHaveAccessibilityValue({ max: 99 });
   });
 
-  it('supports "aria-valuenow"', () => {
-    render(<View testID="view" aria-valuenow={33} />);
+  it('supports "aria-valuenow"', async () => {
+    await render(<View testID="view" aria-valuenow={33} />);
     expect(screen.root).toHaveAccessibilityValue({ now: 33 });
     expect(screen.root).not.toHaveAccessibilityValue({ now: 34 });
   });
 
-  it('supports "aria-valuetext"', () => {
-    render(<View testID="view" aria-valuetext="Hello" />);
+  it('supports "aria-valuetext"', async () => {
+    await render(<View testID="view" aria-valuetext="Hello" />);
     expect(screen.root).toHaveAccessibilityValue({ text: 'Hello' });
     expect(screen.root).toHaveAccessibilityValue({ text: /He/ });
     expect(screen.root).not.toHaveAccessibilityValue({ text: 'Hi' });
     expect(screen.root).not.toHaveAccessibilityValue({ text: /Hi/ });
   });
 
-  it('supports multi-argument matching', () => {
-    render(<View accessibilityValue={{ min: 1, max: 10, now: 5, text: '5/10' }} />);
+  it('supports multi-argument matching', async () => {
+    await render(<View accessibilityValue={{ min: 1, max: 10, now: 5, text: '5/10' }} />);
 
     expect(screen.root).toHaveAccessibilityValue({ now: 5 });
     expect(screen.root).toHaveAccessibilityValue({ now: 5, min: 1 });
@@ -83,8 +83,8 @@ describe('toHaveAccessibilityValue', () => {
     });
   });
 
-  it('gives precedence to ARIA values', () => {
-    render(
+  it('gives precedence to ARIA values', async () => {
+    await render(
       <View
         testID="view"
         aria-valuemin={0}
@@ -106,8 +106,8 @@ describe('toHaveAccessibilityValue', () => {
     expect(screen.root).not.toHaveAccessibilityValue({ text: 'Hi' });
   });
 
-  it('shows errors in expected format', () => {
-    render(
+  it('shows errors in expected format', async () => {
+    await render(
       <View
         testID="view"
         aria-valuemin={0}
@@ -138,8 +138,8 @@ describe('toHaveAccessibilityValue', () => {
     `);
   });
 
-  it('shows errors in expected format with partial value', () => {
-    render(<View testID="view" aria-valuenow={33} aria-valuetext="Hello" />);
+  it('shows errors in expected format with partial value', async () => {
+    await render(<View testID="view" aria-valuenow={33} aria-valuetext="Hello" />);
 
     expect(() => expect(screen.root).toHaveAccessibilityValue({ min: 30 }))
       .toThrowErrorMatchingInlineSnapshot(`
diff --git a/src/matchers/__tests__/to-have-accessible-name.test.tsx b/src/matchers/__tests__/to-have-accessible-name.test.tsx
index 1f433d857..406a8074c 100644
--- a/src/matchers/__tests__/to-have-accessible-name.test.tsx
+++ b/src/matchers/__tests__/to-have-accessible-name.test.tsx
@@ -3,22 +3,22 @@ import { Image, Text, TextInput, View } from 'react-native';
 
 import { render, screen } from '../..';
 
-test('toHaveAccessibleName() handles view with "accessibilityLabel" prop', () => {
-  render(<View testID="view" accessibilityLabel="Test label" />);
+test('toHaveAccessibleName() handles view with "accessibilityLabel" prop', async () => {
+  await render(<View testID="view" accessibilityLabel="Test label" />);
   const element = screen.getByTestId('view');
   expect(element).toHaveAccessibleName('Test label');
   expect(element).not.toHaveAccessibleName('Other label');
 });
 
-test('toHaveAccessibleName() handles view with "aria-label" prop', () => {
-  render(<View testID="view" aria-label="Test label" />);
+test('toHaveAccessibleName() handles view with "aria-label" prop', async () => {
+  await render(<View testID="view" aria-label="Test label" />);
   const element = screen.getByTestId('view');
   expect(element).toHaveAccessibleName('Test label');
   expect(element).not.toHaveAccessibleName('Other label');
 });
 
-test('toHaveAccessibleName() handles view with "accessibilityLabelledBy" prop', () => {
-  render(
+test('toHaveAccessibleName() handles view with "accessibilityLabelledBy" prop', async () => {
+  await render(
     <View>
       <Text nativeID="label">External label</Text>
       <TextInput testID="input" accessibilityLabelledBy="label" />
@@ -30,8 +30,8 @@ test('toHaveAccessibleName() handles view with "accessibilityLabelledBy" prop',
   expect(element).not.toHaveAccessibleName('Other label');
 });
 
-test('toHaveAccessibleName() handles nested "accessibilityLabelledBy"', () => {
-  render(
+test('toHaveAccessibleName() handles nested "accessibilityLabelledBy"', async () => {
+  await render(
     <>
       <View nativeID="label">
         <Text>External label</Text>
@@ -45,8 +45,8 @@ test('toHaveAccessibleName() handles nested "accessibilityLabelledBy"', () => {
   expect(element).not.toHaveAccessibleName('Other label');
 });
 
-test('toHaveAccessibleName() handles view with nested "accessibilityLabelledBy" with no text', () => {
-  render(
+test('toHaveAccessibleName() handles view with nested "accessibilityLabelledBy" with no text', async () => {
+  await render(
     <>
       <View nativeID="label">
         <View />
@@ -59,8 +59,8 @@ test('toHaveAccessibleName() handles view with nested "accessibilityLabelledBy"
   expect(element).not.toHaveAccessibleName();
 });
 
-test('toHaveAccessibleName() handles view with "aria-labelledby" prop', () => {
-  render(
+test('toHaveAccessibleName() handles view with "aria-labelledby" prop', async () => {
+  await render(
     <View>
       <Text nativeID="label">External label</Text>
       <TextInput testID="input" aria-labelledby="label" />
@@ -72,24 +72,24 @@ test('toHaveAccessibleName() handles view with "aria-labelledby" prop', () => {
   expect(element).not.toHaveAccessibleName('Other label');
 });
 
-test('toHaveAccessibleName() handles Text with text content', () => {
-  render(<Text testID="view">Text</Text>);
+test('toHaveAccessibleName() handles Text with text content', async () => {
+  await render(<Text testID="view">Text</Text>);
 
   const element = screen.getByTestId('view');
   expect(element).toHaveAccessibleName('Text');
   expect(element).not.toHaveAccessibleName('Other text');
 });
 
-test('toHaveAccessibleName() handles Image with "alt" prop', () => {
-  render(<Image testID="image" alt="Test image" />);
+test('toHaveAccessibleName() handles Image with "alt" prop', async () => {
+  await render(<Image testID="image" alt="Test image" />);
 
   const element = screen.getByTestId('image');
   expect(element).toHaveAccessibleName('Test image');
   expect(element).not.toHaveAccessibleName('Other text');
 });
 
-test('toHaveAccessibleName() supports calling without expected name', () => {
-  render(<View testID="view" accessibilityLabel="Test label" />);
+test('toHaveAccessibleName() supports calling without expected name', async () => {
+  await render(<View testID="view" accessibilityLabel="Test label" />);
 
   const element = screen.getByTestId('view');
   expect(element).toHaveAccessibleName();
@@ -103,8 +103,8 @@ test('toHaveAccessibleName() supports calling without expected name', () => {
   `);
 });
 
-test('toHaveAccessibleName() handles a view without name when called without expected name', () => {
-  render(<View testID="view" />);
+test('toHaveAccessibleName() handles a view without name when called without expected name', async () => {
+  await render(<View testID="view" />);
   const element = screen.getByTestId('view');
 
   expect(element).not.toHaveAccessibleName();
diff --git a/src/matchers/__tests__/to-have-display-value.test.tsx b/src/matchers/__tests__/to-have-display-value.test.tsx
index 32b9f6245..e4d4cc7c4 100644
--- a/src/matchers/__tests__/to-have-display-value.test.tsx
+++ b/src/matchers/__tests__/to-have-display-value.test.tsx
@@ -3,15 +3,15 @@ import { TextInput, View } from 'react-native';
 
 import { render, screen } from '../..';
 
-test('toHaveDisplayValue() example test', () => {
-  render(<TextInput testID="text-input" value="test" />);
+test('toHaveDisplayValue() example test', async () => {
+  await render(<TextInput testID="text-input" value="test" />);
 
   const textInput = screen.getByTestId('text-input');
   expect(textInput).toHaveDisplayValue('test');
 });
 
-test('toHaveDisplayValue() on matching display value', () => {
-  render(<TextInput testID="text-input" value="test" />);
+test('toHaveDisplayValue() on matching display value', async () => {
+  await render(<TextInput testID="text-input" value="test" />);
 
   const textInput = screen.getByTestId('text-input');
   expect(textInput).toHaveDisplayValue('test');
@@ -27,8 +27,8 @@ test('toHaveDisplayValue() on matching display value', () => {
   `);
 });
 
-test('toHaveDisplayValue() on non-matching display value', () => {
-  render(<TextInput testID="text-input" value="test" />);
+test('toHaveDisplayValue() on non-matching display value', async () => {
+  await render(<TextInput testID="text-input" value="test" />);
 
   const textInput = screen.getByTestId('text-input');
   expect(textInput).not.toHaveDisplayValue('non-test');
@@ -44,8 +44,8 @@ test('toHaveDisplayValue() on non-matching display value', () => {
   `);
 });
 
-test("toHaveDisplayValue() on non-'TextInput' elements", () => {
-  render(<View testID="view" />);
+test("toHaveDisplayValue() on non-'TextInput' elements", async () => {
+  await render(<View testID="view" />);
 
   const view = screen.getByTestId('view');
   expect(() => expect(view).toHaveDisplayValue('test')).toThrowErrorMatchingInlineSnapshot(
@@ -53,8 +53,8 @@ test("toHaveDisplayValue() on non-'TextInput' elements", () => {
   );
 });
 
-test('toHaveDisplayValue() performing partial match', () => {
-  render(<TextInput testID="text-input" value="Hello World" />);
+test('toHaveDisplayValue() performing partial match', async () => {
+  await render(<TextInput testID="text-input" value="Hello World" />);
 
   const textInput = screen.getByTestId('text-input');
   expect(textInput).toHaveDisplayValue('Hello World');
@@ -68,15 +68,15 @@ test('toHaveDisplayValue() performing partial match', () => {
   expect(textInput).toHaveDisplayValue('world', { exact: false });
 });
 
-test('toHaveDisplayValue() uses defaultValue', () => {
-  render(<TextInput testID="text-input" defaultValue="default" />);
+test('toHaveDisplayValue() uses defaultValue', async () => {
+  await render(<TextInput testID="text-input" defaultValue="default" />);
 
   const textInput = screen.getByTestId('text-input');
   expect(textInput).toHaveDisplayValue('default');
 });
 
-test('toHaveDisplayValue() prioritizes value over defaultValue', () => {
-  render(<TextInput testID="text-input" value="value" defaultValue="default" />);
+test('toHaveDisplayValue() prioritizes value over defaultValue', async () => {
+  await render(<TextInput testID="text-input" value="value" defaultValue="default" />);
 
   const textInput = screen.getByTestId('text-input');
   expect(textInput).toHaveDisplayValue('value');
diff --git a/src/matchers/__tests__/to-have-prop.test.tsx b/src/matchers/__tests__/to-have-prop.test.tsx
index a6c0fb3ee..da1ddd8de 100644
--- a/src/matchers/__tests__/to-have-prop.test.tsx
+++ b/src/matchers/__tests__/to-have-prop.test.tsx
@@ -3,8 +3,8 @@ import { Text, TextInput, View } from 'react-native';
 
 import { render, screen } from '../..';
 
-test('toHaveProp() basic case', () => {
-  render(
+test('toHaveProp() basic case', async () => {
+  await render(
     <View testID="view" style={null}>
       <Text ellipsizeMode="head">Hello</Text>
       <TextInput testID="input" textAlign="right" />
@@ -30,8 +30,8 @@ test('toHaveProp() basic case', () => {
   expect(input).not.toHaveProp('editable', false);
 });
 
-test('toHaveProp() error messages', () => {
-  render(<View testID="view" collapsable={false} />);
+test('toHaveProp() error messages', async () => {
+  await render(<View testID="view" collapsable={false} />);
 
   const view = screen.getByTestId('view');
 
diff --git a/src/matchers/__tests__/to-have-style.test.tsx b/src/matchers/__tests__/to-have-style.test.tsx
index 83af29c22..436799bcf 100644
--- a/src/matchers/__tests__/to-have-style.test.tsx
+++ b/src/matchers/__tests__/to-have-style.test.tsx
@@ -7,8 +7,8 @@ const styles = StyleSheet.create({
   container: { borderBottomColor: 'white' },
 });
 
-test('toHaveStyle() handles basic cases', () => {
-  render(
+test('toHaveStyle() handles basic cases', async () => {
+  await render(
     <View
       testID="view"
       style={[
@@ -49,8 +49,8 @@ test('toHaveStyle() handles basic cases', () => {
   });
 });
 
-test('toHaveStyle error messages', () => {
-  render(
+test('toHaveStyle error messages', async () => {
+  await render(
     <View
       testID="view"
       style={{
@@ -128,15 +128,15 @@ test('toHaveStyle error messages', () => {
   `);
 });
 
-test('toHaveStyle() supports missing "style" prop', () => {
-  render(<View testID="view" />);
+test('toHaveStyle() supports missing "style" prop', async () => {
+  await render(<View testID="view" />);
 
   const view = screen.getByTestId('view');
   expect(view).not.toHaveStyle({ fontWeight: 'bold' });
 });
 
-test('toHaveStyle() supports undefined "transform" style', () => {
-  render(
+test('toHaveStyle() supports undefined "transform" style', async () => {
+  await render(
     <View
       testID="view"
       style={{
@@ -163,14 +163,14 @@ test('toHaveStyle() supports undefined "transform" style', () => {
   `);
 });
 
-test('toHaveStyle() supports Pressable with function "style" prop', () => {
-  render(<Pressable testID="view" style={() => ({ backgroundColor: 'blue' })} />);
+test('toHaveStyle() supports Pressable with function "style" prop', async () => {
+  await render(<Pressable testID="view" style={() => ({ backgroundColor: 'blue' })} />);
 
   expect(screen.getByTestId('view')).toHaveStyle({ backgroundColor: 'blue' });
 });
 
-test('toHaveStyle() to differentiate number vs string values', () => {
-  const screen = render(
+test('toHaveStyle() to differentiate number vs string values', async () => {
+  const screen = await render(
     <Text
       testID="view"
       style={{
diff --git a/src/matchers/__tests__/to-have-text-content.test.tsx b/src/matchers/__tests__/to-have-text-content.test.tsx
index edb0724cb..3ac3686e0 100644
--- a/src/matchers/__tests__/to-have-text-content.test.tsx
+++ b/src/matchers/__tests__/to-have-text-content.test.tsx
@@ -3,10 +3,12 @@ import { Text, View } from 'react-native';
 
 import { render, screen } from '../..';
 
-test('toHaveTextContent() example test', () => {
-  render(
+test('toHaveTextContent() example test', async () => {
+  await render(
     <View testID="view">
-      <Text>Hello</Text> <Text>World</Text>
+      <Text>Hello</Text>
+      <Text> </Text>
+      <Text>World</Text>
     </View>,
   );
 
@@ -15,8 +17,8 @@ test('toHaveTextContent() example test', () => {
   expect(view).not.toHaveTextContent('Hello there');
 });
 
-test('toHaveTextContent() handles positive test cases', () => {
-  render(<Text testID="text">Hello World</Text>);
+test('toHaveTextContent() handles positive test cases', async () => {
+  await render(<Text testID="text">Hello World</Text>);
 
   const text = screen.getByTestId('text');
   expect(text).toHaveTextContent('Hello World');
@@ -24,8 +26,8 @@ test('toHaveTextContent() handles positive test cases', () => {
   expect(text).toHaveTextContent(/Hello World/);
 });
 
-test('toHaveTextContent() does exact match by default', () => {
-  render(<Text testID="text">Hello World</Text>);
+test('toHaveTextContent() does exact match by default', async () => {
+  await render(<Text testID="text">Hello World</Text>);
 
   const text = screen.getByTestId('text');
   expect(text).toHaveTextContent('Hello World');
@@ -33,8 +35,8 @@ test('toHaveTextContent() does exact match by default', () => {
   expect(text).not.toHaveTextContent('World');
 });
 
-test('toHaveTextContent() handles nested text', () => {
-  render(
+test('toHaveTextContent() handles nested text', async () => {
+  await render(
     <Text testID="text">
       Hello <Text>React</Text>
     </Text>,
@@ -44,8 +46,8 @@ test('toHaveTextContent() handles nested text', () => {
   expect(text).toHaveTextContent('Hello React');
 });
 
-test('toHaveTextContent() negative test cases', () => {
-  render(<Text testID="text">Hello World</Text>);
+test('toHaveTextContent() negative test cases', async () => {
+  await render(<Text testID="text">Hello World</Text>);
 
   const text = screen.getByTestId('text');
   expect(text).not.toHaveTextContent(/Hello React/);
diff --git a/src/matchers/__tests__/utils.test.tsx b/src/matchers/__tests__/utils.test.tsx
index def0c84c8..3fffe19e6 100644
--- a/src/matchers/__tests__/utils.test.tsx
+++ b/src/matchers/__tests__/utils.test.tsx
@@ -8,8 +8,8 @@ function fakeMatcher() {
   return { pass: true, message: () => 'fake' };
 }
 
-test('checkHostElement allows host element', () => {
-  render(<View testID="view" />);
+test('checkHostElement allows host element', async () => {
+  await render(<View testID="view" />);
 
   expect(() => {
     // @ts-expect-error: intentionally passing wrong element shape
diff --git a/src/pure.ts b/src/pure.ts
index f36b153e6..9ea2b5419 100644
--- a/src/pure.ts
+++ b/src/pure.ts
@@ -1,26 +1,21 @@
 export { default as act } from './act';
-export { default as cleanup, cleanupAsync } from './cleanup';
-export { fireEvent, deprecated_fireEventSync } from './fire-event';
-export { default as render } from './render';
-export { default as renderAsync } from './render-async';
-export { default as waitFor } from './wait-for';
-export { default as waitForElementToBeRemoved } from './wait-for-element-to-be-removed';
+export { cleanup } from './cleanup';
+export { fireEvent, unsafe_fireEventSync } from './fire-event';
+export { render } from './render';
+export { unsafe_renderSync } from './unsafe-render-sync';
+export { waitFor } from './wait-for';
+export { waitForElementToBeRemoved } from './wait-for-element-to-be-removed';
 export { within, getQueriesForElement } from './within';
 
 export { configure, resetToDefaults } from './config';
 export { isHiddenFromAccessibility, isInaccessible } from './helpers/accessibility';
 export { getDefaultNormalizer } from './matches';
-export { renderHook, deprecated_renderHookSync } from './render-hook';
+export { renderHook, unsafe_renderHookSync } from './render-hook';
 export { screen } from './screen';
 export { userEvent } from './user-event';
 
-export type {
-  RenderOptions,
-  RenderResult,
-  RenderResult as RenderAPI,
-  DebugFunction,
-} from './render';
-export type { RenderAsyncOptions, RenderAsyncResult } from './render-async';
+export type { RenderOptions, RenderResult, DebugFunction } from './render';
+export type { RenderSyncOptions, RenderSyncResult } from './unsafe-render-sync';
 export type { RenderHookOptions, RenderHookResult, RenderHookSyncResult } from './render-hook';
 export type { Config } from './config';
 export type { UserEventConfig } from './user-event';
diff --git a/src/queries/__tests__/display-value.test.tsx b/src/queries/__tests__/display-value.test.tsx
index 97d51f0cf..af36452c8 100644
--- a/src/queries/__tests__/display-value.test.tsx
+++ b/src/queries/__tests__/display-value.test.tsx
@@ -28,8 +28,8 @@ const Banana = () => (
   </View>
 );
 
-test('getByDisplayValue, queryByDisplayValue', () => {
-  render(<Banana />);
+test('getByDisplayValue, queryByDisplayValue', async () => {
+  await render(<Banana />);
 
   const input = screen.getByDisplayValue(/custom/i);
   expect(input).toHaveDisplayValue(INPUT_FRESHNESS);
@@ -47,8 +47,8 @@ test('getByDisplayValue, queryByDisplayValue', () => {
   );
 });
 
-test('getByDisplayValue, queryByDisplayValue get element by default value only when value is undefined', () => {
-  render(<Banana />);
+test('getByDisplayValue, queryByDisplayValue get element by default value only when value is undefined', async () => {
+  await render(<Banana />);
   expect(() => screen.getByDisplayValue(DEFAULT_INPUT_CHEF)).toThrowErrorMatchingInlineSnapshot(`
     "Unable to find an element with displayValue: What did you inspect?
 
@@ -105,8 +105,8 @@ test('getByDisplayValue, queryByDisplayValue get element by default value only w
   expect(screen.queryByDisplayValue(DEFAULT_INPUT_CUSTOMER)).toBeTruthy();
 });
 
-test('getAllByDisplayValue, queryAllByDisplayValue', () => {
-  render(<Banana />);
+test('getAllByDisplayValue, queryAllByDisplayValue', async () => {
+  await render(<Banana />);
   const inputs = screen.getAllByDisplayValue(/fresh/i);
 
   expect(inputs).toHaveLength(2);
@@ -120,7 +120,7 @@ test('getAllByDisplayValue, queryAllByDisplayValue', () => {
 
 test('findBy queries work asynchronously', async () => {
   const options = { timeout: 10 }; // Short timeout so that this test runs quickly
-  render(<View />);
+  await render(<View />);
 
   await expect(screen.findByDisplayValue('Display Value', {}, options)).rejects.toBeTruthy();
   await expect(screen.findAllByDisplayValue('Display Value', {}, options)).rejects.toBeTruthy();
@@ -139,8 +139,8 @@ test('findBy queries work asynchronously', async () => {
   await expect(screen.findAllByDisplayValue('Display Value')).resolves.toHaveLength(1);
 }, 20000);
 
-test('byDisplayValue queries support hidden option', () => {
-  render(<TextInput value="hidden" style={{ display: 'none' }} />);
+test('byDisplayValue queries support hidden option', async () => {
+  await render(<TextInput value="hidden" style={{ display: 'none' }} />);
 
   expect(screen.getByDisplayValue('hidden', { includeHiddenElements: true })).toBeTruthy();
 
@@ -161,14 +161,14 @@ test('byDisplayValue queries support hidden option', () => {
   `);
 });
 
-test('byDisplayValue should return host component', () => {
-  render(<TextInput value="value" />);
+test('byDisplayValue should return host component', async () => {
+  await render(<TextInput value="value" />);
 
   expect(screen.getByDisplayValue('value').type).toBe('TextInput');
 });
 
 test('error message renders the element tree, preserving only helpful props', async () => {
-  render(<TextInput value="1" key="3" />);
+  await render(<TextInput value="1" key="3" />);
 
   expect(() => screen.getByDisplayValue('2')).toThrowErrorMatchingInlineSnapshot(`
     "Unable to find an element with displayValue: 2
@@ -204,7 +204,7 @@ test('error message renders the element tree, preserving only helpful props', as
 });
 
 test('supports unmanaged TextInput element', async () => {
-  render(<TextInput testID="input" />);
+  await render(<TextInput testID="input" />);
 
   const input = screen.getByDisplayValue('');
   expect(input).toHaveDisplayValue('');
diff --git a/src/queries/__tests__/find-by.test.tsx b/src/queries/__tests__/find-by.test.tsx
index 4b9c9d602..e5e86b279 100644
--- a/src/queries/__tests__/find-by.test.tsx
+++ b/src/queries/__tests__/find-by.test.tsx
@@ -5,7 +5,7 @@ import { render, screen } from '../..';
 import { clearRenderResult } from '../../screen';
 
 test('findByTestId detects screen being detached', async () => {
-  render(<View />);
+  await render(<View />);
 
   const promise = screen.findByTestId('not-exists', {}, { timeout: 50 });
 
diff --git a/src/queries/__tests__/hint-text.test.tsx b/src/queries/__tests__/hint-text.test.tsx
index ad8f9f743..9f2e715c7 100644
--- a/src/queries/__tests__/hint-text.test.tsx
+++ b/src/queries/__tests__/hint-text.test.tsx
@@ -34,7 +34,7 @@ const Section = () => (
 );
 
 test('getByA11yHint, queryByA11yHint, findByA11yHint', async () => {
-  render(<Section />);
+  await render(<Section />);
 
   expect(screen.getByA11yHint(BUTTON_HINT).props.accessibilityHint).toEqual(BUTTON_HINT);
   const button = screen.queryByA11yHint(BUTTON_HINT);
@@ -64,7 +64,7 @@ test('getByA11yHint, queryByA11yHint, findByA11yHint', async () => {
 });
 
 test('getAllByA11yHint, queryAllByA11yHint, findAllByA11yHint', async () => {
-  render(<Section />);
+  await render(<Section />);
 
   expect(screen.getAllByA11yHint(TEXT_HINT)).toHaveLength(2);
   expect(screen.queryAllByA11yHint(TEXT_HINT)).toHaveLength(2);
@@ -80,8 +80,8 @@ test('getAllByA11yHint, queryAllByA11yHint, findAllByA11yHint', async () => {
   );
 });
 
-test('getByHintText, getByHintText', () => {
-  render(
+test('getByHintText, getByHintText', async () => {
+  await render(
     <View>
       <View accessibilityHint="test" />
       <View accessibilityHint="tests id" />
@@ -91,8 +91,8 @@ test('getByHintText, getByHintText', () => {
   expect(screen.getAllByHintText('test', { exact: false })).toHaveLength(2);
 });
 
-test('getByHintText, getByHintText and exact = true', () => {
-  render(
+test('getByHintText, getByHintText and exact = true', async () => {
+  await render(
     <View>
       <View accessibilityHint="test" />
       <View accessibilityHint="tests id" />
@@ -102,8 +102,8 @@ test('getByHintText, getByHintText and exact = true', () => {
   expect(screen.getAllByHintText('test', { exact: true })).toHaveLength(1);
 });
 
-test('byHintText queries support hidden option', () => {
-  render(
+test('byHintText queries support hidden option', async () => {
+  await render(
     <Text accessibilityHint="hidden" style={{ display: 'none' }}>
       Hidden from accessiblity
     </Text>,
@@ -131,7 +131,7 @@ test('byHintText queries support hidden option', () => {
 });
 
 test('error message renders the element tree, preserving only helpful props', async () => {
-  render(<Pressable accessibilityHint="HINT" key="3" />);
+  await render(<Pressable accessibilityHint="HINT" key="3" />);
 
   expect(() => screen.getByHintText('FOO')).toThrowErrorMatchingInlineSnapshot(`
     "Unable to find an element with accessibility hint: FOO
diff --git a/src/queries/__tests__/label-text.test.tsx b/src/queries/__tests__/label-text.test.tsx
index 04cb4967a..bc86fbe46 100644
--- a/src/queries/__tests__/label-text.test.tsx
+++ b/src/queries/__tests__/label-text.test.tsx
@@ -41,7 +41,7 @@ const Section = () => (
 );
 
 test('getByLabelText, queryByLabelText, findByLabelText', async () => {
-  render(<Section />);
+  await render(<Section />);
 
   expect(screen.getByLabelText(BUTTON_LABEL).props.accessibilityLabel).toEqual(BUTTON_LABEL);
   const button = screen.queryByLabelText(/button/);
@@ -71,7 +71,7 @@ test('getByLabelText, queryByLabelText, findByLabelText', async () => {
 });
 
 test('getAllByLabelText, queryAllByLabelText, findAllByLabelText', async () => {
-  render(<Section />);
+  await render(<Section />);
 
   expect(screen.getAllByLabelText(TEXT_LABEL)).toHaveLength(2);
   expect(screen.queryAllByLabelText(/cool/)).toHaveLength(3);
@@ -88,7 +88,7 @@ test('getAllByLabelText, queryAllByLabelText, findAllByLabelText', async () => {
 });
 
 test('getAllByLabelText, queryAllByLabelText, findAllByLabelText with exact as false', async () => {
-  render(<Section />);
+  await render(<Section />);
 
   expect(screen.getAllByLabelText(TEXT_LABEL, { exact: false })).toHaveLength(2);
   expect(screen.queryAllByLabelText(/cool/, { exact: false })).toHaveLength(3);
@@ -116,7 +116,7 @@ describe('findBy options deprecations', () => {
   test('findByText queries warn on deprecated use of WaitForOptions', async () => {
     const options = { timeout: 10 };
     // mock implementation to avoid warning in the test suite
-    render(<View />);
+    await render(<View />);
     await expect(screen.findByLabelText('Some Text', options)).rejects.toBeTruthy();
 
     setTimeout(() => screen.rerender(<View accessibilityLabel="Some Text" />), 20);
@@ -126,8 +126,8 @@ describe('findBy options deprecations', () => {
   }, 20000);
 });
 
-test('byLabelText queries support hidden option', () => {
-  render(
+test('byLabelText queries support hidden option', async () => {
+  await render(
     <Text accessibilityLabel="hidden" style={{ display: 'none' }}>
       Hidden from accessibility
     </Text>,
@@ -154,8 +154,8 @@ test('byLabelText queries support hidden option', () => {
   `);
 });
 
-test('getByLabelText supports aria-label', () => {
-  render(
+test('getByLabelText supports aria-label', async () => {
+  await render(
     <>
       <View testID="view" aria-label="view-label" />
       <Text testID="text" aria-label="text-label">
@@ -170,8 +170,8 @@ test('getByLabelText supports aria-label', () => {
   expect(screen.getByLabelText('text-input-label')).toBe(screen.getByTestId('text-input'));
 });
 
-test('getByLabelText supports accessibilityLabelledBy', () => {
-  render(
+test('getByLabelText supports accessibilityLabelledBy', async () => {
+  await render(
     <>
       <Text nativeID="label">Label for input</Text>
       <TextInput testID="textInput" accessibilityLabelledBy="label" />
@@ -182,8 +182,8 @@ test('getByLabelText supports accessibilityLabelledBy', () => {
   expect(screen.getByLabelText(/input/)).toBe(screen.getByTestId('textInput'));
 });
 
-test('getByLabelText supports nested accessibilityLabelledBy', () => {
-  render(
+test('getByLabelText supports nested accessibilityLabelledBy', async () => {
+  await render(
     <>
       <View nativeID="label">
         <Text>Label for input</Text>
@@ -196,8 +196,8 @@ test('getByLabelText supports nested accessibilityLabelledBy', () => {
   expect(screen.getByLabelText(/input/)).toBe(screen.getByTestId('textInput'));
 });
 
-test('getByLabelText supports aria-labelledby', () => {
-  render(
+test('getByLabelText supports aria-labelledby', async () => {
+  await render(
     <>
       <Text nativeID="label">Text Label</Text>
       <TextInput testID="text-input" aria-labelledby="label" />
@@ -208,8 +208,8 @@ test('getByLabelText supports aria-labelledby', () => {
   expect(screen.getByLabelText(/text label/i)).toBe(screen.getByTestId('text-input'));
 });
 
-test('getByLabelText supports nested aria-labelledby', () => {
-  render(
+test('getByLabelText supports nested aria-labelledby', async () => {
+  await render(
     <>
       <View nativeID="label">
         <Text>Nested Text Label</Text>
@@ -222,8 +222,8 @@ test('getByLabelText supports nested aria-labelledby', () => {
   expect(screen.getByLabelText(/nested text label/i)).toBe(screen.getByTestId('text-input'));
 });
 
-test('getByLabelText supports "Image"" with "alt" prop', () => {
-  render(
+test('getByLabelText supports "Image"" with "alt" prop', async () => {
+  await render(
     <>
       <Image alt="Image Label" testID="image" />
     </>,
@@ -235,7 +235,7 @@ test('getByLabelText supports "Image"" with "alt" prop', () => {
 });
 
 test('error message renders the element tree, preserving only helpful props', async () => {
-  render(<Pressable accessibilityLabel="LABEL" key="3" />);
+  await render(<Pressable accessibilityLabel="LABEL" key="3" />);
 
   expect(() => screen.getByLabelText('FOO')).toThrowErrorMatchingInlineSnapshot(`
     "Unable to find an element with accessibility label: FOO
diff --git a/src/queries/__tests__/make-queries.test.tsx b/src/queries/__tests__/make-queries.test.tsx
index b00e800ca..60e1d3c65 100644
--- a/src/queries/__tests__/make-queries.test.tsx
+++ b/src/queries/__tests__/make-queries.test.tsx
@@ -4,8 +4,8 @@ import { Text, TextInput, View } from 'react-native';
 import { render, screen } from '../..';
 
 describe('printing element tree', () => {
-  test('includes element tree on error with less-helpful props stripped', () => {
-    render(<Text onPress={() => null}>Some text</Text>);
+  test('includes element tree on error with less-helpful props stripped', async () => {
+    await render(<Text onPress={() => null}>Some text</Text>);
 
     expect(() => screen.getByText(/foo/)).toThrowErrorMatchingInlineSnapshot(`
       "Unable to find an element with text: /foo/
@@ -16,8 +16,8 @@ describe('printing element tree', () => {
     `);
   });
 
-  test('prints helpful props but not others', () => {
-    render(
+  test('prints helpful props but not others', async () => {
+    await render(
       <View
         key="this is filtered"
         testID="TEST_ID"
@@ -90,7 +90,7 @@ describe('printing element tree', () => {
   });
 
   test('prints tree and filters props with getBy, getAllBy, findBy, findAllBy', async () => {
-    render(<View accessibilityViewIsModal key="this is filtered" />);
+    await render(<View accessibilityViewIsModal key="this is filtered" />);
 
     expect(() => screen.getByText(/foo/)).toThrowErrorMatchingInlineSnapshot(`
       "Unable to find an element with text: /foo/
@@ -126,7 +126,7 @@ describe('printing element tree', () => {
   });
 
   test('only appends element tree on last failure with findBy', async () => {
-    render(<View accessibilityViewIsModal key="this is filtered" />);
+    await render(<View accessibilityViewIsModal key="this is filtered" />);
 
     jest.spyOn(screen, 'toJSON');
 
@@ -136,7 +136,7 @@ describe('printing element tree', () => {
   });
 
   test('onTimeout with findBy receives error without element tree', async () => {
-    render(<View />);
+    await render(<View />);
 
     const onTimeout = jest.fn((_: Error) => new Error('Replacement error'));
 
@@ -152,7 +152,7 @@ describe('printing element tree', () => {
   });
 
   test('onTimeout with findAllBy receives error without element tree', async () => {
-    render(<View />);
+    await render(<View />);
 
     const onTimeout = jest.fn((_: Error) => new Error('Replacement error'));
 
@@ -167,8 +167,8 @@ describe('printing element tree', () => {
     );
   });
 
-  test('does not strip display: none from "style" prop, but does strip other styles', () => {
-    render(
+  test('does not strip display: none from "style" prop, but does strip other styles', async () => {
+    await render(
       <View style={{ display: 'flex', position: 'absolute' }}>
         <Text
           style={[
@@ -198,8 +198,8 @@ describe('printing element tree', () => {
     `);
   });
 
-  test('strips undefined values from accessibilityState', () => {
-    render(
+  test('strips undefined values from accessibilityState', async () => {
+    await render(
       <View accessibilityState={{ checked: true, busy: false }}>
         <View accessibilityState={{ checked: undefined }} />
       </View>,
@@ -221,8 +221,8 @@ describe('printing element tree', () => {
     `);
   });
 
-  test('strips undefined values from accessibilityValue', () => {
-    render(
+  test('strips undefined values from accessibilityValue', async () => {
+    await render(
       <View accessibilityValue={{ min: 1 }}>
         <View accessibilityState={{}} />
       </View>,
@@ -243,8 +243,8 @@ describe('printing element tree', () => {
     `);
   });
 
-  test('does not render element tree when toJSON() returns null', () => {
-    render(<View />);
+  test('does not render element tree when toJSON() returns null', async () => {
+    await render(<View />);
 
     jest.spyOn(screen, 'toJSON').mockImplementation(() => null);
     expect(() => screen.getByText(/foo/)).toThrowErrorMatchingInlineSnapshot(
diff --git a/src/queries/__tests__/placeholder-text.test.tsx b/src/queries/__tests__/placeholder-text.test.tsx
index 47309b45f..94c11795f 100644
--- a/src/queries/__tests__/placeholder-text.test.tsx
+++ b/src/queries/__tests__/placeholder-text.test.tsx
@@ -25,8 +25,8 @@ const Banana = () => (
   </View>
 );
 
-test('getByPlaceholderText, queryByPlaceholderText', () => {
-  render(<Banana />);
+test('getByPlaceholderText, queryByPlaceholderText', async () => {
+  await render(<Banana />);
   const input = screen.getByPlaceholderText(/custom/i);
 
   expect(input.props.placeholder).toBe(PLACEHOLDER_FRESHNESS);
@@ -45,8 +45,8 @@ test('getByPlaceholderText, queryByPlaceholderText', () => {
   );
 });
 
-test('getAllByPlaceholderText, queryAllByPlaceholderText', () => {
-  render(<Banana />);
+test('getAllByPlaceholderText, queryAllByPlaceholderText', async () => {
+  await render(<Banana />);
   const inputs = screen.getAllByPlaceholderText(/fresh/i);
 
   expect(inputs).toHaveLength(2);
@@ -58,8 +58,8 @@ test('getAllByPlaceholderText, queryAllByPlaceholderText', () => {
   expect(screen.queryAllByPlaceholderText('no placeholder')).toHaveLength(0);
 });
 
-test('byPlaceholderText queries support hidden option', () => {
-  render(<TextInput placeholder="hidden" style={{ display: 'none' }} />);
+test('byPlaceholderText queries support hidden option', async () => {
+  await render(<TextInput placeholder="hidden" style={{ display: 'none' }} />);
 
   expect(screen.getByPlaceholderText('hidden', { includeHiddenElements: true })).toBeTruthy();
 
@@ -80,14 +80,14 @@ test('byPlaceholderText queries support hidden option', () => {
   `);
 });
 
-test('byPlaceHolderText should return host component', () => {
-  render(<TextInput placeholder="placeholder" />);
+test('byPlaceHolderText should return host component', async () => {
+  await render(<TextInput placeholder="placeholder" />);
 
   expect(screen.getByPlaceholderText('placeholder').type).toBe('TextInput');
 });
 
 test('error message renders the element tree, preserving only helpful props', async () => {
-  render(<TextInput placeholder="PLACEHOLDER" key="3" />);
+  await render(<TextInput placeholder="PLACEHOLDER" key="3" />);
 
   expect(() => screen.getByPlaceholderText('FOO')).toThrowErrorMatchingInlineSnapshot(`
     "Unable to find an element with placeholder: FOO
diff --git a/src/queries/__tests__/role-value.test.tsx b/src/queries/__tests__/role-value.test.tsx
index e327ae8b3..c2a1bb5ab 100644
--- a/src/queries/__tests__/role-value.test.tsx
+++ b/src/queries/__tests__/role-value.test.tsx
@@ -4,8 +4,8 @@ import { Text, View } from 'react-native';
 import { render, screen } from '../..';
 
 describe('accessibility value', () => {
-  test('matches using all value props', () => {
-    render(
+  test('matches using all value props', async () => {
+    await render(
       <View
         accessible
         accessibilityRole="adjustable"
@@ -40,8 +40,8 @@ describe('accessibility value', () => {
     ).toBeFalsy();
   });
 
-  test('matches using single value', () => {
-    render(
+  test('matches using single value', async () => {
+    await render(
       <View
         accessible
         accessibilityRole="adjustable"
@@ -62,8 +62,8 @@ describe('accessibility value', () => {
     expect(screen.queryByRole('adjustable', { value: { text: /no/ } })).toBeFalsy();
   });
 
-  test('matches using single value and other options', () => {
-    render(
+  test('matches using single value and other options', async () => {
+    await render(
       <Text
         accessibilityRole="adjustable"
         accessibilityState={{ disabled: true }}
@@ -170,34 +170,34 @@ describe('accessibility value', () => {
     `);
   });
 
-  test('supports "aria-valuemax" prop', () => {
-    render(<View accessible role="slider" aria-valuemax={10} />);
+  test('supports "aria-valuemax" prop', async () => {
+    await render(<View accessible role="slider" aria-valuemax={10} />);
     expect(screen.getByRole('slider', { value: { max: 10 } })).toBeTruthy();
     expect(screen.queryByRole('slider', { value: { max: 20 } })).toBeNull();
   });
 
-  test('supports "aria-valuemin" prop', () => {
-    render(<View accessible role="slider" aria-valuemin={20} />);
+  test('supports "aria-valuemin" prop', async () => {
+    await render(<View accessible role="slider" aria-valuemin={20} />);
     expect(screen.getByRole('slider', { value: { min: 20 } })).toBeTruthy();
     expect(screen.queryByRole('slider', { value: { min: 30 } })).toBeNull();
   });
 
-  test('supports "aria-valuenow" prop', () => {
-    render(<View accessible role="slider" aria-valuenow={30} />);
+  test('supports "aria-valuenow" prop', async () => {
+    await render(<View accessible role="slider" aria-valuenow={30} />);
     expect(screen.getByRole('slider', { value: { now: 30 } })).toBeTruthy();
     expect(screen.queryByRole('slider', { value: { now: 10 } })).toBeNull();
   });
 
-  test('supports "aria-valuetext" prop', () => {
-    render(<View accessible role="slider" aria-valuetext="Hello World" />);
+  test('supports "aria-valuetext" prop', async () => {
+    await render(<View accessible role="slider" aria-valuetext="Hello World" />);
     expect(screen.getByRole('slider', { value: { text: 'Hello World' } })).toBeTruthy();
     expect(screen.getByRole('slider', { value: { text: /hello/i } })).toBeTruthy();
     expect(screen.queryByRole('slider', { value: { text: 'Hello' } })).toBeNull();
     expect(screen.queryByRole('slider', { value: { text: /salut/i } })).toBeNull();
   });
 
-  test('supports multiple "aria-value*" props', () => {
-    render(
+  test('supports multiple "aria-value*" props', async () => {
+    await render(
       <View accessible role="slider" aria-valuenow={50} aria-valuemin={0} aria-valuemax={100} />,
     );
     expect(screen.getByRole('slider', { value: { now: 50, min: 0, max: 100 } })).toBeTruthy();
diff --git a/src/queries/__tests__/role.test.tsx b/src/queries/__tests__/role.test.tsx
index 6d0cbe641..7a112b5bd 100644
--- a/src/queries/__tests__/role.test.tsx
+++ b/src/queries/__tests__/role.test.tsx
@@ -44,7 +44,7 @@ const Section = () => (
 );
 
 test('getByRole, queryByRole, findByRole', async () => {
-  render(<Section />);
+  await render(<Section />);
 
   expect(screen.getByRole('button').props.accessibilityRole).toEqual('button');
   const button = screen.queryByRole(/button/);
@@ -68,7 +68,7 @@ test('getByRole, queryByRole, findByRole', async () => {
 });
 
 test('getAllByRole, queryAllByRole, findAllByRole', async () => {
-  render(<Section />);
+  await render(<Section />);
 
   expect(screen.getAllByRole('link')).toHaveLength(2);
   expect(screen.queryAllByRole(/ink/)).toHaveLength(2);
@@ -84,8 +84,8 @@ test('getAllByRole, queryAllByRole, findAllByRole', async () => {
   );
 });
 
-test('supports role prop', () => {
-  render(
+test('supports role prop', async () => {
+  await render(
     <>
       <View accessible role="checkbox" />
       <View accessible role="radio" />
@@ -108,24 +108,24 @@ test('supports role prop', () => {
   expect(screen.getByRole('button')).toBeTruthy();
 });
 
-test('supports default View component "none" role', () => {
-  render(<View testID="view" accessible />);
+test('supports default View component "none" role', async () => {
+  await render(<View testID="view" accessible />);
   expect(screen.getByRole('none').props.testID).toBe('view');
 });
 
-test('supports default Text component  "text" role', () => {
-  render(<Text testID="text" />);
+test('supports default Text component  "text" role', async () => {
+  await render(<Text testID="text" />);
   expect(screen.getByRole('text').props.testID).toBe('text');
 });
 
-test('supports default TextInput component "none" role', () => {
-  render(<TextInput testID="text-input" />);
+test('supports default TextInput component "none" role', async () => {
+  await render(<TextInput testID="text-input" />);
   expect(screen.getByRole('none').props.testID).toBe('text-input');
 });
 
 describe('supports name option', () => {
-  test('returns an element that has the corresponding role and a children with the name', () => {
-    render(
+  test('returns an element that has the corresponding role and a children with the name', async () => {
+    await render(
       <TouchableOpacity accessibilityRole="button" testID="target-button">
         <Text>Save</Text>
       </TouchableOpacity>,
@@ -135,8 +135,8 @@ describe('supports name option', () => {
     expect(screen.getByRole('button', { name: 'Save' }).props.testID).toBe('target-button');
   });
 
-  test('returns an element that has the corresponding role when several children include the name', () => {
-    render(
+  test('returns an element that has the corresponding role when several children include the name', async () => {
+    await render(
       <TouchableOpacity accessibilityRole="button" testID="target-button">
         <Text>Save</Text>
         <Text>Save</Text>
@@ -147,8 +147,8 @@ describe('supports name option', () => {
     expect(screen.getByRole('button', { name: 'Save' }).props.testID).toBe('target-button');
   });
 
-  test('returns an element that has the corresponding role and a children with a matching accessibilityLabel', () => {
-    render(
+  test('returns an element that has the corresponding role and a children with a matching accessibilityLabel', async () => {
+    await render(
       <TouchableOpacity accessibilityRole="button" testID="target-button">
         <Text accessibilityLabel="Save" />
       </TouchableOpacity>,
@@ -158,8 +158,8 @@ describe('supports name option', () => {
     expect(screen.getByRole('button', { name: 'Save' }).props.testID).toBe('target-button');
   });
 
-  test('returns an element that has the corresponding role and a matching accessibilityLabel', () => {
-    render(
+  test('returns an element that has the corresponding role and a matching accessibilityLabel', async () => {
+    await render(
       <TouchableOpacity
         accessibilityRole="button"
         testID="target-button"
@@ -171,8 +171,8 @@ describe('supports name option', () => {
     expect(screen.getByRole('button', { name: 'Save' }).props.testID).toBe('target-button');
   });
 
-  test('returns an element that has the corresponding role and a children with a matching aria-label', () => {
-    render(
+  test('returns an element that has the corresponding role and a children with a matching aria-label', async () => {
+    await render(
       <TouchableOpacity accessibilityRole="button" testID="target-button">
         <Text aria-label="Save" />
       </TouchableOpacity>,
@@ -182,8 +182,8 @@ describe('supports name option', () => {
     expect(screen.getByRole('button', { name: 'Save' }).props.testID).toBe('target-button');
   });
 
-  test('returns an element that has the corresponding role and a matching aria-label', () => {
-    render(
+  test('returns an element that has the corresponding role and a matching aria-label', async () => {
+    await render(
       <TouchableOpacity
         accessibilityRole="button"
         testID="target-button"
@@ -195,8 +195,8 @@ describe('supports name option', () => {
     expect(screen.getByRole('button', { name: 'Save' }).props.testID).toBe('target-button');
   });
 
-  test('returns an element when the direct child is text', () => {
-    render(
+  test('returns an element when the direct child is text', async () => {
+    await render(
       <Text accessibilityRole="header" testID="target-header">
         About
       </Text>,
@@ -207,8 +207,8 @@ describe('supports name option', () => {
     expect(screen.getByRole('header', { name: 'About' }).props.testID).toBe('target-header');
   });
 
-  test('returns an element with nested Text as children', () => {
-    render(
+  test('returns an element with nested Text as children', async () => {
+    await render(
       <Text accessibilityRole="header" testID="parent">
         <Text testID="child">About</Text>
       </Text>,
@@ -219,16 +219,18 @@ describe('supports name option', () => {
     expect(screen.getByRole('header', { name: 'About' }).props.testID).toBe('parent');
   });
 
-  test('returns a header with an accessibilityLabel', () => {
-    render(<Text accessibilityRole="header" testID="target-header" accessibilityLabel="About" />);
+  test('returns a header with an accessibilityLabel', async () => {
+    await render(
+      <Text accessibilityRole="header" testID="target-header" accessibilityLabel="About" />,
+    );
 
     // assert on the testId to be sure that the returned element is the one with the accessibilityRole
     expect(screen.getByRole('header', { name: 'About' })).toBe(screen.getByTestId('target-header'));
     expect(screen.getByRole('header', { name: 'About' }).props.testID).toBe('target-header');
   });
 
-  test('supports host Image element with "alt" prop', () => {
-    render(
+  test('supports host Image element with "alt" prop', async () => {
+    await render(
       <>
         <Image testID="image1" role="img" alt="an elephant" />
         <Image testID="image2" accessibilityRole="image" alt="a tiger" />
@@ -249,8 +251,8 @@ describe('supports name option', () => {
 
 describe('supports accessibility states', () => {
   describe('disabled', () => {
-    test('returns a disabled element when required', () => {
-      render(
+    test('returns a disabled element when required', async () => {
+      await render(
         <TouchableOpacity accessibilityRole="button" accessibilityState={{ disabled: true }} />,
       );
 
@@ -258,8 +260,8 @@ describe('supports accessibility states', () => {
       expect(screen.queryByRole('button', { disabled: false })).toBe(null);
     });
 
-    test('returns the correct element when only one matches all the requirements', () => {
-      render(
+    test('returns the correct element when only one matches all the requirements', async () => {
+      await render(
         <>
           <TouchableOpacity
             testID="correct"
@@ -282,15 +284,15 @@ describe('supports accessibility states', () => {
       ).toBe('correct');
     });
 
-    test('returns an implicitly enabled element', () => {
-      render(<TouchableOpacity accessibilityRole="button"></TouchableOpacity>);
+    test('returns an implicitly enabled element', async () => {
+      await render(<TouchableOpacity accessibilityRole="button"></TouchableOpacity>);
 
       expect(screen.getByRole('button', { disabled: false })).toBeTruthy();
       expect(screen.queryByRole('button', { disabled: true })).toBe(null);
     });
 
-    test('returns an explicitly enabled element', () => {
-      render(
+    test('returns an explicitly enabled element', async () => {
+      await render(
         <TouchableOpacity
           accessibilityRole="button"
           accessibilityState={{ disabled: false }}
@@ -301,8 +303,8 @@ describe('supports accessibility states', () => {
       expect(screen.queryByRole('button', { disabled: true })).toBe(null);
     });
 
-    test('does not return disabled elements when querying for non disabled', () => {
-      render(
+    test('does not return disabled elements when querying for non disabled', async () => {
+      await render(
         <TouchableOpacity
           accessibilityRole="button"
           accessibilityState={{ disabled: true }}
@@ -312,8 +314,8 @@ describe('supports accessibility states', () => {
       expect(screen.queryByRole('button', { disabled: false })).toBe(null);
     });
 
-    test('returns elements using the built-in disabled prop', () => {
-      render(
+    test('returns elements using the built-in disabled prop', async () => {
+      await render(
         <>
           <Pressable disabled accessibilityRole="button">
             <Text>Pressable</Text>
@@ -340,35 +342,37 @@ describe('supports accessibility states', () => {
       expect(screen.getByRole('button', { name: 'RNButton', disabled: true })).toBeTruthy();
     });
 
-    test('supports aria-disabled={true} prop', () => {
-      render(<View accessible accessibilityRole="button" aria-disabled={true} />);
+    test('supports aria-disabled={true} prop', async () => {
+      await render(<View accessible accessibilityRole="button" aria-disabled={true} />);
       expect(screen.getByRole('button', { disabled: true })).toBeTruthy();
       expect(screen.queryByRole('button', { disabled: false })).toBeNull();
     });
 
-    test('supports aria-disabled={false} prop', () => {
-      render(<View accessible accessibilityRole="button" aria-disabled={false} />);
+    test('supports aria-disabled={false} prop', async () => {
+      await render(<View accessible accessibilityRole="button" aria-disabled={false} />);
       expect(screen.getByRole('button', { disabled: false })).toBeTruthy();
       expect(screen.queryByRole('button', { disabled: true })).toBeNull();
     });
 
-    test('supports default aria-disabled prop', () => {
-      render(<View accessible accessibilityRole="button" />);
+    test('supports default aria-disabled prop', async () => {
+      await render(<View accessible accessibilityRole="button" />);
       expect(screen.getByRole('button', { disabled: false })).toBeTruthy();
       expect(screen.queryByRole('button', { disabled: true })).toBeNull();
     });
   });
 
   describe('selected', () => {
-    test('returns a selected element when required', () => {
-      render(<TouchableOpacity accessibilityRole="tab" accessibilityState={{ selected: true }} />);
+    test('returns a selected element when required', async () => {
+      await render(
+        <TouchableOpacity accessibilityRole="tab" accessibilityState={{ selected: true }} />,
+      );
 
       expect(screen.getByRole('tab', { selected: true })).toBeTruthy();
       expect(screen.queryByRole('tab', { selected: false })).toBe(null);
     });
 
-    test('returns the correct element when only one matches all the requirements', () => {
-      render(
+    test('returns the correct element when only one matches all the requirements', async () => {
+      await render(
         <>
           <TouchableOpacity
             testID="correct"
@@ -388,15 +392,15 @@ describe('supports accessibility states', () => {
       );
     });
 
-    test('returns an implicitly non selected element', () => {
-      render(<TouchableOpacity accessibilityRole="tab"></TouchableOpacity>);
+    test('returns an implicitly non selected element', async () => {
+      await render(<TouchableOpacity accessibilityRole="tab"></TouchableOpacity>);
 
       expect(screen.getByRole('tab', { selected: false })).toBeTruthy();
       expect(screen.queryByRole('tab', { selected: true })).toBe(null);
     });
 
-    test('returns an explicitly non selected element', () => {
-      render(
+    test('returns an explicitly non selected element', async () => {
+      await render(
         <TouchableOpacity
           accessibilityRole="tab"
           accessibilityState={{ selected: false }}
@@ -407,8 +411,8 @@ describe('supports accessibility states', () => {
       expect(screen.queryByRole('tab', { selected: true })).toBe(null);
     });
 
-    test('does not return selected elements when querying for non selected', () => {
-      render(
+    test('does not return selected elements when querying for non selected', async () => {
+      await render(
         <TouchableOpacity
           accessibilityRole="tab"
           accessibilityState={{ selected: true }}
@@ -418,28 +422,28 @@ describe('supports accessibility states', () => {
       expect(screen.queryByRole('tab', { selected: false })).toBe(null);
     });
 
-    test('supports aria-selected={true} prop', () => {
-      render(<View accessible accessibilityRole="button" aria-selected={true} />);
+    test('supports aria-selected={true} prop', async () => {
+      await render(<View accessible accessibilityRole="button" aria-selected={true} />);
       expect(screen.getByRole('button', { selected: true })).toBeTruthy();
       expect(screen.queryByRole('button', { selected: false })).toBeNull();
     });
 
-    test('supports aria-selected={false} prop', () => {
-      render(<View accessible accessibilityRole="button" aria-selected={false} />);
+    test('supports aria-selected={false} prop', async () => {
+      await render(<View accessible accessibilityRole="button" aria-selected={false} />);
       expect(screen.getByRole('button', { selected: false })).toBeTruthy();
       expect(screen.queryByRole('button', { selected: true })).toBeNull();
     });
 
-    test('supports default aria-selected prop', () => {
-      render(<View accessible accessibilityRole="button" />);
+    test('supports default aria-selected prop', async () => {
+      await render(<View accessible accessibilityRole="button" />);
       expect(screen.getByRole('button', { selected: false })).toBeTruthy();
       expect(screen.queryByRole('button', { selected: true })).toBeNull();
     });
   });
 
   describe('checked', () => {
-    test('returns a checked element when required', () => {
-      render(
+    test('returns a checked element when required', async () => {
+      await render(
         <TouchableOpacity accessibilityRole="checkbox" accessibilityState={{ checked: true }} />,
       );
 
@@ -448,8 +452,8 @@ describe('supports accessibility states', () => {
       expect(screen.queryByRole('checkbox', { checked: 'mixed' })).toBe(null);
     });
 
-    test('returns `mixed` checkboxes', () => {
-      render(
+    test('returns `mixed` checkboxes', async () => {
+      await render(
         <TouchableOpacity accessibilityRole="checkbox" accessibilityState={{ checked: 'mixed' }} />,
       );
 
@@ -458,16 +462,16 @@ describe('supports accessibility states', () => {
       expect(screen.queryByRole('checkbox', { checked: false })).toBe(null);
     });
 
-    it('does not return mixed checkboxes when querying for checked: true', () => {
-      render(
+    it('does not return mixed checkboxes when querying for checked: true', async () => {
+      await render(
         <TouchableOpacity accessibilityRole="checkbox" accessibilityState={{ checked: 'mixed' }} />,
       );
 
       expect(screen.queryByRole('checkbox', { checked: false })).toBe(null);
     });
 
-    test('returns the correct element when only one matches all the requirements', () => {
-      render(
+    test('returns the correct element when only one matches all the requirements', async () => {
+      await render(
         <>
           <TouchableOpacity
             testID="correct"
@@ -490,14 +494,14 @@ describe('supports accessibility states', () => {
       ).toBe('correct');
     });
 
-    test('does not return return as non checked an element with checked: undefined', () => {
-      render(<TouchableOpacity accessibilityRole="checkbox"></TouchableOpacity>);
+    test('does not return return as non checked an element with checked: undefined', async () => {
+      await render(<TouchableOpacity accessibilityRole="checkbox"></TouchableOpacity>);
 
       expect(screen.queryByRole('checkbox', { checked: false })).toBe(null);
     });
 
-    test('returns an explicitly non checked element', () => {
-      render(
+    test('returns an explicitly non checked element', async () => {
+      await render(
         <TouchableOpacity
           accessibilityRole="checkbox"
           accessibilityState={{ checked: false }}
@@ -508,8 +512,8 @@ describe('supports accessibility states', () => {
       expect(screen.queryByRole('checkbox', { checked: true })).toBe(null);
     });
 
-    test('does not return checked elements when querying for non checked', () => {
-      render(
+    test('does not return checked elements when querying for non checked', async () => {
+      await render(
         <TouchableOpacity
           accessibilityRole="checkbox"
           accessibilityState={{ checked: true }}
@@ -519,8 +523,8 @@ describe('supports accessibility states', () => {
       expect(screen.queryByRole('checkbox', { checked: false })).toBe(null);
     });
 
-    test('does not return mixed elements when querying for non checked', () => {
-      render(
+    test('does not return mixed elements when querying for non checked', async () => {
+      await render(
         <TouchableOpacity
           accessibilityRole="checkbox"
           accessibilityState={{ checked: 'mixed' }}
@@ -530,37 +534,37 @@ describe('supports accessibility states', () => {
       expect(screen.queryByRole('checkbox', { checked: false })).toBe(null);
     });
 
-    test('supports "Switch" component', () => {
-      render(<Switch value={true} />);
+    test('supports "Switch" component', async () => {
+      await render(<Switch value={true} />);
 
       expect(screen.getByRole('switch', { checked: true })).toBeTruthy();
       expect(screen.queryByRole('switch', { checked: false })).toBe(null);
       expect(screen.queryByRole('switch', { checked: 'mixed' })).toBe(null);
     });
 
-    test('supports aria-checked={true} prop', () => {
-      render(<View accessible role="checkbox" aria-checked={true} />);
+    test('supports aria-checked={true} prop', async () => {
+      await render(<View accessible role="checkbox" aria-checked={true} />);
       expect(screen.getByRole('checkbox', { checked: true })).toBeTruthy();
       expect(screen.queryByRole('checkbox', { checked: false })).toBeNull();
       expect(screen.queryByRole('checkbox', { checked: 'mixed' })).toBeNull();
     });
 
-    test('supports aria-checked={false} prop', () => {
-      render(<View accessible role="checkbox" aria-checked={false} />);
+    test('supports aria-checked={false} prop', async () => {
+      await render(<View accessible role="checkbox" aria-checked={false} />);
       expect(screen.getByRole('checkbox', { checked: false })).toBeTruthy();
       expect(screen.queryByRole('checkbox', { checked: true })).toBeNull();
       expect(screen.queryByRole('checkbox', { checked: 'mixed' })).toBeNull();
     });
 
-    test('supports aria-checked="mixed" prop', () => {
-      render(<View accessible role="checkbox" aria-checked="mixed" />);
+    test('supports aria-checked="mixed" prop', async () => {
+      await render(<View accessible role="checkbox" aria-checked="mixed" />);
       expect(screen.getByRole('checkbox', { checked: 'mixed' })).toBeTruthy();
       expect(screen.queryByRole('checkbox', { checked: true })).toBeNull();
       expect(screen.queryByRole('checkbox', { checked: false })).toBeNull();
     });
 
-    test('supports default aria-selected prop', () => {
-      render(<View accessible role="checkbox" />);
+    test('supports default aria-selected prop', async () => {
+      await render(<View accessible role="checkbox" />);
       expect(screen.getByRole('checkbox')).toBeTruthy();
       expect(screen.queryByRole('checkbox', { checked: true })).toBeNull();
       expect(screen.queryByRole('checkbox', { checked: false })).toBeNull();
@@ -569,15 +573,17 @@ describe('supports accessibility states', () => {
   });
 
   describe('busy', () => {
-    test('returns a busy element when required', () => {
-      render(<TouchableOpacity accessibilityRole="button" accessibilityState={{ busy: true }} />);
+    test('returns a busy element when required', async () => {
+      await render(
+        <TouchableOpacity accessibilityRole="button" accessibilityState={{ busy: true }} />,
+      );
 
       expect(screen.getByRole('button', { busy: true })).toBeTruthy();
       expect(screen.queryByRole('button', { busy: false })).toBe(null);
     });
 
-    test('returns the correct element when only one matches all the requirements', () => {
-      render(
+    test('returns the correct element when only one matches all the requirements', async () => {
+      await render(
         <>
           <TouchableOpacity
             testID="correct"
@@ -595,15 +601,15 @@ describe('supports accessibility states', () => {
       expect(screen.getByRole('button', { name: 'Save', busy: true }).props.testID).toBe('correct');
     });
 
-    test('returns an implicitly non busy element', () => {
-      render(<TouchableOpacity accessibilityRole="button"></TouchableOpacity>);
+    test('returns an implicitly non busy element', async () => {
+      await render(<TouchableOpacity accessibilityRole="button"></TouchableOpacity>);
 
       expect(screen.getByRole('button', { busy: false })).toBeTruthy();
       expect(screen.queryByRole('button', { busy: true })).toBe(null);
     });
 
-    test('returns an explicitly non busy element', () => {
-      render(
+    test('returns an explicitly non busy element', async () => {
+      await render(
         <TouchableOpacity
           accessibilityRole="button"
           accessibilityState={{ busy: false }}
@@ -614,8 +620,8 @@ describe('supports accessibility states', () => {
       expect(screen.queryByRole('button', { busy: true })).toBe(null);
     });
 
-    test('does not return busy elements when querying for non busy', () => {
-      render(
+    test('does not return busy elements when querying for non busy', async () => {
+      await render(
         <TouchableOpacity
           accessibilityRole="button"
           accessibilityState={{ selected: true }}
@@ -625,28 +631,28 @@ describe('supports accessibility states', () => {
       expect(screen.queryByRole('button', { selected: false })).toBe(null);
     });
 
-    test('supports aria-busy={true} prop', () => {
-      render(<View accessible accessibilityRole="button" aria-busy={true} />);
+    test('supports aria-busy={true} prop', async () => {
+      await render(<View accessible accessibilityRole="button" aria-busy={true} />);
       expect(screen.getByRole('button', { busy: true })).toBeTruthy();
       expect(screen.queryByRole('button', { busy: false })).toBeNull();
     });
 
-    test('supports aria-busy={false} prop', () => {
-      render(<View accessible accessibilityRole="button" aria-busy={false} />);
+    test('supports aria-busy={false} prop', async () => {
+      await render(<View accessible accessibilityRole="button" aria-busy={false} />);
       expect(screen.getByRole('button', { busy: false })).toBeTruthy();
       expect(screen.queryByRole('button', { busy: true })).toBeNull();
     });
 
-    test('supports default aria-busy prop', () => {
-      render(<View accessible accessibilityRole="button" />);
+    test('supports default aria-busy prop', async () => {
+      await render(<View accessible accessibilityRole="button" />);
       expect(screen.getByRole('button', { busy: false })).toBeTruthy();
       expect(screen.queryByRole('button', { busy: true })).toBeNull();
     });
   });
 
   describe('expanded', () => {
-    test('returns a expanded element when required', () => {
-      render(
+    test('returns a expanded element when required', async () => {
+      await render(
         <TouchableOpacity accessibilityRole="button" accessibilityState={{ expanded: true }} />,
       );
 
@@ -654,8 +660,8 @@ describe('supports accessibility states', () => {
       expect(screen.queryByRole('button', { expanded: false })).toBe(null);
     });
 
-    test('returns the correct element when only one matches all the requirements', () => {
-      render(
+    test('returns the correct element when only one matches all the requirements', async () => {
+      await render(
         <>
           <TouchableOpacity
             testID="correct"
@@ -678,14 +684,14 @@ describe('supports accessibility states', () => {
       ).toBe('correct');
     });
 
-    test('does not return return as non expanded an element with expanded: undefined', () => {
-      render(<TouchableOpacity accessibilityRole="button"></TouchableOpacity>);
+    test('does not return return as non expanded an element with expanded: undefined', async () => {
+      await render(<TouchableOpacity accessibilityRole="button"></TouchableOpacity>);
 
       expect(screen.queryByRole('button', { expanded: false })).toBe(null);
     });
 
-    test('returns an explicitly non expanded element', () => {
-      render(
+    test('returns an explicitly non expanded element', async () => {
+      await render(
         <TouchableOpacity
           accessibilityRole="button"
           accessibilityState={{ expanded: false }}
@@ -696,8 +702,8 @@ describe('supports accessibility states', () => {
       expect(screen.queryByRole('button', { expanded: true })).toBe(null);
     });
 
-    test('does not return expanded elements when querying for non expanded', () => {
-      render(
+    test('does not return expanded elements when querying for non expanded', async () => {
+      await render(
         <TouchableOpacity
           accessibilityRole="button"
           accessibilityState={{ expanded: true }}
@@ -707,28 +713,28 @@ describe('supports accessibility states', () => {
       expect(screen.queryByRole('button', { expanded: false })).toBe(null);
     });
 
-    test('supports aria-expanded={true} prop', () => {
-      render(<View accessible accessibilityRole="button" aria-expanded={true} />);
+    test('supports aria-expanded={true} prop', async () => {
+      await render(<View accessible accessibilityRole="button" aria-expanded={true} />);
       expect(screen.getByRole('button', { expanded: true })).toBeTruthy();
       expect(screen.queryByRole('button', { expanded: false })).toBeNull();
     });
 
-    test('supports aria-expanded={false} prop', () => {
-      render(<View accessible accessibilityRole="button" aria-expanded={false} />);
+    test('supports aria-expanded={false} prop', async () => {
+      await render(<View accessible accessibilityRole="button" aria-expanded={false} />);
       expect(screen.getByRole('button', { expanded: false })).toBeTruthy();
       expect(screen.queryByRole('button', { expanded: true })).toBeNull();
     });
 
-    test('supports default aria-expanded prop', () => {
-      render(<View accessible accessibilityRole="button" />);
+    test('supports default aria-expanded prop', async () => {
+      await render(<View accessible accessibilityRole="button" />);
       expect(screen.getByRole('button')).toBeTruthy();
       expect(screen.queryByRole('button', { expanded: true })).toBeNull();
       expect(screen.queryByRole('button', { expanded: false })).toBeNull();
     });
   });
 
-  test('ignores non queried accessibilityState', () => {
-    render(
+  test('ignores non queried accessibilityState', async () => {
+    await render(
       <TouchableOpacity
         accessibilityRole="button"
         accessibilityState={{
@@ -755,8 +761,8 @@ describe('supports accessibility states', () => {
     ).toBe(null);
   });
 
-  test('matches an element combining all the options', () => {
-    render(
+  test('matches an element combining all the options', async () => {
+    await render(
       <TouchableOpacity
         accessibilityRole="checkbox"
         accessibilityState={{
@@ -785,8 +791,8 @@ describe('supports accessibility states', () => {
 });
 
 describe('error messages', () => {
-  test('gives a descriptive error message when querying with a role', () => {
-    render(<View />);
+  test('gives a descriptive error message when querying with a role', async () => {
+    await render(<View />);
 
     expect(() => screen.getByRole('button')).toThrowErrorMatchingInlineSnapshot(`
       "Unable to find an element with role: button
@@ -795,8 +801,8 @@ describe('error messages', () => {
     `);
   });
 
-  test('gives a descriptive error message when querying with a role and a name', () => {
-    render(<View />);
+  test('gives a descriptive error message when querying with a role and a name', async () => {
+    await render(<View />);
 
     expect(() => screen.getByRole('button', { name: 'Save' })).toThrowErrorMatchingInlineSnapshot(`
       "Unable to find an element with role: button, name: Save
@@ -805,8 +811,8 @@ describe('error messages', () => {
     `);
   });
 
-  test('gives a descriptive error message when querying with a role, a name and accessibility state', () => {
-    render(<View />);
+  test('gives a descriptive error message when querying with a role, a name and accessibility state', async () => {
+    await render(<View />);
 
     expect(() => screen.getByRole('button', { name: 'Save', disabled: true }))
       .toThrowErrorMatchingInlineSnapshot(`
@@ -816,8 +822,8 @@ describe('error messages', () => {
     `);
   });
 
-  test('gives a descriptive error message when querying with a role, a name and several accessibility state', () => {
-    render(<View />);
+  test('gives a descriptive error message when querying with a role, a name and several accessibility state', async () => {
+    await render(<View />);
 
     expect(() => screen.getByRole('button', { name: 'Save', disabled: true, selected: true }))
       .toThrowErrorMatchingInlineSnapshot(`
@@ -827,8 +833,8 @@ describe('error messages', () => {
     `);
   });
 
-  test('gives a descriptive error message when querying with a role and an accessibility state', () => {
-    render(<View />);
+  test('gives a descriptive error message when querying with a role and an accessibility state', async () => {
+    await render(<View />);
 
     expect(() => screen.getByRole('button', { disabled: true }))
       .toThrowErrorMatchingInlineSnapshot(`
@@ -838,8 +844,8 @@ describe('error messages', () => {
     `);
   });
 
-  test('gives a descriptive error message when querying with a role and an accessibility value', () => {
-    render(<View />);
+  test('gives a descriptive error message when querying with a role and an accessibility value', async () => {
+    await render(<View />);
 
     expect(() => screen.getByRole('adjustable', { value: { min: 1 } }))
       .toThrowErrorMatchingInlineSnapshot(`
@@ -860,8 +866,8 @@ describe('error messages', () => {
   });
 });
 
-test('byRole queries support hidden option', () => {
-  render(
+test('byRole queries support hidden option', async () => {
+  await render(
     <Pressable accessibilityRole="button" style={{ display: 'none' }}>
       <Text>Hidden from accessibility</Text>
     </Pressable>,
@@ -892,8 +898,8 @@ test('byRole queries support hidden option', () => {
 });
 
 describe('matches only accessible elements', () => {
-  test('matches elements with accessible={true}', () => {
-    render(
+  test('matches elements with accessible={true}', async () => {
+    await render(
       <View accessibilityRole="menu" accessible={true}>
         <Text>Action</Text>
       </View>,
@@ -901,8 +907,8 @@ describe('matches only accessible elements', () => {
     expect(screen.queryByRole('menu', { name: 'Action' })).toBeTruthy();
   });
 
-  test('ignores elements with accessible={false}', () => {
-    render(
+  test('ignores elements with accessible={false}', async () => {
+    await render(
       <Pressable accessibilityRole="button" accessible={false}>
         <Text>Action</Text>
       </Pressable>,
@@ -910,8 +916,8 @@ describe('matches only accessible elements', () => {
     expect(screen.queryByRole('button', { name: 'Action' })).toBeFalsy();
   });
 
-  test('ignores elements with accessible={undefined} and that are implicitly not accessible', () => {
-    render(
+  test('ignores elements with accessible={undefined} and that are implicitly not accessible', async () => {
+    await render(
       <View accessibilityRole="menu">
         <Text>Action</Text>
       </View>,
@@ -921,7 +927,7 @@ describe('matches only accessible elements', () => {
 });
 
 test('error message renders the element tree, preserving only helpful props', async () => {
-  render(<View accessibilityRole="button" key="3" />);
+  await render(<View accessibilityRole="button" key="3" />);
 
   expect(() => screen.getByRole('link')).toThrowErrorMatchingInlineSnapshot(`
     "Unable to find an element with role: link
diff --git a/src/queries/__tests__/test-id.test.tsx b/src/queries/__tests__/test-id.test.tsx
index 79377ce57..e49fa54b6 100644
--- a/src/queries/__tests__/test-id.test.tsx
+++ b/src/queries/__tests__/test-id.test.tsx
@@ -25,8 +25,8 @@ const Banana = () => (
 
 const MyComponent = (_props: { testID?: string }) => <Text>My Component</Text>;
 
-test('getByTestId returns only native elements', () => {
-  render(
+test('getByTestId returns only native elements', async () => {
+  await render(
     <View>
       <Text testID="text">Text</Text>
       <TextInput testID="textInput" />
@@ -54,8 +54,8 @@ test('getByTestId returns only native elements', () => {
   );
 });
 
-test('supports a regex matcher', () => {
-  render(
+test('supports a regex matcher', async () => {
+  await render(
     <View>
       <Text testID="text">Text</Text>
       <TextInput testID="textInput" />
@@ -69,8 +69,8 @@ test('supports a regex matcher', () => {
   expect(screen.getAllByTestId(/text/)).toHaveLength(2);
 });
 
-test('getByTestId, queryByTestId', () => {
-  render(<Banana />);
+test('getByTestId, queryByTestId', async () => {
+  await render(<Banana />);
   const component = screen.getByTestId('bananaFresh');
 
   expect(component.props.children).toBe('not fresh');
@@ -89,8 +89,8 @@ test('getByTestId, queryByTestId', () => {
   );
 });
 
-test('getAllByTestId, queryAllByTestId', () => {
-  render(<Banana />);
+test('getAllByTestId, queryAllByTestId', async () => {
+  await render(<Banana />);
   const textElements = screen.getAllByTestId('duplicateText');
 
   expect(textElements.length).toBe(2);
@@ -110,7 +110,7 @@ test('getAllByTestId, queryAllByTestId', () => {
 
 test('findByTestId and findAllByTestId work asynchronously', async () => {
   const options = { timeout: 10 }; // Short timeout so that this test runs quickly
-  render(<View />);
+  await render(<View />);
   await expect(screen.findByTestId('aTestId', {}, options)).rejects.toBeTruthy();
   await expect(screen.findAllByTestId('aTestId', {}, options)).rejects.toBeTruthy();
 
@@ -130,8 +130,8 @@ test('findByTestId and findAllByTestId work asynchronously', async () => {
   await expect(screen.findAllByTestId('aTestId')).resolves.toHaveLength(1);
 }, 20000);
 
-test('byTestId queries support hidden option', () => {
-  render(
+test('byTestId queries support hidden option', async () => {
+  await render(
     <Text style={{ display: 'none' }} testID="hidden">
       Hidden from accessibility
     </Text>,
@@ -159,7 +159,7 @@ test('byTestId queries support hidden option', () => {
 });
 
 test('error message renders the element tree, preserving only helpful props', async () => {
-  render(<View testID="TEST_ID" key="3" />);
+  await render(<View testID="TEST_ID" key="3" />);
 
   expect(() => screen.getByTestId('FOO')).toThrowErrorMatchingInlineSnapshot(`
     "Unable to find an element with testID: FOO
diff --git a/src/queries/__tests__/text.test.tsx b/src/queries/__tests__/text.test.tsx
index 0dda7578d..28a3b16bc 100644
--- a/src/queries/__tests__/text.test.tsx
+++ b/src/queries/__tests__/text.test.tsx
@@ -3,13 +3,13 @@ import { Button, Image, Text, TextInput, TouchableOpacity, View } from 'react-na
 
 import { getDefaultNormalizer, render, screen, within } from '../..';
 
-test('byText matches simple text', () => {
-  render(<Text testID="text">Hello World</Text>);
+test('byText matches simple text', async () => {
+  await render(<Text testID="text">Hello World</Text>);
   expect(screen.getByText('Hello World').props.testID).toBe('text');
 });
 
-test('byText matches inner nested text', () => {
-  render(
+test('byText matches inner nested text', async () => {
+  await render(
     <Text testID="outer">
       <Text testID="inner">Hello World</Text>
     </Text>,
@@ -17,8 +17,8 @@ test('byText matches inner nested text', () => {
   expect(screen.getByText('Hello World').props.testID).toBe('inner');
 });
 
-test('byText matches accross multiple texts', () => {
-  render(
+test('byText matches accross multiple texts', async () => {
+  await render(
     <Text testID="outer">
       <Text testID="inner-1">Hello</Text> <Text testID="inner-2">World</Text>
     </Text>,
@@ -53,8 +53,8 @@ const Banana = () => {
 
 type ChildrenProps = { children: React.ReactNode };
 
-test('getByText, queryByText', () => {
-  render(<Banana />);
+test('getByText, queryByText', async () => {
+  await render(<Banana />);
   const button = screen.getByText(/change/i);
 
   expect(button.props.children).toBe('Change freshness!');
@@ -74,7 +74,7 @@ test('getByText, queryByText', () => {
   expect(screen.queryByText('0')).toBe(zeroText);
 });
 
-test('getByText, screen.queryByText with children as Array', () => {
+test('getByText, screen.queryByText with children as Array', async () => {
   type BananaCounterProps = { numBananas: number };
   const BananaCounter = ({ numBananas }: BananaCounterProps) => (
     <Text>There are {numBananas} bananas in the bunch</Text>
@@ -88,14 +88,14 @@ test('getByText, screen.queryByText with children as Array', () => {
     </View>
   );
 
-  render(<BananaStore />);
+  await render(<BananaStore />);
 
   const threeBananaBunch = screen.getByText('There are 3 bananas in the bunch');
   expect(threeBananaBunch.props.children).toEqual(['There are ', 3, ' bananas in the bunch']);
 });
 
-test('getAllByText, queryAllByText', () => {
-  render(<Banana />);
+test('getAllByText, queryAllByText', async () => {
+  await render(<Banana />);
   const buttons = screen.getAllByText(/fresh/i);
 
   expect(buttons).toHaveLength(3);
@@ -109,7 +109,7 @@ test('getAllByText, queryAllByText', () => {
 
 test('findByText queries work asynchronously', async () => {
   const options = { timeout: 10 }; // Short timeout so that this test runs quickly
-  render(<View />);
+  await render(<View />);
   await expect(screen.findByText('Some Text', {}, options)).rejects.toBeTruthy();
   await expect(screen.findAllByText('Some Text', {}, options)).rejects.toBeTruthy();
 
@@ -127,21 +127,23 @@ test('findByText queries work asynchronously', async () => {
   await expect(screen.findAllByText('Some Text')).resolves.toHaveLength(1);
 }, 20000);
 
-test('getByText works properly with custom text component', () => {
+test('getByText works properly with custom text component', async () => {
   function BoldText({ children }: ChildrenProps) {
     return <Text>{children}</Text>;
   }
 
   expect(
-    render(
-      <Text>
-        <BoldText>Hello</BoldText>
-      </Text>,
+    (
+      await render(
+        <Text>
+          <BoldText>Hello</BoldText>
+        </Text>,
+      )
     ).getByText('Hello'),
   ).toBeTruthy();
 });
 
-test('getByText works properly with custom text container', () => {
+test('getByText works properly with custom text container', async () => {
   function MyText({ children }: ChildrenProps) {
     return <Text>{children}</Text>;
   }
@@ -151,61 +153,71 @@ test('getByText works properly with custom text container', () => {
   }
 
   expect(
-    render(
-      <MyText>
-        <BoldText>Hello</BoldText>
-      </MyText>,
+    (
+      await render(
+        <MyText>
+          <BoldText>Hello</BoldText>
+        </MyText>,
+      )
     ).getByText('Hello'),
   ).toBeTruthy();
 });
 
-test('queryByText nested <Image> in <Text> at start', () => {
+test('queryByText nested <Image> in <Text> at start', async () => {
   expect(
-    render(
-      <Text>
-        <Image source={{}} />
-        Hello
-      </Text>,
+    (
+      await render(
+        <Text>
+          <Image source={{}} />
+          Hello
+        </Text>,
+      )
     ).queryByText('Hello'),
   ).toBeTruthy();
 });
 
-test('queryByText nested <Image> in <Text> at end', () => {
+test('queryByText nested <Image> in <Text> at end', async () => {
   expect(
-    render(
-      <Text>
-        Hello
-        <Image source={{}} />
-      </Text>,
+    (
+      await render(
+        <Text>
+          Hello
+          <Image source={{}} />
+        </Text>,
+      )
     ).queryByText('Hello'),
   ).toBeTruthy();
 });
 
-test('queryByText nested <Image> in <Text> in middle', () => {
+test('queryByText nested <Image> in <Text> in middle', async () => {
   expect(
-    render(
-      <Text>
-        Hello
-        <Image source={{}} />
-        World
-      </Text>,
+    (
+      await render(
+        <Text>
+          Hello
+          <Image source={{}} />
+          World
+        </Text>,
+      )
     ).queryByText('HelloWorld'),
   ).toBeTruthy();
 });
 
-test('queryByText not found', () => {
+test('queryByText not found', async () => {
   expect(
-    render(
-      <Text>
-        Hello
-        <Image source={{}} />
-      </Text>,
+    (
+      await render(
+        <Text>
+          Hello
+          <Image source={{}} />
+        </Text>,
+      )
     ).queryByText('SomethingElse'),
   ).toBeFalsy();
 });
 
-test('*ByText matches text across multiple nested Text', () => {
-  render(
+test('*ByText matches text across multiple nested Text', async () => {
+  await render(
     <Text nativeID="1">
       Hello{' '}
       <Text nativeID="2">
@@ -218,18 +230,18 @@ test('*ByText matches text across multiple nested Text', () => {
   expect(screen.getByText('Hello World!')).toBeTruthy();
 });
 
-test('queryByText with nested Text components return the closest Text', () => {
+test('queryByText with nested Text components return the closest Text', async () => {
   const NestedTexts = () => (
     <Text nativeID="1">
       <Text nativeID="2">My text</Text>
     </Text>
   );
 
-  render(<NestedTexts />);
+  await render(<NestedTexts />);
   expect(screen.queryByText('My text', { exact: false })?.props.nativeID).toBe('2');
 });
 
-test('queryByText with nested Text components each with text return the lowest one', () => {
+test('queryByText with nested Text components each with text return the lowest one', async () => {
   const NestedTexts = () => (
     <Text nativeID="1">
       bob
@@ -237,27 +249,29 @@ test('queryByText with nested Text components each with text return the lowest o
     </Text>
   );
 
-  render(<NestedTexts />);
+  await render(<NestedTexts />);
 
   expect(screen.queryByText('My text', { exact: false })?.props.nativeID).toBe('2');
 });
 
-test('queryByText nested deep <CustomText> in <Text>', () => {
+test('queryByText nested deep <CustomText> in <Text>', async () => {
   const CustomText = ({ children }: ChildrenProps) => {
     return <Text>{children}</Text>;
   };
 
   expect(
-    render(
-      <Text>
-        <CustomText>Hello</CustomText> <CustomText>World!</CustomText>
-      </Text>,
+    (
+      await render(
+        <Text>
+          <CustomText>Hello</CustomText> <CustomText>World!</CustomText>
+        </Text>,
+      )
     ).getByText('Hello World!'),
   ).toBeTruthy();
 });
 
-test('queryByText with nested Text components: not-exact text match returns the most deeply nested common component', () => {
-  render(
+test('queryByText with nested Text components: not-exact text match returns the most deeply nested common component', async () => {
+  await render(
     <Text nativeID="1">
       bob
       <Text nativeID="2">My </Text>
@@ -265,7 +279,7 @@ test('queryByText with nested Text components: not-exact text match returns the
     </Text>,
   );
 
-  render(
+  await render(
     <Text nativeID="1">
       bob
       <Text nativeID="2">My text for test</Text>
@@ -276,32 +290,36 @@ test('queryByText with nested Text components: not-exact text match returns the
   expect(screen.queryByText('My text', { exact: false })?.props.nativeID).toBe('2');
 });
 
-test('queryAllByText does not match several times the same text', () => {
-  const allMatched = render(
-    <Text nativeID="1">
-      Start
-      <Text nativeID="2">This is a long text</Text>
-    </Text>,
+test('queryAllByText does not match several times the same text', async () => {
+  const allMatched = (
+    await render(
+      <Text nativeID="1">
+        Start
+        <Text nativeID="2">This is a long text</Text>
+      </Text>,
+    )
   ).queryAllByText('long text', { exact: false });
   expect(allMatched.length).toBe(1);
   expect(allMatched[0].props.nativeID).toBe('2');
 });
 
-test('queryAllByText matches all the matching nodes', () => {
-  const allMatched = render(
-    <Text nativeID="1">
-      Start
-      <Text nativeID="2">This is a long text</Text>
-      <Text nativeID="3">This is another long text</Text>
-    </Text>,
+test('queryAllByText matches all the matching nodes', async () => {
+  const allMatched = (
+    await render(
+      <Text nativeID="1">
+        Start
+        <Text nativeID="2">This is a long text</Text>
+        <Text nativeID="3">This is another long text</Text>
+      </Text>,
+    )
   ).queryAllByText('long text', { exact: false });
   expect(allMatched.length).toBe(2);
   expect(allMatched.map((node) => node.props.nativeID)).toEqual(['2', '3']);
 });
 
 describe('supports TextMatch options', () => {
-  test('getByText, getAllByText', () => {
-    render(
+  test('getByText, getAllByText', async () => {
+    await render(
       <View>
         <Text testID="text">Text and details</Text>
         <Button testID="button" title="Button and a detail" onPress={jest.fn()} />
@@ -312,8 +330,8 @@ describe('supports TextMatch options', () => {
     expect(screen.getAllByText('detail', { exact: false })).toHaveLength(2);
   });
 
-  test('getByPlaceholderText, getAllByPlaceholderText', () => {
-    render(
+  test('getByPlaceholderText, getAllByPlaceholderText', async () => {
+    await render(
       <View>
         <TextInput placeholder={'Placeholder with details'} />
         <TextInput placeholder={'Placeholder with a DETAIL'} />
@@ -324,8 +342,8 @@ describe('supports TextMatch options', () => {
     expect(screen.getAllByPlaceholderText('detail', { exact: false })).toHaveLength(2);
   });
 
-  test('getByDisplayValue, getAllByDisplayValue', () => {
-    render(
+  test('getByDisplayValue, getAllByDisplayValue', async () => {
+    await render(
       <View>
         <TextInput value={'Value with details'} />
         <TextInput value={'Value with a detail'} />
@@ -336,8 +354,8 @@ describe('supports TextMatch options', () => {
     expect(screen.getAllByDisplayValue('detail', { exact: false })).toHaveLength(2);
   });
 
-  test('getByTestId, getAllByTestId', () => {
-    render(
+  test('getByTestId, getAllByTestId', async () => {
+    await render(
       <View>
         <View testID="test" />
         <View testID="tests id" />
@@ -347,8 +365,8 @@ describe('supports TextMatch options', () => {
     expect(screen.getAllByTestId('test', { exact: false })).toHaveLength(2);
   });
 
-  test('with TextMatch option exact === false text search is NOT case sensitive', () => {
-    render(
+  test('with TextMatch option exact === false text search is NOT case sensitive', async () => {
+    await render(
       <View>
         <Text testID="text">Text and details</Text>
         <Button testID="button" title="Button and a DeTAil" onPress={jest.fn()} />
@@ -361,8 +379,8 @@ describe('supports TextMatch options', () => {
 });
 
 describe('Supports normalization', () => {
-  test('trims and collapses whitespace by default', () => {
-    render(
+  test('trims and collapses whitespace by default', async () => {
+    await render(
       <View>
         <Text>{`  Text     and
 
@@ -373,11 +391,11 @@ describe('Supports normalization', () => {
     expect(screen.getByText('Text and whitespace')).toBeTruthy();
   });
 
-  test('trim and collapseWhitespace is customizable by getDefaultNormalizer param', () => {
+  test('trim and collapseWhitespace is customizable by getDefaultNormalizer param', async () => {
     const testTextWithWhitespace = `  Text     and
 
         whitespace`;
-    render(
+    await render(
       <View>
         <Text>{testTextWithWhitespace}</Text>
       </View>,
@@ -393,10 +411,10 @@ describe('Supports normalization', () => {
     ).toBeTruthy();
   });
 
-  test('normalizer function is customisable', () => {
+  test('normalizer function is customisable', async () => {
     const testText = 'A TO REMOVE text';
     const normalizerFn = (textToNormalize: string) => textToNormalize.replace('TO REMOVE ', '');
-    render(
+    await render(
       <View>
         <Text>{testText}</Text>
       </View>,
@@ -406,8 +424,8 @@ describe('Supports normalization', () => {
   });
 });
 
-test('getByText and queryByText work properly with text nested in React.Fragment', () => {
-  render(
+test('getByText and queryByText work properly with text nested in React.Fragment', async () => {
+  await render(
     <Text>
       <>Hello</>
     </Text>,
@@ -416,8 +434,8 @@ test('getByText and queryByText work properly with text nested in React.Fragment
   expect(screen.queryByText('Hello')).not.toBeNull();
 });
 
-test('getByText and queryByText work properly with text partially nested in React.Fragment', () => {
-  render(
+test('getByText and queryByText work properly with text partially nested in React.Fragment', async () => {
+  await render(
     <Text>
       He<>llo</>
     </Text>,
@@ -426,8 +444,8 @@ test('getByText and queryByText work properly with text partially nested in Reac
   expect(screen.queryByText('Hello')).not.toBeNull();
 });
 
-test('getByText and queryByText work properly with multiple nested fragments', () => {
-  render(
+test('getByText and queryByText work properly with multiple nested fragments', async () => {
+  await render(
     <Text>
       He
       <>
@@ -439,28 +457,28 @@ test('getByText and queryByText work properly with multiple nested fragments', (
   expect(screen.queryByText('Hello')).not.toBeNull();
 });
 
-test('getByText and queryByText work with newlines', () => {
+test('getByText and queryByText work with newlines', async () => {
   const textWithNewLines = 'Line 1\nLine 2';
-  render(<Text>{textWithNewLines}</Text>);
+  await render(<Text>{textWithNewLines}</Text>);
   expect(screen.getByText(textWithNewLines)).toBeTruthy();
   expect(screen.queryByText(textWithNewLines)).toBeTruthy();
 });
 
-test('getByText and queryByText work with tabs', () => {
+test('getByText and queryByText work with tabs', async () => {
   const textWithTabs = 'Line 1\tLine 2';
-  render(<Text>{textWithTabs}</Text>);
+  await render(<Text>{textWithTabs}</Text>);
   expect(screen.getByText(textWithTabs)).toBeTruthy();
   expect(screen.queryByText(textWithTabs)).toBeTruthy();
 });
 
-test('getByText does not search for text within itself', () => {
-  render(<Text testID="subject">Hello</Text>);
+test('getByText does not search for text within itself', async () => {
+  await render(<Text testID="subject">Hello</Text>);
   const textNode = within(screen.getByText('Hello'));
   expect(textNode.queryByText('Hello')).toBeNull();
 });
 
-test('byText support hidden option', () => {
-  render(<Text style={{ display: 'none' }}>Hidden from accessibility</Text>);
+test('byText support hidden option', async () => {
+  await render(<Text style={{ display: 'none' }}>Hidden from accessibility</Text>);
 
   expect(screen.getByText(/hidden/i, { includeHiddenElements: true })).toBeTruthy();
 
@@ -483,7 +501,7 @@ test('byText support hidden option', () => {
 });
 
 test('error message renders the element tree, preserving only helpful props', async () => {
-  render(<View accessibilityViewIsModal key="this is filtered" />);
+  await render(<View accessibilityViewIsModal key="this is filtered" />);
 
   expect(() => screen.getByText(/foo/)).toThrowErrorMatchingInlineSnapshot(`
     "Unable to find an element with text: /foo/
@@ -518,7 +536,7 @@ test('error message renders the element tree, preserving only helpful props', as
   `);
 });
 
-test('byText should return host component', () => {
-  render(<Text>hello</Text>);
+test('byText should return host component', async () => {
+  await render(<Text>hello</Text>);
   expect(screen.getByText('hello').type).toBe('Text');
 });
diff --git a/src/queries/make-queries.ts b/src/queries/make-queries.ts
index 7aba2d35a..fa2868fc5 100644
--- a/src/queries/make-queries.ts
+++ b/src/queries/make-queries.ts
@@ -5,7 +5,7 @@ import { formatJson } from '../helpers/format-element';
 import { logger } from '../helpers/logger';
 import { screen } from '../screen';
 import type { WaitForOptions } from '../wait-for';
-import waitFor from '../wait-for';
+import { waitFor } from '../wait-for';
 
 export type GetByQuery<Predicate, Options = void> = (
   predicate: Predicate,
diff --git a/src/render-hook.tsx b/src/render-hook.tsx
index 2aaa18dfd..b04e61dae 100644
--- a/src/render-hook.tsx
+++ b/src/render-hook.tsx
@@ -1,8 +1,8 @@
 import * as React from 'react';
 
-import render from './render';
-import renderAsync from './render-async';
+import { render } from './render';
 import type { RefObject } from './types';
+import { unsafe_renderSync } from './unsafe-render-sync';
 
 export type RenderHookResult<Result, Props> = {
   result: RefObject<Result>;
@@ -47,21 +47,21 @@ export async function renderHook<Result, Props>(
   }
 
   const { initialProps, ...renderOptions } = options ?? {};
-  const { rerenderAsync: rerenderComponentAsync, unmountAsync } = await renderAsync(
-    // @ts-expect-error since option can be undefined, initialProps can be undefined when it should'nt
+  const { rerender: rerenderComponent, unmount } = await render(
+    // @ts-expect-error since option can be undefined, initialProps can be undefined when it shouldn't be
     <HookContainer hookProps={initialProps} />,
     renderOptions,
   );
 
   return {
     result: result,
-    rerender: (hookProps: Props) => rerenderComponentAsync(<HookContainer hookProps={hookProps} />),
-    unmount: unmountAsync,
+    rerender: (hookProps: Props) => rerenderComponent(<HookContainer hookProps={hookProps} />),
+    unmount,
   };
 }
 
 /** @deprecated - Use async `renderHook` instead.   */
-export function deprecated_renderHookSync<Result, Props>(
+export function unsafe_renderHookSync<Result, Props>(
   hookToRender: (props: Props) => Result,
   options?: RenderHookOptions<NoInfer<Props>>,
 ): RenderHookSyncResult<Result, Props> {
@@ -77,7 +77,7 @@ export function deprecated_renderHookSync<Result, Props>(
   }
 
   const { initialProps, ...renderOptions } = options ?? {};
-  const { rerender: rerenderComponent, unmount } = render(
+  const { rerender: rerenderComponent, unmount } = unsafe_renderSync(
     // @ts-expect-error since option can be undefined, initialProps can be undefined when it should'nt
     <HookContainer hookProps={initialProps} />,
     renderOptions,
diff --git a/src/render.tsx b/src/render.tsx
index 9944904ff..cedff3e2a 100644
--- a/src/render.tsx
+++ b/src/render.tsx
@@ -6,7 +6,8 @@ import { addToCleanupQueue } from './cleanup';
 import { getConfig } from './config';
 import type { DebugOptions } from './helpers/debug';
 import { debug } from './helpers/debug';
-import { renderWithAct } from './render-act';
+import { HOST_TEXT_NAMES } from './helpers/host-component-names';
+import { renderWithAsyncAct } from './render-act';
 import { setRenderResult } from './screen';
 import { getQueriesForElement } from './within';
 
@@ -18,27 +19,25 @@ export interface RenderOptions {
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   wrapper?: React.ComponentType<any>;
 
-  createNodeMock?: (element: React.ReactElement) => unknown;
+  createNodeMock?: (element: React.ReactElement) => object;
 }
 
-export type RenderResult = ReturnType<typeof render>;
+export type RenderResult = Awaited<ReturnType<typeof render>>;
 
 /**
  * Renders test component deeply using React Test Renderer and exposes helpers
  * to assert on the output.
  */
-export default function render<T>(component: React.ReactElement<T>, options: RenderOptions = {}) {
-  return renderInternal(component, options);
-}
-
-export function renderInternal<T>(component: React.ReactElement<T>, options?: RenderOptions) {
-  const { wrapper: Wrapper } = options || {};
+export async function render<T>(component: React.ReactElement<T>, options: RenderOptions = {}) {
+  const { wrapper: Wrapper, createNodeMock } = options || {};
 
-  // TODO allow passing some options
-  const rendererOptions: RootOptions = {};
+  const rendererOptions: RootOptions = {
+    textComponents: HOST_TEXT_NAMES,
+    createNodeMock,
+  };
 
   const wrap = (element: React.ReactElement) => (Wrapper ? <Wrapper>{element}</Wrapper> : element);
-  const renderer = renderWithAct(wrap(component), rendererOptions);
+  const renderer = await renderWithAsyncAct(wrap(component), rendererOptions);
   return buildRenderResult(renderer, wrap);
 }
 
@@ -46,24 +45,16 @@ function buildRenderResult(
   renderer: Root,
   wrap: (element: React.ReactElement) => React.JSX.Element,
 ) {
-  const rerender = (component: React.ReactElement) => {
-    void act(() => {
-      renderer.render(wrap(component));
-    });
-  };
-  const rerenderAsync = async (component: React.ReactElement) => {
+  const container = renderer.container;
+
+  const rerender = async (component: React.ReactElement) => {
     // eslint-disable-next-line require-await
     await act(async () => {
       renderer.render(wrap(component));
     });
   };
 
-  const unmount = () => {
-    void act(() => {
-      renderer.unmount();
-    });
-  };
-  const unmountAsync = async () => {
+  const unmount = async () => {
     // eslint-disable-next-line require-await
     await act(async () => {
       renderer.unmount();
@@ -83,23 +74,20 @@ function buildRenderResult(
     return json;
   };
 
-  addToCleanupQueue(unmountAsync);
+  addToCleanupQueue(unmount);
 
   const result = {
     ...getQueriesForElement(renderer.container),
     rerender,
-    rerenderAsync,
-    update: rerender, // alias for 'rerender'
-    updateAsync: rerenderAsync, // alias for `rerenderAsync`
+    update: rerender, // alias for `rerender`
     unmount,
-    unmountAsync,
     toJSON,
     debug: makeDebug(renderer),
     get container(): HostElement {
       return renderer.container;
     },
     get root(): HostElement | null {
-      const firstChild = renderer.container.children[0];
+      const firstChild = container.children[0];
       if (typeof firstChild === 'string') {
         throw new Error(
           'Invariant Violation: Root element must be a host element. Detected attempt to render a string within the root element.',
diff --git a/src/screen.ts b/src/screen.ts
index fb3a01932..1fa86787a 100644
--- a/src/screen.ts
+++ b/src/screen.ts
@@ -2,7 +2,7 @@ import type { HostElement } from 'universal-test-renderer';
 
 import type { RenderResult } from './render';
 
-const SCREEN_ERROR = '`render` method has not been called';
+const SCREEN_ERROR = '`render` function has not been called';
 
 const notImplemented = () => {
   throw new Error(SCREEN_ERROR);
@@ -22,11 +22,8 @@ const defaultScreen: Screen = {
   },
   debug: notImplemented,
   rerender: notImplemented,
-  rerenderAsync: notImplemented,
   update: notImplemented,
-  updateAsync: notImplemented,
   unmount: notImplemented,
-  unmountAsync: notImplemented,
   toJSON: notImplemented,
   getByLabelText: notImplemented,
   getAllByLabelText: notImplemented,
diff --git a/src/render-async.tsx b/src/unsafe-render-sync.tsx
similarity index 59%
rename from src/render-async.tsx
rename to src/unsafe-render-sync.tsx
index 5ac031706..4b7959c55 100644
--- a/src/render-async.tsx
+++ b/src/unsafe-render-sync.tsx
@@ -1,17 +1,17 @@
 import * as React from 'react';
-import type { HostElement, Root, RootOptions } from 'universal-test-renderer';
+import type { HostElement, JsonElement, Root, RootOptions } from 'universal-test-renderer';
 
 import act from './act';
 import { addToCleanupQueue } from './cleanup';
 import { getConfig } from './config';
 import type { DebugOptions } from './helpers/debug';
 import { debug } from './helpers/debug';
-import { ErrorWithStack } from './helpers/errors';
-import { renderWithAsyncAct } from './render-act';
+import { HOST_TEXT_NAMES } from './helpers/host-component-names';
+import { renderWithAct } from './render-act';
 import { setRenderResult } from './screen';
 import { getQueriesForElement } from './within';
 
-export interface RenderAsyncOptions {
+export interface RenderSyncOptions {
   /**
    * Pass a React Component as the wrapper option to have it rendered around the inner element. This is most useful for creating
    * reusable custom render functions for common data providers.
@@ -19,26 +19,33 @@ export interface RenderAsyncOptions {
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   wrapper?: React.ComponentType<any>;
 
-  createNodeMock?: (element: React.ReactElement) => unknown;
+  createNodeMock?: (element: React.ReactElement) => object;
 }
 
-export type RenderAsyncResult = ReturnType<typeof renderAsync>;
-
 /**
+ * @deprecated Use `render` (async) instead. This function is provided for migration purposes only.
  * Renders test component deeply using React Test Renderer and exposes helpers
  * to assert on the output.
  */
-export default async function renderAsync<T>(
+export function unsafe_renderSync<T>(
   component: React.ReactElement<T>,
-  options: RenderAsyncOptions = {},
+  options: RenderSyncOptions = {},
 ) {
-  const { wrapper: Wrapper } = options || {};
+  return renderInternal(component, options);
+}
+
+export type RenderSyncResult = ReturnType<typeof unsafe_renderSync>;
 
-  // TODO allow passing some options
-  const rendererOptions: RootOptions = {};
+export function renderInternal<T>(component: React.ReactElement<T>, options?: RenderSyncOptions) {
+  const { wrapper: Wrapper, createNodeMock } = options || {};
+
+  const rendererOptions: RootOptions = {
+    textComponents: HOST_TEXT_NAMES,
+    createNodeMock,
+  };
 
   const wrap = (element: React.ReactElement) => (Wrapper ? <Wrapper>{element}</Wrapper> : element);
-  const renderer = await renderWithAsyncAct(wrap(component), rendererOptions);
+  const renderer = renderWithAct(wrap(component), rendererOptions);
   return buildRenderResult(renderer, wrap);
 }
 
@@ -46,14 +53,12 @@ function buildRenderResult(
   renderer: Root,
   wrap: (element: React.ReactElement) => React.JSX.Element,
 ) {
-  const container = renderer.container;
-
-  const rerender = (_component: React.ReactElement) => {
-    throw new ErrorWithStack(
-      '"rerender(...)" is not supported when using "renderAsync" use "await rerenderAsync(...)" instead',
-      rerender,
-    );
+  const rerender = (component: React.ReactElement) => {
+    void act(() => {
+      renderer.render(wrap(component));
+    });
   };
+
   const rerenderAsync = async (component: React.ReactElement) => {
     // eslint-disable-next-line require-await
     await act(async () => {
@@ -62,11 +67,11 @@ function buildRenderResult(
   };
 
   const unmount = () => {
-    throw new ErrorWithStack(
-      '"unmount()" is not supported when using "renderAsync" use "await unmountAsync()" instead',
-      unmount,
-    );
+    void act(() => {
+      renderer.unmount();
+    });
   };
+
   const unmountAsync = async () => {
     // eslint-disable-next-line require-await
     await act(async () => {
@@ -74,23 +79,33 @@ function buildRenderResult(
     });
   };
 
+  const toJSON = (): JsonElement | null => {
+    const json = renderer.container.toJSON();
+    if (json?.children?.length === 0) {
+      return null;
+    }
+
+    if (json?.children?.length === 1 && typeof json.children[0] !== 'string') {
+      return json.children[0];
+    }
+
+    return json;
+  };
+
   addToCleanupQueue(unmountAsync);
 
   const result = {
     ...getQueriesForElement(renderer.container),
     rerender,
-    rerenderAsync,
-    update: rerender, // alias for `rerender`
-    updateAsync: rerenderAsync, // alias for `rerenderAsync`
+    update: rerender, // alias for 'rerender'
     unmount,
-    unmountAsync,
-    toJSON: () => renderer.container.toJSON(),
+    toJSON,
     debug: makeDebug(renderer),
     get container(): HostElement {
       return renderer.container;
     },
     get root(): HostElement | null {
-      const firstChild = container.children[0];
+      const firstChild = renderer.container.children[0];
       if (typeof firstChild === 'string') {
         throw new Error(
           'Invariant Violation: Root element must be a host element. Detected attempt to render a string within the root element.',
@@ -101,7 +116,12 @@ function buildRenderResult(
     },
   };
 
-  setRenderResult(result);
+  setRenderResult({
+    ...result,
+    rerender: rerenderAsync,
+    update: rerenderAsync,
+    unmount: unmountAsync,
+  });
 
   return result;
 }
diff --git a/src/user-event/__tests__/clear.test.tsx b/src/user-event/__tests__/clear.test.tsx
index 712e73dfe..ecfeac203 100644
--- a/src/user-event/__tests__/clear.test.tsx
+++ b/src/user-event/__tests__/clear.test.tsx
@@ -9,10 +9,10 @@ beforeEach(() => {
   jest.useRealTimers();
 });
 
-function renderTextInputWithToolkit(props: TextInputProps = {}) {
+async function renderTextInputWithToolkit(props: TextInputProps = {}) {
   const { events, logEvent } = createEventLogger();
 
-  render(
+  await render(
     <TextInput
       testID="input"
       onFocus={logEvent('focus')}
@@ -41,7 +41,7 @@ function renderTextInputWithToolkit(props: TextInputProps = {}) {
 describe('clear()', () => {
   it('supports basic case', async () => {
     jest.spyOn(Date, 'now').mockImplementation(() => 100100100100);
-    const { textInput, events } = renderTextInputWithToolkit({
+    const { textInput, events } = await renderTextInputWithToolkit({
       value: 'Hello!',
     });
 
@@ -64,7 +64,7 @@ describe('clear()', () => {
 
   it.each(['modern', 'legacy'])('works with %s fake timers', async (type) => {
     jest.useFakeTimers({ legacyFakeTimers: type === 'legacy' });
-    const { textInput, events } = renderTextInputWithToolkit({
+    const { textInput, events } = await renderTextInputWithToolkit({
       value: 'Hello!',
     });
 
@@ -84,7 +84,7 @@ describe('clear()', () => {
   });
 
   it('supports defaultValue prop', async () => {
-    const { textInput, events } = renderTextInputWithToolkit({
+    const { textInput, events } = await renderTextInputWithToolkit({
       defaultValue: 'Hello Default!',
     });
 
@@ -106,7 +106,7 @@ describe('clear()', () => {
   });
 
   it('does respect editable prop', async () => {
-    const { textInput } = renderTextInputWithToolkit({
+    const { textInput } = await renderTextInputWithToolkit({
       value: 'Hello!',
       editable: false,
     });
@@ -118,7 +118,7 @@ describe('clear()', () => {
   });
 
   it('does respect pointer-events prop', async () => {
-    const { textInput } = renderTextInputWithToolkit({
+    const { textInput } = await renderTextInputWithToolkit({
       value: 'Hello!',
       pointerEvents: 'none',
     });
@@ -130,7 +130,7 @@ describe('clear()', () => {
   });
 
   it('supports multiline', async () => {
-    const { textInput, events } = renderTextInputWithToolkit({
+    const { textInput, events } = await renderTextInputWithToolkit({
       value: 'Hello World!\nHow are you?',
       multiline: true,
     });
@@ -155,7 +155,7 @@ describe('clear()', () => {
 
   it('works when not all events have handlers', async () => {
     const { events, logEvent } = createEventLogger();
-    render(
+    await render(
       <TextInput
         testID="input"
         onChangeText={logEvent('changeText')}
@@ -172,7 +172,7 @@ describe('clear()', () => {
   });
 
   it('does NOT work on View', async () => {
-    render(<View testID="input" />);
+    await render(<View testID="input" />);
 
     const user = userEvent.setup();
     await expect(
@@ -187,7 +187,7 @@ describe('clear()', () => {
 
   it('does NOT bubble up', async () => {
     const parentHandler = jest.fn();
-    render(
+    await render(
       <AnyView
         onChangeText={parentHandler}
         onChange={parentHandler}
@@ -209,7 +209,7 @@ describe('clear()', () => {
   });
 
   it('sets native state value for unmanaged text inputs', async () => {
-    render(<TextInput testID="input" />);
+    await render(<TextInput testID="input" />);
 
     const user = userEvent.setup();
     const input = screen.getByTestId('input');
diff --git a/src/user-event/__tests__/paste.test.tsx b/src/user-event/__tests__/paste.test.tsx
index cf254a1ad..47534f39e 100644
--- a/src/user-event/__tests__/paste.test.tsx
+++ b/src/user-event/__tests__/paste.test.tsx
@@ -9,10 +9,10 @@ beforeEach(() => {
   jest.useRealTimers();
 });
 
-function renderTextInputWithToolkit(props: TextInputProps = {}) {
+async function renderTextInputWithToolkit(props: TextInputProps = {}) {
   const { events, logEvent } = createEventLogger();
 
-  render(
+  await render(
     <TextInput
       testID="input"
       onFocus={logEvent('focus')}
@@ -41,7 +41,7 @@ function renderTextInputWithToolkit(props: TextInputProps = {}) {
 describe('paste()', () => {
   it('paste on empty text input', async () => {
     jest.spyOn(Date, 'now').mockImplementation(() => 100100100100);
-    const { textInput, events } = renderTextInputWithToolkit();
+    const { textInput, events } = await renderTextInputWithToolkit();
 
     const user = userEvent.setup();
     await user.paste(textInput, 'Hi!');
@@ -61,7 +61,7 @@ describe('paste()', () => {
 
   it('paste on filled text input', async () => {
     jest.spyOn(Date, 'now').mockImplementation(() => 100100100100);
-    const { textInput, events } = renderTextInputWithToolkit({
+    const { textInput, events } = await renderTextInputWithToolkit({
       value: 'Hello!',
     });
 
@@ -83,7 +83,7 @@ describe('paste()', () => {
 
   it.each(['modern', 'legacy'])('works with %s fake timers', async (type) => {
     jest.useFakeTimers({ legacyFakeTimers: type === 'legacy' });
-    const { textInput, events } = renderTextInputWithToolkit({
+    const { textInput, events } = await renderTextInputWithToolkit({
       value: 'Hello!',
     });
 
@@ -102,7 +102,7 @@ describe('paste()', () => {
   });
 
   it('supports defaultValue prop', async () => {
-    const { textInput, events } = renderTextInputWithToolkit({
+    const { textInput, events } = await renderTextInputWithToolkit({
       defaultValue: 'Hello Default!',
     });
 
@@ -123,7 +123,7 @@ describe('paste()', () => {
   });
 
   it('does respect editable prop', async () => {
-    const { textInput } = renderTextInputWithToolkit({
+    const { textInput } = await renderTextInputWithToolkit({
       value: 'Hello!',
       editable: false,
     });
@@ -135,7 +135,7 @@ describe('paste()', () => {
   });
 
   it('does respect pointer-events prop', async () => {
-    const { textInput } = renderTextInputWithToolkit({
+    const { textInput } = await renderTextInputWithToolkit({
       value: 'Hello!',
       pointerEvents: 'none',
     });
@@ -147,7 +147,7 @@ describe('paste()', () => {
   });
 
   it('supports multiline', async () => {
-    const { textInput, events } = renderTextInputWithToolkit({
+    const { textInput, events } = await renderTextInputWithToolkit({
       value: 'Hello World!\nHow are you?',
       multiline: true,
     });
@@ -171,7 +171,7 @@ describe('paste()', () => {
 
   it('works when not all events have handlers', async () => {
     const { events, logEvent } = createEventLogger();
-    render(
+    await render(
       <TextInput
         testID="input"
         onChangeText={logEvent('changeText')}
@@ -188,7 +188,7 @@ describe('paste()', () => {
   });
 
   it('does NOT work on View', async () => {
-    render(<View testID="input" />);
+    await render(<View testID="input" />);
 
     const user = userEvent.setup();
     await expect(
@@ -203,7 +203,7 @@ describe('paste()', () => {
 
   it('does NOT bubble up', async () => {
     const parentHandler = jest.fn();
-    render(
+    await render(
       <AnyView
         onChangeText={parentHandler}
         onChange={parentHandler}
@@ -225,7 +225,7 @@ describe('paste()', () => {
   });
 
   it('sets native state value for unmanaged text inputs', async () => {
-    render(<TextInput testID="input" />);
+    await render(<TextInput testID="input" />);
 
     const user = userEvent.setup();
     const input = screen.getByTestId('input');
diff --git a/src/user-event/press/__tests__/longPress.real-timers.test.tsx b/src/user-event/press/__tests__/longPress.real-timers.test.tsx
index 656fc3c0e..8f54cb22e 100644
--- a/src/user-event/press/__tests__/longPress.real-timers.test.tsx
+++ b/src/user-event/press/__tests__/longPress.real-timers.test.tsx
@@ -15,7 +15,7 @@ describe('userEvent.longPress with real timers', () => {
     const { events, logEvent } = createEventLogger();
     const user = userEvent.setup();
 
-    render(
+    await render(
       <Pressable
         onPress={logEvent('press')}
         onPressIn={logEvent('pressIn')}
@@ -32,7 +32,7 @@ describe('userEvent.longPress with real timers', () => {
   test('works on TouchableOpacity', async () => {
     const mockOnPress = jest.fn();
 
-    render(
+    await render(
       <TouchableOpacity onPress={mockOnPress}>
         <Text>press me</Text>
       </TouchableOpacity>,
@@ -45,7 +45,7 @@ describe('userEvent.longPress with real timers', () => {
   test('works on TouchableHighlight', async () => {
     const mockOnPress = jest.fn();
 
-    render(
+    await render(
       <TouchableHighlight onPress={mockOnPress}>
         <Text>press me</Text>
       </TouchableHighlight>,
@@ -58,7 +58,7 @@ describe('userEvent.longPress with real timers', () => {
   test('works on Text', async () => {
     const { events, logEvent } = createEventLogger();
 
-    render(
+    await render(
       <Text
         onPress={logEvent('press')}
         onPressIn={logEvent('pressIn')}
@@ -77,7 +77,7 @@ describe('userEvent.longPress with real timers', () => {
     const mockOnLongPress = jest.fn();
     const user = userEvent.setup();
 
-    render(
+    await render(
       <Pressable onLongPress={mockOnLongPress}>
         <Text>press me</Text>
       </Pressable>,
@@ -92,7 +92,7 @@ describe('userEvent.longPress with real timers', () => {
     const mockOnPress = jest.fn();
     const user = userEvent.setup();
 
-    render(
+    await render(
       <Pressable delayLongPress={800} onLongPress={mockOnLongPress} onPress={mockOnPress}>
         <Text>press me</Text>
       </Pressable>,
@@ -111,7 +111,7 @@ describe('userEvent.longPress with real timers', () => {
     const mockOnPress = jest.fn();
     const user = userEvent.setup();
 
-    render(
+    await render(
       <Pressable delayLongPress={1000} onLongPress={mockOnLongPress} onPress={mockOnPress}>
         <Text>press me</Text>
       </Pressable>,
@@ -127,7 +127,7 @@ describe('userEvent.longPress with real timers', () => {
     const mockOnPress = jest.fn();
     const user = userEvent.setup();
 
-    render(
+    await render(
       <Pressable onLongPress={mockOnLongPress} onPress={mockOnPress}>
         <Text>press me</Text>
       </Pressable>,
@@ -141,7 +141,7 @@ describe('userEvent.longPress with real timers', () => {
   test('longPress is accessible directly in userEvent', async () => {
     const mockOnLongPress = jest.fn();
 
-    render(
+    await render(
       <Pressable onLongPress={mockOnLongPress}>
         <Text>press me</Text>
       </Pressable>,
diff --git a/src/user-event/press/__tests__/longPress.test.tsx b/src/user-event/press/__tests__/longPress.test.tsx
index 91267bb9d..23c31aae2 100644
--- a/src/user-event/press/__tests__/longPress.test.tsx
+++ b/src/user-event/press/__tests__/longPress.test.tsx
@@ -15,7 +15,7 @@ describe('userEvent.longPress with fake timers', () => {
     const { events, logEvent } = createEventLogger();
     const user = userEvent.setup();
 
-    render(
+    await render(
       <Pressable
         onPress={logEvent('press')}
         onPressIn={logEvent('pressIn')}
@@ -33,7 +33,7 @@ describe('userEvent.longPress with fake timers', () => {
   test('works on TouchableOpacity', async () => {
     const mockOnPress = jest.fn();
 
-    render(
+    await render(
       <TouchableOpacity onPress={mockOnPress}>
         <Text>press me</Text>
       </TouchableOpacity>,
@@ -46,7 +46,7 @@ describe('userEvent.longPress with fake timers', () => {
   test('works on TouchableHighlight', async () => {
     const mockOnPress = jest.fn();
 
-    render(
+    await render(
       <TouchableHighlight onPress={mockOnPress}>
         <Text>press me</Text>
       </TouchableHighlight>,
@@ -59,7 +59,7 @@ describe('userEvent.longPress with fake timers', () => {
   test('works on Text', async () => {
     const { events, logEvent } = createEventLogger();
 
-    render(
+    await render(
       <Text
         onPress={logEvent('press')}
         onPressIn={logEvent('pressIn')}
@@ -78,7 +78,7 @@ describe('userEvent.longPress with fake timers', () => {
     const { logEvent, events } = createEventLogger();
     const user = userEvent.setup();
 
-    render(
+    await render(
       <Pressable onPress={logEvent('press')} onLongPress={logEvent('longPress')}>
         <Text>press me</Text>
       </Pressable>,
@@ -93,7 +93,7 @@ describe('userEvent.longPress with fake timers', () => {
     const mockOnPress = jest.fn();
     const user = userEvent.setup();
 
-    render(
+    await render(
       <Pressable delayLongPress={800} onLongPress={mockOnLongPress} onPress={mockOnPress}>
         <Text>press me</Text>
       </Pressable>,
@@ -112,7 +112,7 @@ describe('userEvent.longPress with fake timers', () => {
     const mockOnPress = jest.fn();
     const user = userEvent.setup();
 
-    render(
+    await render(
       <Pressable delayLongPress={1000} onLongPress={mockOnLongPress} onPress={mockOnPress}>
         <Text>press me</Text>
       </Pressable>,
@@ -128,7 +128,7 @@ describe('userEvent.longPress with fake timers', () => {
     const mockOnPress = jest.fn();
     const user = userEvent.setup();
 
-    render(
+    await render(
       <Pressable onLongPress={mockOnLongPress} onPress={mockOnPress}>
         <Text>press me</Text>
       </Pressable>,
@@ -142,7 +142,7 @@ describe('userEvent.longPress with fake timers', () => {
   test('longPress is accessible directly in userEvent', async () => {
     const mockOnLongPress = jest.fn();
 
-    render(
+    await render(
       <Pressable onLongPress={mockOnLongPress}>
         <Text>press me</Text>
       </Pressable>,
@@ -157,7 +157,7 @@ describe('userEvent.longPress with fake timers', () => {
     const { events, logEvent } = createEventLogger();
     const user = userEvent.setup();
 
-    render(
+    await render(
       <Pressable
         onPress={logEvent('press')}
         onPressIn={logEvent('pressIn')}
diff --git a/src/user-event/press/__tests__/press.real-timers.test.tsx b/src/user-event/press/__tests__/press.real-timers.test.tsx
index d10954369..ccf4b8cc5 100644
--- a/src/user-event/press/__tests__/press.real-timers.test.tsx
+++ b/src/user-event/press/__tests__/press.real-timers.test.tsx
@@ -23,7 +23,7 @@ describe('userEvent.press with real timers', () => {
     const { events, logEvent } = createEventLogger();
     const user = userEvent.setup();
 
-    render(
+    await render(
       <Pressable
         onPress={logEvent('press')}
         onPressIn={logEvent('pressIn')}
@@ -45,7 +45,7 @@ describe('userEvent.press with real timers', () => {
   test('works on TouchableOpacity', async () => {
     const mockOnPress = jest.fn();
 
-    render(
+    await render(
       <TouchableOpacity onPress={mockOnPress}>
         <Text>press me</Text>
       </TouchableOpacity>,
@@ -58,7 +58,7 @@ describe('userEvent.press with real timers', () => {
   test('works on TouchableHighlight', async () => {
     const mockOnPress = jest.fn();
 
-    render(
+    await render(
       <TouchableHighlight onPress={mockOnPress}>
         <Text>press me</Text>
       </TouchableHighlight>,
@@ -71,7 +71,7 @@ describe('userEvent.press with real timers', () => {
   test('works on Text', async () => {
     const { events, logEvent } = createEventLogger();
 
-    render(
+    await render(
       <Text
         onPress={logEvent('press')}
         onPressIn={logEvent('pressIn')}
@@ -89,7 +89,7 @@ describe('userEvent.press with real timers', () => {
   test('works on TextInput', async () => {
     const { events, logEvent } = createEventLogger();
 
-    render(
+    await render(
       <TextInput
         placeholder="email"
         onPressIn={logEvent('pressIn')}
@@ -104,7 +104,7 @@ describe('userEvent.press with real timers', () => {
   test('works on Button', async () => {
     const { events, logEvent } = createEventLogger();
 
-    render(<Button title="press me" onPress={logEvent('press')} />);
+    await render(<Button title="press me" onPress={logEvent('press')} />);
 
     await userEvent.press(screen.getByText('press me'));
     expect(getEventsNames(events)).toEqual(['press']);
@@ -114,7 +114,7 @@ describe('userEvent.press with real timers', () => {
     const { events, logEvent } = createEventLogger();
     const user = userEvent.setup();
 
-    render(
+    await render(
       <Pressable
         disabled
         onPress={logEvent('press')}
@@ -133,7 +133,7 @@ describe('userEvent.press with real timers', () => {
     const { events, logEvent } = createEventLogger();
     const user = userEvent.setup();
 
-    render(
+    await render(
       <Pressable
         onPress={logEvent('press')}
         onPressIn={logEvent('pressIn')}
@@ -152,7 +152,7 @@ describe('userEvent.press with real timers', () => {
     const { events, logEvent } = createEventLogger();
     const user = userEvent.setup();
 
-    render(
+    await render(
       <Pressable
         onPress={logEvent('press')}
         onPressIn={logEvent('pressIn')}
@@ -171,7 +171,7 @@ describe('userEvent.press with real timers', () => {
     const { events, logEvent } = createEventLogger();
     const user = userEvent.setup();
 
-    render(
+    await render(
       <View pointerEvents="box-only">
         <Pressable
           onPress={logEvent('press')}
@@ -191,7 +191,7 @@ describe('userEvent.press with real timers', () => {
     const { events, logEvent } = createEventLogger();
     const user = userEvent.setup();
 
-    render(
+    await render(
       <Pressable
         onPress={logEvent('press')}
         onPressIn={logEvent('pressIn')}
@@ -214,7 +214,7 @@ describe('userEvent.press with real timers', () => {
   test('crawls up in the tree to find an element that responds to touch events', async () => {
     const mockOnPress = jest.fn();
 
-    render(
+    await render(
       <Pressable onPress={mockOnPress}>
         <Text>press me</Text>
       </Pressable>,
@@ -227,7 +227,7 @@ describe('userEvent.press with real timers', () => {
   test('does not call onLongPress', async () => {
     const mockOnLongPress = jest.fn();
 
-    render(
+    await render(
       <Pressable onLongPress={mockOnLongPress}>
         <Text>press me</Text>
       </Pressable>,
@@ -240,7 +240,7 @@ describe('userEvent.press with real timers', () => {
   test('does not trigger on disabled Text', async () => {
     const { events, logEvent } = createEventLogger();
 
-    render(
+    await render(
       <Text
         onPress={logEvent('press')}
         onPressIn={logEvent('pressIn')}
@@ -259,7 +259,7 @@ describe('userEvent.press with real timers', () => {
   test('does not trigger on Text with disabled pointer events', async () => {
     const { events, logEvent } = createEventLogger();
 
-    render(
+    await render(
       <View pointerEvents="box-only">
         <Text
           onPress={logEvent('press')}
@@ -279,7 +279,7 @@ describe('userEvent.press with real timers', () => {
   test('does not call onPressIn and onPressOut on non editable TextInput', async () => {
     const { events, logEvent } = createEventLogger();
 
-    render(
+    await render(
       <TextInput
         placeholder="email"
         editable={false}
@@ -294,7 +294,7 @@ describe('userEvent.press with real timers', () => {
   test('does not call onPressIn and onPressOut on TextInput with pointer events disabled', async () => {
     const { events, logEvent } = createEventLogger();
 
-    render(
+    await render(
       <TextInput
         placeholder="email"
         pointerEvents="box-none"
@@ -309,7 +309,7 @@ describe('userEvent.press with real timers', () => {
   test('press is accessible directly in userEvent', async () => {
     const mockOnPress = jest.fn();
 
-    render(
+    await render(
       <Pressable onPress={mockOnPress}>
         <Text>press me</Text>
       </Pressable>,
diff --git a/src/user-event/press/__tests__/press.test.tsx b/src/user-event/press/__tests__/press.test.tsx
index e4535ddbb..9b530f463 100644
--- a/src/user-event/press/__tests__/press.test.tsx
+++ b/src/user-event/press/__tests__/press.test.tsx
@@ -23,7 +23,7 @@ describe('userEvent.press with fake timers', () => {
     const { events, logEvent } = createEventLogger();
     const user = userEvent.setup();
 
-    render(
+    await render(
       <Pressable
         onPress={logEvent('press')}
         onPressIn={logEvent('pressIn')}
@@ -41,7 +41,7 @@ describe('userEvent.press with fake timers', () => {
   test('works on TouchableOpacity', async () => {
     const mockOnPress = jest.fn();
 
-    render(
+    await render(
       <TouchableOpacity onPress={mockOnPress}>
         <Text>press me</Text>
       </TouchableOpacity>,
@@ -54,7 +54,7 @@ describe('userEvent.press with fake timers', () => {
   test('works on TouchableHighlight', async () => {
     const mockOnPress = jest.fn();
 
-    render(
+    await render(
       <TouchableHighlight onPress={mockOnPress}>
         <Text>press me</Text>
       </TouchableHighlight>,
@@ -67,7 +67,7 @@ describe('userEvent.press with fake timers', () => {
   test('works on Text', async () => {
     const { events, logEvent } = createEventLogger();
 
-    render(
+    await render(
       <Text
         onPress={logEvent('press')}
         onPressIn={logEvent('pressIn')}
@@ -85,7 +85,7 @@ describe('userEvent.press with fake timers', () => {
   test('works on TextInput', async () => {
     const { events, logEvent } = createEventLogger();
 
-    render(
+    await render(
       <TextInput
         placeholder="email"
         onPressIn={logEvent('pressIn')}
@@ -100,7 +100,7 @@ describe('userEvent.press with fake timers', () => {
   test('works on Button', async () => {
     const { events, logEvent } = createEventLogger();
 
-    render(<Button title="press me" onPress={logEvent('press')} />);
+    await render(<Button title="press me" onPress={logEvent('press')} />);
 
     await userEvent.press(screen.getByText('press me'));
     expect(getEventsNames(events)).toEqual(['press']);
@@ -110,7 +110,7 @@ describe('userEvent.press with fake timers', () => {
     const { events, logEvent } = createEventLogger();
     const user = userEvent.setup();
 
-    render(
+    await render(
       <Pressable
         disabled
         onPress={logEvent('press')}
@@ -129,7 +129,7 @@ describe('userEvent.press with fake timers', () => {
     const { events, logEvent } = createEventLogger();
     const user = userEvent.setup();
 
-    render(
+    await render(
       <Pressable
         onPress={logEvent('press')}
         onPressIn={logEvent('pressIn')}
@@ -148,7 +148,7 @@ describe('userEvent.press with fake timers', () => {
     const { events, logEvent } = createEventLogger();
     const user = userEvent.setup();
 
-    render(
+    await render(
       <Pressable
         onPress={logEvent('press')}
         onPressIn={logEvent('pressIn')}
@@ -167,7 +167,7 @@ describe('userEvent.press with fake timers', () => {
     const { events, logEvent } = createEventLogger();
     const user = userEvent.setup();
 
-    render(
+    await render(
       <View pointerEvents="box-only">
         <Pressable
           onPress={logEvent('press')}
@@ -187,7 +187,7 @@ describe('userEvent.press with fake timers', () => {
     const { events, logEvent } = createEventLogger();
     const user = userEvent.setup();
 
-    render(
+    await render(
       <Pressable
         onPress={logEvent('press')}
         onPressIn={logEvent('pressIn')}
@@ -205,7 +205,7 @@ describe('userEvent.press with fake timers', () => {
   test('crawls up in the tree to find an element that responds to touch events', async () => {
     const mockOnPress = jest.fn();
 
-    render(
+    await render(
       <Pressable onPress={mockOnPress}>
         <Text>press me</Text>
       </Pressable>,
@@ -218,7 +218,7 @@ describe('userEvent.press with fake timers', () => {
   test('does not call onLongPress', async () => {
     const mockOnLongPress = jest.fn();
 
-    render(
+    await render(
       <Pressable onLongPress={mockOnLongPress}>
         <Text>press me</Text>
       </Pressable>,
@@ -231,7 +231,7 @@ describe('userEvent.press with fake timers', () => {
   test('longPress works Text', async () => {
     const { events, logEvent } = createEventLogger();
 
-    render(
+    await render(
       <Text
         onPress={logEvent('press')}
         onPressIn={logEvent('pressIn')}
@@ -249,7 +249,7 @@ describe('userEvent.press with fake timers', () => {
   test('does not trigger on disabled Text', async () => {
     const { events, logEvent } = createEventLogger();
 
-    render(
+    await render(
       <Text
         onPress={logEvent('press')}
         onPressIn={logEvent('pressIn')}
@@ -268,7 +268,7 @@ describe('userEvent.press with fake timers', () => {
   test('does not trigger on Text with disabled pointer events', async () => {
     const { events, logEvent } = createEventLogger();
 
-    render(
+    await render(
       <View pointerEvents="box-only">
         <Text
           onPress={logEvent('press')}
@@ -288,7 +288,7 @@ describe('userEvent.press with fake timers', () => {
   test('does not call onPressIn and onPressOut on non editable TextInput', async () => {
     const { events, logEvent } = createEventLogger();
 
-    render(
+    await render(
       <TextInput
         placeholder="email"
         editable={false}
@@ -304,7 +304,7 @@ describe('userEvent.press with fake timers', () => {
   test('does not call onPressIn and onPressOut on TextInput with pointer events disabled', async () => {
     const { events, logEvent } = createEventLogger();
 
-    render(
+    await render(
       <TextInput
         placeholder="email"
         pointerEvents="box-none"
@@ -320,7 +320,7 @@ describe('userEvent.press with fake timers', () => {
   test('press is accessible directly in userEvent', async () => {
     const mockOnPress = jest.fn();
 
-    render(
+    await render(
       <Pressable onPress={mockOnPress}>
         <Text>press me</Text>
       </Pressable>,
@@ -353,7 +353,7 @@ describe('userEvent.press with fake timers', () => {
       );
     };
 
-    render(<TestComponent />);
+    await render(<TestComponent />);
     await userEvent.press(screen.getByTestId('pressable'));
 
     expect(consoleErrorSpy).not.toHaveBeenCalled();
@@ -379,7 +379,7 @@ function Component() {
 }
 
 test('unmounts component', async () => {
-  render(<Component />);
+  await render(<Component />);
   await userEvent.press(screen.getByText('Unmount'));
   expect(screen.queryByText('Unmount')).not.toBeOnTheScreen();
 });
diff --git a/src/user-event/scroll/__tests__/scroll-to-flat-list.test.tsx b/src/user-event/scroll/__tests__/scroll-to-flat-list.test.tsx
index 5883dc826..b4a6aad14 100644
--- a/src/user-event/scroll/__tests__/scroll-to-flat-list.test.tsx
+++ b/src/user-event/scroll/__tests__/scroll-to-flat-list.test.tsx
@@ -17,11 +17,11 @@ function mapEventsToShortForm(events: EventEntry[]) {
   ]);
 }
 
-function renderFlatListWithToolkit(props: ScrollViewProps = {}) {
+async function renderFlatListWithToolkit(props: ScrollViewProps = {}) {
   const { events, logEvent } = createEventLogger();
 
   const renderItem = (title: string) => <Text>{title}</Text>;
-  render(
+  await render(
     <FlatList
       testID="flatList"
       onScroll={logEvent('scroll')}
@@ -43,7 +43,7 @@ function renderFlatListWithToolkit(props: ScrollViewProps = {}) {
 
 describe('scrollTo() with FlatList', () => {
   it('supports vertical drag scroll', async () => {
-    const { events } = renderFlatListWithToolkit();
+    const { events } = await renderFlatListWithToolkit();
     const user = userEvent.setup();
 
     await user.scrollTo(screen.getByTestId('flatList'), { y: 100 });
@@ -58,7 +58,7 @@ describe('scrollTo() with FlatList', () => {
   });
 
   it('supports horizontal drag scroll', async () => {
-    const { events } = renderFlatListWithToolkit({ horizontal: true });
+    const { events } = await renderFlatListWithToolkit({ horizontal: true });
     const user = userEvent.setup();
 
     await user.scrollTo(screen.getByTestId('flatList'), { x: 100 });
@@ -97,7 +97,7 @@ function Item({ title }: { title: string }) {
 }
 
 test('scrollTo with contentSize and layoutMeasurement update FlatList content', async () => {
-  render(<Scrollable />);
+  await render(<Scrollable />);
   const user = userEvent.setup();
 
   expect(screen.getByText('Item 0')).toBeOnTheScreen();
@@ -115,5 +115,5 @@ test('scrollTo with contentSize and layoutMeasurement update FlatList content',
   expect(screen.getByText('Item 15')).toBeOnTheScreen();
 
   // Prevent act warning by unmounting the component
-  await screen.unmountAsync();
+  await screen.unmount();
 });
diff --git a/src/user-event/scroll/__tests__/scroll-to.test.tsx b/src/user-event/scroll/__tests__/scroll-to.test.tsx
index 360c1ff11..6b1500f5e 100644
--- a/src/user-event/scroll/__tests__/scroll-to.test.tsx
+++ b/src/user-event/scroll/__tests__/scroll-to.test.tsx
@@ -15,10 +15,10 @@ function mapEventsToShortForm(events: EventEntry[]) {
   ]);
 }
 
-function renderScrollViewWithToolkit(props: ScrollViewProps = {}) {
+async function renderScrollViewWithToolkit(props: ScrollViewProps = {}) {
   const { events, logEvent } = createEventLogger();
 
-  render(
+  await render(
     <ScrollView
       testID="scrollView"
       onScroll={logEvent('scroll')}
@@ -40,7 +40,7 @@ beforeEach(() => {
 
 describe('scrollTo()', () => {
   it('supports vertical drag scroll', async () => {
-    const { events } = renderScrollViewWithToolkit();
+    const { events } = await renderScrollViewWithToolkit();
     const user = userEvent.setup();
 
     await user.scrollTo(screen.getByTestId('scrollView'), { y: 100 });
@@ -55,7 +55,7 @@ describe('scrollTo()', () => {
   });
 
   it('supports horizontal drag scroll', async () => {
-    const { events } = renderScrollViewWithToolkit({ horizontal: true });
+    const { events } = await renderScrollViewWithToolkit({ horizontal: true });
     const user = userEvent.setup();
 
     await user.scrollTo(screen.getByTestId('scrollView'), { x: 100 });
@@ -69,7 +69,7 @@ describe('scrollTo()', () => {
   });
 
   it('supports vertical momentum scroll', async () => {
-    const { events } = renderScrollViewWithToolkit();
+    const { events } = await renderScrollViewWithToolkit();
     const user = userEvent.setup();
 
     await user.scrollTo(screen.getByTestId('scrollView'), {
@@ -93,7 +93,7 @@ describe('scrollTo()', () => {
 
   test('works with fake timers', async () => {
     jest.useFakeTimers();
-    const { events } = renderScrollViewWithToolkit();
+    const { events } = await renderScrollViewWithToolkit();
     const user = userEvent.setup();
 
     await user.scrollTo(screen.getByTestId('scrollView'), { y: 100 });
@@ -107,7 +107,7 @@ describe('scrollTo()', () => {
   });
 
   test('remembers previous scroll offset', async () => {
-    const { events } = renderScrollViewWithToolkit();
+    const { events } = await renderScrollViewWithToolkit();
     const user = userEvent.setup();
 
     await user.scrollTo(screen.getByTestId('scrollView'), { y: 100 });
@@ -127,7 +127,7 @@ describe('scrollTo()', () => {
   });
 
   test('remembers previous scroll offset from "fireEvent.scroll"', async () => {
-    const { events } = renderScrollViewWithToolkit();
+    const { events } = await renderScrollViewWithToolkit();
     const user = userEvent.setup();
 
     await fireEvent.scroll(screen.getByTestId('scrollView'), {
@@ -145,7 +145,7 @@ describe('scrollTo()', () => {
   });
 
   it('validates vertical scroll direction', async () => {
-    renderScrollViewWithToolkit();
+    await renderScrollViewWithToolkit();
     const user = userEvent.setup();
 
     await expect(() =>
@@ -156,7 +156,7 @@ describe('scrollTo()', () => {
   });
 
   it('validates horizontal scroll direction', async () => {
-    renderScrollViewWithToolkit({ horizontal: true });
+    await renderScrollViewWithToolkit({ horizontal: true });
     const user = userEvent.setup();
 
     await expect(() =>
@@ -167,7 +167,7 @@ describe('scrollTo()', () => {
   });
 
   it('generates single drag step if already at target offset', async () => {
-    const { events } = renderScrollViewWithToolkit();
+    const { events } = await renderScrollViewWithToolkit();
     const user = userEvent.setup();
 
     await user.scrollTo(screen.getByTestId('scrollView'), { y: 0 });
@@ -178,7 +178,7 @@ describe('scrollTo()', () => {
   });
 
   it('generates single momentum step if already at target offset', async () => {
-    const { events } = renderScrollViewWithToolkit();
+    const { events } = await renderScrollViewWithToolkit();
     const user = userEvent.setup();
 
     await user.scrollTo(screen.getByTestId('scrollView'), {
@@ -198,7 +198,7 @@ describe('scrollTo()', () => {
   });
 
   it('generates no steps for scroll without offset', async () => {
-    const { events } = renderScrollViewWithToolkit();
+    const { events } = await renderScrollViewWithToolkit();
     const user = userEvent.setup();
 
     // @ts-expect-error intentionally omitting required options
@@ -207,7 +207,7 @@ describe('scrollTo()', () => {
   });
 
   it('does NOT work on View', async () => {
-    render(<View testID="view" />);
+    await render(<View testID="view" />);
     const user = userEvent.setup();
 
     await expect(
@@ -218,7 +218,7 @@ describe('scrollTo()', () => {
   });
 
   test('is accessible directly in userEvent', async () => {
-    const { events } = renderScrollViewWithToolkit();
+    const { events } = await renderScrollViewWithToolkit();
 
     await userEvent.scrollTo(screen.getByTestId('scrollView'), { y: 100 });
     expect(mapEventsToShortForm(events)).toEqual([
diff --git a/src/user-event/type/__tests__/type-managed.test.tsx b/src/user-event/type/__tests__/type-managed.test.tsx
index 8f5677843..7800c02a0 100644
--- a/src/user-event/type/__tests__/type-managed.test.tsx
+++ b/src/user-event/type/__tests__/type-managed.test.tsx
@@ -51,7 +51,7 @@ describe('type() for managed TextInput', () => {
   it('supports basic case', async () => {
     jest.spyOn(Date, 'now').mockImplementation(() => 100100100100);
     const { events, logEvent } = createEventLogger();
-    render(<ManagedTextInput logEvent={logEvent} />);
+    await render(<ManagedTextInput logEvent={logEvent} />);
 
     const user = userEvent.setup();
     await user.type(screen.getByTestId('input'), 'Wow');
@@ -82,7 +82,7 @@ describe('type() for managed TextInput', () => {
   test('supports rejecting TextInput', async () => {
     jest.spyOn(Date, 'now').mockImplementation(() => 100100100100);
     const { events, logEvent } = createEventLogger();
-    render(
+    await render(
       <ManagedTextInput initialValue="XXX" logEvent={logEvent} valueTransformer={() => 'XXX'} />,
     );
 
@@ -114,7 +114,7 @@ describe('type() for managed TextInput', () => {
 
   it('skips blur and endEditing events when `skipBlur: true` in managed TextInput', async () => {
     const { events, logEvent } = createEventLogger();
-    render(<ManagedTextInput logEvent={logEvent} />);
+    await render(<ManagedTextInput logEvent={logEvent} />);
 
     const user = userEvent.setup();
     await user.type(screen.getByTestId('input'), 'a', {
diff --git a/src/user-event/type/__tests__/type.test.tsx b/src/user-event/type/__tests__/type.test.tsx
index 7ce499008..87ef89798 100644
--- a/src/user-event/type/__tests__/type.test.tsx
+++ b/src/user-event/type/__tests__/type.test.tsx
@@ -10,10 +10,10 @@ beforeEach(() => {
   jest.useRealTimers();
 });
 
-function renderTextInputWithToolkit(props: TextInputProps = {}) {
+async function renderTextInputWithToolkit(props: TextInputProps = {}) {
   const { events, logEvent } = createEventLogger();
 
-  render(
+  await render(
     <TextInput
       testID="input"
       onFocus={logEvent('focus')}
@@ -39,7 +39,7 @@ function renderTextInputWithToolkit(props: TextInputProps = {}) {
 describe('type()', () => {
   it('supports basic case', async () => {
     jest.spyOn(Date, 'now').mockImplementation(() => 100100100100);
-    const { events } = renderTextInputWithToolkit();
+    const { events } = await renderTextInputWithToolkit();
 
     const user = userEvent.setup();
     await user.type(screen.getByTestId('input'), 'abc');
@@ -69,7 +69,7 @@ describe('type()', () => {
 
   it.each(['modern', 'legacy'])('works with %s fake timers', async (type) => {
     jest.useFakeTimers({ legacyFakeTimers: type === 'legacy' });
-    const { events } = renderTextInputWithToolkit();
+    const { events } = await renderTextInputWithToolkit();
 
     const user = userEvent.setup();
     await user.type(screen.getByTestId('input'), 'abc');
@@ -96,7 +96,7 @@ describe('type()', () => {
   });
 
   it('supports defaultValue prop', async () => {
-    const { events } = renderTextInputWithToolkit({
+    const { events } = await renderTextInputWithToolkit({
       defaultValue: 'xxx',
     });
 
@@ -123,7 +123,7 @@ describe('type()', () => {
   });
 
   it('does respect editable prop', async () => {
-    const { events } = renderTextInputWithToolkit({
+    const { events } = await renderTextInputWithToolkit({
       editable: false,
     });
 
@@ -134,7 +134,7 @@ describe('type()', () => {
   });
 
   it('supports backspace', async () => {
-    const { events } = renderTextInputWithToolkit({
+    const { events } = await renderTextInputWithToolkit({
       defaultValue: 'xxx',
     });
 
@@ -161,7 +161,7 @@ describe('type()', () => {
   });
 
   it('supports multiline', async () => {
-    const { events } = renderTextInputWithToolkit({
+    const { events } = await renderTextInputWithToolkit({
       multiline: true,
     });
 
@@ -190,7 +190,7 @@ describe('type()', () => {
   });
 
   test('skips press events when `skipPress: true`', async () => {
-    const { events } = renderTextInputWithToolkit();
+    const { events } = await renderTextInputWithToolkit();
 
     const user = userEvent.setup();
     await user.type(screen.getByTestId('input'), 'a', {
@@ -216,7 +216,7 @@ describe('type()', () => {
   });
 
   it('triggers submit event with `submitEditing: true`', async () => {
-    const { events } = renderTextInputWithToolkit();
+    const { events } = await renderTextInputWithToolkit();
 
     const user = userEvent.setup();
     await user.type(screen.getByTestId('input'), 'a', {
@@ -245,7 +245,7 @@ describe('type()', () => {
 
   it('works when not all events have handlers', async () => {
     const { events, logEvent } = createEventLogger();
-    render(
+    await render(
       <TextInput
         testID="input"
         onChangeText={logEvent('changeText')}
@@ -267,7 +267,7 @@ describe('type()', () => {
   });
 
   it('does NOT work on View', async () => {
-    render(<View testID="input" />);
+    await render(<View testID="input" />);
 
     const user = userEvent.setup();
     await expect(
@@ -282,7 +282,7 @@ describe('type()', () => {
 
   it('does NOT bubble up', async () => {
     const parentHandler = jest.fn();
-    render(
+    await render(
       <AnyView
         onChangeText={parentHandler}
         onChange={parentHandler}
@@ -305,7 +305,7 @@ describe('type()', () => {
 
   it('supports direct access', async () => {
     const { events, logEvent } = createEventLogger();
-    render(
+    await render(
       <TextInput
         testID="input"
         onChangeText={logEvent('changeText')}
@@ -328,7 +328,7 @@ describe('type()', () => {
   // See: https://github.com/callstack/react-native-testing-library/issues/1588
   it('can call "persist()" on "onKeyPress" event handler', async () => {
     const handleKeyPress = jest.fn();
-    render(
+    await render(
       <TextInput
         testID="input"
         onKeyPress={(e) => {
@@ -343,7 +343,7 @@ describe('type()', () => {
   });
 
   it('respects the "maxLength" prop', async () => {
-    const { events } = renderTextInputWithToolkit({ maxLength: 2 });
+    const { events } = await renderTextInputWithToolkit({ maxLength: 2 });
 
     const user = userEvent.setup();
     await user.type(screen.getByTestId('input'), 'abcd');
@@ -376,7 +376,7 @@ describe('type()', () => {
   });
 
   it('unmanaged text inputs preserve their native state', async () => {
-    render(<TextInput testID="input" />);
+    await render(<TextInput testID="input" />);
 
     const user = userEvent.setup();
     const input = screen.getByTestId('input');
@@ -390,7 +390,7 @@ describe('type()', () => {
   });
 
   it('skips blur and endEditing events when `skipBlur: true`', async () => {
-    const { events } = renderTextInputWithToolkit();
+    const { events } = await renderTextInputWithToolkit();
 
     const user = userEvent.setup();
     await user.type(screen.getByTestId('input'), 'a', {
diff --git a/src/user-event/utils/__tests__/dispatch-event.test.tsx b/src/user-event/utils/__tests__/dispatch-event.test.tsx
index 573b338d6..81f308e2d 100644
--- a/src/user-event/utils/__tests__/dispatch-event.test.tsx
+++ b/src/user-event/utils/__tests__/dispatch-event.test.tsx
@@ -10,7 +10,7 @@ const TOUCH_EVENT = EventBuilder.Common.touch();
 describe('dispatchEvent', () => {
   it('does dispatch event', async () => {
     const onPress = jest.fn();
-    render(<Text testID="text" onPress={onPress} />);
+    await render(<Text testID="text" onPress={onPress} />);
 
     await dispatchEvent(screen.getByTestId('text'), 'press', TOUCH_EVENT);
     expect(onPress).toHaveBeenCalledTimes(1);
@@ -18,7 +18,7 @@ describe('dispatchEvent', () => {
 
   it('does not dispatch event to parent host component', async () => {
     const onPressParent = jest.fn();
-    render(
+    await render(
       <Text onPress={onPressParent}>
         <Text testID="text" />
       </Text>,
@@ -29,7 +29,7 @@ describe('dispatchEvent', () => {
   });
 
   it('does NOT throw if no handler found', async () => {
-    render(
+    await render(
       <Text>
         <Text testID="text" />
       </Text>,
diff --git a/src/wait-for-element-to-be-removed.ts b/src/wait-for-element-to-be-removed.ts
index 5af3e4fa2..e0546e40f 100644
--- a/src/wait-for-element-to-be-removed.ts
+++ b/src/wait-for-element-to-be-removed.ts
@@ -1,12 +1,12 @@
 import { ErrorWithStack } from './helpers/errors';
 import type { WaitForOptions } from './wait-for';
-import waitFor from './wait-for';
+import { waitFor } from './wait-for';
 
 function isRemoved<T>(result: T): boolean {
   return !result || (Array.isArray(result) && !result.length);
 }
 
-export default async function waitForElementToBeRemoved<T>(
+export async function waitForElementToBeRemoved<T>(
   expectation: () => T,
   options?: WaitForOptions,
 ): Promise<T> {
diff --git a/src/wait-for.ts b/src/wait-for.ts
index 1bf96e68c..945d29a99 100644
--- a/src/wait-for.ts
+++ b/src/wait-for.ts
@@ -182,7 +182,7 @@ function waitForInternal<T>(
   });
 }
 
-export default function waitFor<T>(expectation: () => T, options?: WaitForOptions): Promise<T> {
+export function waitFor<T>(expectation: () => T, options?: WaitForOptions): Promise<T> {
   // Being able to display a useful stack trace requires generating it before doing anything async
   const stackTraceError = new ErrorWithStack('STACK_TRACE_ERROR', waitFor);
   const optionsWithStackTrace = { stackTraceError, ...options };
diff --git a/website/docs/14.x/cookbook/basics/async-tests.md b/website/docs/14.x/cookbook/basics/async-tests.md
index c3900d519..8c9cd4c43 100644
--- a/website/docs/14.x/cookbook/basics/async-tests.md
+++ b/website/docs/14.x/cookbook/basics/async-tests.md
@@ -17,7 +17,7 @@ Consider a basic asynchronous test for a user signing in with correct credential
 test('User can sign in with correct credentials', async () => {
   // Typical test setup
   const user = userEvent.setup();
-  render(<App />);
+  await render(<App />);
 
   // No need to use async here, components are already rendered
   expect(screen.getByRole('header', { name: 'Sign in to Hello World App!' })).toBeOnTheScreen();
@@ -60,7 +60,7 @@ function findByRole: (
     interval?: number;
     // ..
   }
-): Promise<ReactTestInstance>;
+): Promise<HostElement>;
 ```
 
 Each query has a default `timeout` value of 1000 ms and a default `interval` of 50 ms. Custom timeout and check intervals can be specified if needed, as shown below:
diff --git a/website/docs/14.x/cookbook/basics/custom-render.md b/website/docs/14.x/cookbook/basics/custom-render.md
index 6d1d88ffd..830d3005c 100644
--- a/website/docs/14.x/cookbook/basics/custom-render.md
+++ b/website/docs/14.x/cookbook/basics/custom-render.md
@@ -14,11 +14,11 @@ interface RenderWithProvidersProps {
   theme?: Theme;
 }
 
-export function renderWithProviders<T>(
+export async function renderWithProviders<T>(
   ui: React.ReactElement<T>,
   options?: RenderWithProvidersProps
 ) {
-  return render(
+  return await render(
     <UserProvider.Provider value={options?.user ?? null}>
       <ThemeProvider.Provider value={options?.theme ?? 'light'}>{ui}</ThemeProvider.Provider>
     </UserProvider.Provider>
@@ -31,13 +31,13 @@ import { screen } from '@testing-library/react-native';
 import { renderWithProviders } from '../test-utils';
 // ...
 
-test('renders WelcomeScreen with user', () => {
-  renderWithProviders(<WelcomeScreen />, { user: { name: 'Jar-Jar' } });
+test('renders WelcomeScreen with user', async () => {
+  await renderWithProviders(<WelcomeScreen />, { user: { name: 'Jar-Jar' } });
   expect(screen.getByText(/hello Jar-Jar/i)).toBeOnTheScreen();
 });
 
-test('renders WelcomeScreen without user', () => {
-  renderWithProviders(<WelcomeScreen />, { user: null });
+test('renders WelcomeScreen without user', async () => {
+  await renderWithProviders(<WelcomeScreen />, { user: null });
   expect(screen.getByText(/hello stranger/i)).toBeOnTheScreen();
 });
 ```
diff --git a/website/docs/14.x/docs/advanced/testing-env.mdx b/website/docs/14.x/docs/advanced/testing-env.mdx
index 41292a3ff..acd597d5d 100644
--- a/website/docs/14.x/docs/advanced/testing-env.mdx
+++ b/website/docs/14.x/docs/advanced/testing-env.mdx
@@ -18,11 +18,11 @@ React allows you to write declarative code using JSX, write function or class co
 
 When you run your tests in the React Native Testing Library, somewhat contrary to what the name suggests, they are actually **not** using React Native renderer. This is because this renderer needs to be run on an iOS or Android operating system, so it would need to run on a device or simulator.
 
-## React Test Renderer
+## Universal Test Renderer
 
-Instead, RNTL uses React Test Renderer, a specialized renderer that allows rendering to pure JavaScript objects without access to mobile OS and can run in a Node.js environment using Jest (or any other JavaScript test runner).
+Instead, RNTL uses [Universal Test Renderer](https://github.com/mdjastrzebski/universal-test-renderer), a modern, actively maintained renderer that allows rendering to pure JavaScript objects without access to mobile OS and can run in a Node.js environment using Jest (or any other JavaScript test runner). Universal Test Renderer replaces the deprecated `react-test-renderer` package and provides better compatibility with React 19 and improved type safety.
 
-Using React Test Renderer has pros and cons.
+Using Universal Test Renderer has pros and cons.
 
 Benefits:
 
@@ -41,22 +41,22 @@ It's worth noting that the React Testing Library (web one) works a bit different
 
 ## Element tree
 
-Calling the `render()` function creates an element tree. This is done internally by invoking `TestRenderer.create()` method. The output tree represents your React Native component tree, and each node of that tree is an "instance" of some React component (to be more precise, each node represents a React fiber, and only class components have instances, while function components store the hook state using fibers).
+Calling the `render()` function creates an element tree. This is done internally by invoking the renderer's `create()` method from Universal Test Renderer. The output tree represents your React Native component tree, and each node of that tree is an "instance" of some React component (to be more precise, each node represents a React fiber, and only class components have instances, while function components store the hook state using fibers).
 
-These tree elements are represented by `ReactTestInstance` type:
+These tree elements are represented by `HostElement` type from Universal Test Renderer:
 
 ```tsx
-interface ReactTestInstance {
+interface HostElement {
   type: ElementType;
   props: { [propName: string]: any };
-  parent: ReactTestInstance | null;
-  children: Array<ReactTestInstance | string>;
+  parent: HostElement | null;
+  children: Array<HostElement | string>;
 
   // Other props and methods
 }
 ```
 
-Based on: https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/types/react-test-renderer/index.d.ts
+For more details, see the [Universal Test Renderer documentation](https://github.com/mdjastrzebski/universal-test-renderer).
 
 ## Host and composite components
 
@@ -96,7 +96,7 @@ Not all React Native components are organized this way, e.g., when you use `Pres
 
 ### Differentiating between host and composite elements
 
-Any easy way to differentiate between host and composite elements is the `type` prop of `ReactTestInstance`:
+Any easy way to differentiate between host and composite elements is the `type` prop of `HostElement`:
 
 - for host components, it's always a string value representing a component name, e.g., `"View"`
 - for composite components, it's a function or class corresponding to the component
@@ -104,7 +104,7 @@ Any easy way to differentiate between host and composite elements is the `type`
 You can use the following code to check if a given element is a host one:
 
 ```jsx
-function isHostElement(element: ReactTestInstance) {
+function isHostElement(element: HostElement) {
   return typeof element.type === 'string';
 }
 ```
@@ -135,7 +135,7 @@ In the above example, user-defined components accept both `onPress` and `style`
 You should avoid navigating over the element tree, as this makes your testing code fragile and may result in false positives. This section is more relevant for people who want to contribute to our codebase.
 :::
 
-You will encounter host and composite elements when navigating a tree of react elements using `parent` or `children` props of a `ReactTestInstance` element. You should be careful when navigating the element tree, as the tree structure for third-party components can change independently from your code and cause unexpected test failures.
+You will encounter host and composite elements when navigating a tree of react elements using `parent` or `children` props of a `HostElement` element. You should be careful when navigating the element tree, as the tree structure for third-party components can change independently from your code and cause unexpected test failures.
 
 Inside RNTL, we have various tree navigation helpers: `getHostParent`, `getHostChildren`, etc. These are intentionally not exported, as using them is not recommended.
 
diff --git a/website/docs/14.x/docs/api/events/fire-event.mdx b/website/docs/14.x/docs/api/events/fire-event.mdx
index fef427999..0feee2dda 100644
--- a/website/docs/14.x/docs/api/events/fire-event.mdx
+++ b/website/docs/14.x/docs/api/events/fire-event.mdx
@@ -10,11 +10,7 @@ Use Fire Event for cases not supported by User Event and for triggering event ha
 :::
 
 ```ts
-function fireEvent(
-  element: ReactTestInstance,
-  eventName: string,
-  ...data: unknown[]
-): Promise<unknown>;
+function fireEvent(element: HostElement, eventName: string, ...data: unknown[]): Promise<unknown>;
 ```
 
 The `fireEvent` API allows you to trigger all kinds of event handlers on both host and composite components. It will try to invoke a single event handler traversing the component tree bottom-up from passed element and trying to find enabled event handler named `onXxx` when `xxx` is the name of the event passed.
@@ -71,7 +67,7 @@ It is recommended to use the User Event [`press()`](docs/api/events/user-event#p
 
 ```tsx
 fireEvent.press: (
-  element: ReactTestInstance,
+  element: HostElement,
   ...data: Array<any>,
 ) => Promise<unknown>
 ```
@@ -110,7 +106,7 @@ It is recommended to use the User Event [`type()`](docs/api/events/user-event#ty
 
 ```tsx
 fireEvent.changeText: (
-  element: ReactTestInstance,
+  element: HostElement,
   ...data: Array<any>,
 ) => Promise<unknown>
 ```
@@ -141,7 +137,7 @@ Prefer using [`user.scrollTo`](docs/api/events/user-event#scrollto) over `fireEv
 
 ```tsx
 fireEvent.scroll: (
-  element: ReactTestInstance,
+  element: HostElement,
   ...data: Array<any>,
 ) => Promise<unknown>
 ```
@@ -172,14 +168,10 @@ render(
 await fireEvent.scroll(screen.getByText('scroll-view'), eventData);
 ```
 
-## `deprecated_fireEventSync` {#deprecated-fire-event-sync}
+## `unsafe_fireEventSync` {#unsafe-fire-event-sync}
 
 ```ts
-function deprecated_fireEventSync(
-  element: ReactTestInstance,
-  eventName: string,
-  ...data: unknown[]
-): void;
+function unsafe_fireEventSync(element: HostElement, eventName: string, ...data: unknown[]): void;
 ```
 
 Synchronous version of `fireEvent`. Deprecated and will be removed in future versions.
diff --git a/website/docs/14.x/docs/api/events/user-event.mdx b/website/docs/14.x/docs/api/events/user-event.mdx
index 4684faebe..ebc071059 100644
--- a/website/docs/14.x/docs/api/events/user-event.mdx
+++ b/website/docs/14.x/docs/api/events/user-event.mdx
@@ -34,7 +34,7 @@ Creates a User Event object instance, which can be used to trigger events.
 
 ```ts
 press(
-  element: ReactTestInstance,
+  element: HostElement,
 ): Promise<void>
 ```
 
@@ -53,7 +53,7 @@ This event will take a minimum of 130 ms to run due to the internal React Native
 
 ```ts
 longPress(
-  element: ReactTestInstance,
+  element: HostElement,
   options: { duration: number } = { duration: 500 }
 ): Promise<void>
 ```
@@ -77,7 +77,7 @@ This event will, by default, take 500 ms to run. Due to internal React Native lo
 
 ```ts
 type(
-  element: ReactTestInstance,
+  element: HostElement,
   text: string,
   options?: {
     skipPress?: boolean;
@@ -142,7 +142,7 @@ The `endEditing` and `blur` events can be skipped by passing the `skipBlur: true
 
 ```ts
 clear(
-  element: ReactTestInstance,
+  element: HostElement,
 )
 ```
 
@@ -185,7 +185,7 @@ Events will not be emitted if the `editable` prop is set to `false`.
 
 ```ts
 paste(
-  element: ReactTestInstance,
+  element: HostElement,
   text: string,
 )
 ```
@@ -228,7 +228,7 @@ Events will not be emitted if the `editable` prop is set to `false`.
 
 ```ts
 scrollTo(
-  element: ReactTestInstance,
+  element: HostElement,
   options: {
     y: number,
     momentumY?: number,
diff --git a/website/docs/14.x/docs/api/jest-matchers.mdx b/website/docs/14.x/docs/api/jest-matchers.mdx
index 0834b07bc..13a662fb9 100644
--- a/website/docs/14.x/docs/api/jest-matchers.mdx
+++ b/website/docs/14.x/docs/api/jest-matchers.mdx
@@ -40,7 +40,7 @@ This allows you to assert whether the given element has the given text content o
 
 ```ts
 expect(container).toContainElement(
-  element: ReactTestInstance | null,
+  element: HostElement | null,
 )
 ```
 
diff --git a/website/docs/14.x/docs/api/misc/accessibility.mdx b/website/docs/14.x/docs/api/misc/accessibility.mdx
index 6e7aab474..916830364 100644
--- a/website/docs/14.x/docs/api/misc/accessibility.mdx
+++ b/website/docs/14.x/docs/api/misc/accessibility.mdx
@@ -3,7 +3,7 @@
 ## `isHiddenFromAccessibility`
 
 ```ts
-function isHiddenFromAccessibility(element: ReactTestInstance | null): boolean {}
+function isHiddenFromAccessibility(element: HostElement | null): boolean {}
 ```
 
 Also available as `isInaccessible()` alias for React Testing Library compatibility.
diff --git a/website/docs/14.x/docs/api/misc/other.mdx b/website/docs/14.x/docs/api/misc/other.mdx
index 8100981c3..560f8d791 100644
--- a/website/docs/14.x/docs/api/misc/other.mdx
+++ b/website/docs/14.x/docs/api/misc/other.mdx
@@ -3,9 +3,9 @@
 ## `within`, `getQueriesForElement` {#within}
 
 ```jsx
-function within(element: ReactTestInstance): Queries {}
+function within(element: HostElement): Queries {}
 
-function getQueriesForElement(element: ReactTestInstance): Queries {}
+function getQueriesForElement(element: HostElement): Queries {}
 ```
 
 `within` (also available as `getQueriesForElement` alias) performs [queries](docs/api/queries) scoped to given element.
@@ -29,7 +29,7 @@ Use cases for scoped queries include:
 
 ## `act`
 
-Useful function to help testing components that use hooks API. By default any `render`, `update`, `fireEvent`, and `waitFor` calls are wrapped by this function, so there is no need to wrap it manually. This method is re-exported from [`react-test-renderer`](https://github.com/facebook/react/blob/main/packages/react-test-renderer/src/ReactTestRenderer.js#L567]).
+Useful function to help testing components that use hooks API. By default any `render`, `update`, `fireEvent`, and `waitFor` calls are wrapped by this function, so there is no need to wrap it manually. This method is provided by [Universal Test Renderer](https://github.com/callstack/universal-test-renderer) and re-exported for convenience.
 
 Consult our [Understanding Act function](docs/advanced/understanding-act.md) document for more understanding of its intricacies.
 
diff --git a/website/docs/14.x/docs/api/misc/render-hook.mdx b/website/docs/14.x/docs/api/misc/render-hook.mdx
index c9e24716e..a590d3bfa 100644
--- a/website/docs/14.x/docs/api/misc/render-hook.mdx
+++ b/website/docs/14.x/docs/api/misc/render-hook.mdx
@@ -170,8 +170,8 @@ it('handles hook with suspense', async () => {
 
 ## Migration from v13
 
-If you're migrating from React Native Testing Library v13, you may have existing tests using the synchronous `renderHook` API. To ease migration, we provide `deprecated_renderHookSync` which maintains the same synchronous behavior.
+If you're migrating from React Native Testing Library v13, you may have existing tests using the synchronous `renderHook` API. To ease migration, we provide `unsafe_renderHookSync` which maintains the same synchronous behavior.
 
-**⚠️ Deprecated**: `deprecated_renderHookSync` is provided for migration purposes only. Use async `renderHook` instead.
+**⚠️ Deprecated**: `unsafe_renderHookSync` is provided for migration purposes only. Use async `renderHook` instead.
 
 For detailed migration instructions, see the [v14 migration guide](../../migration/v14).
diff --git a/website/docs/14.x/docs/api/queries.mdx b/website/docs/14.x/docs/api/queries.mdx
index e7034c683..cb607a8c3 100644
--- a/website/docs/14.x/docs/api/queries.mdx
+++ b/website/docs/14.x/docs/api/queries.mdx
@@ -49,21 +49,21 @@ For this query, `getBy*` is the query variant, and `*ByRole` is the predicate.
 
 The query variants describe the expected number (and timing) of matching elements, so they differ in their return type.
 
-| Variant                                        | Assertion                     | Return type                                | Is Async? |
-| ---------------------------------------------- | ----------------------------- | ------------------------------------------ | --------- |
-| [`getBy*`](docs/api/queries#get-by)            | Exactly one matching element  | `ReactTestInstance`                        | No        |
-| [`getAllBy*`](docs/api/queries#get-all-by)     | At least one matching element | `Array<ReactTestInstance>`                 | No        |
-| [`queryBy*`](docs/api/queries#query-by)        | Zero or one matching element  | <code>ReactTestInstance &#124; null</code> | No        |
-| [`queryAllBy*`](docs/api/queries#query-all-by) | No assertion                  | `Array<ReactTestInstance>`                 | No        |
-| [`findBy*`](docs/api/queries#find-by)          | Exactly one matching element  | `Promise<ReactTestInstance>`               | Yes       |
-| [`findAllBy*`](docs/api/queries#find-all-by)   | At least one matching element | `Promise<Array<ReactTestInstance>>`        | Yes       |
+| Variant                                        | Assertion                     | Return type                          | Is Async? |
+| ---------------------------------------------- | ----------------------------- | ------------------------------------ | --------- |
+| [`getBy*`](docs/api/queries#get-by)            | Exactly one matching element  | `HostElement`                        | No        |
+| [`getAllBy*`](docs/api/queries#get-all-by)     | At least one matching element | `Array<HostElement>`                 | No        |
+| [`queryBy*`](docs/api/queries#query-by)        | Zero or one matching element  | <code>HostElement &#124; null</code> | No        |
+| [`queryAllBy*`](docs/api/queries#query-all-by) | No assertion                  | `Array<HostElement>`                 | No        |
+| [`findBy*`](docs/api/queries#find-by)          | Exactly one matching element  | `Promise<HostElement>`               | Yes       |
+| [`findAllBy*`](docs/api/queries#find-all-by)   | At least one matching element | `Promise<Array<HostElement>>`        | Yes       |
 
 Queries work as implicit assertions on the number of matching elements and will throw an error when the assertion fails.
 
 ### `getBy*` queries {#get-by}
 
 ```ts
-getByX(...): ReactTestInstance
+getByX(...): HostElement
 ```
 
 `getBy*` queries return the single matching element for a query, and throw an error if no elements match or if more than one match is found. If you need to find more than one element, then use `getAllBy`.
@@ -71,7 +71,7 @@ getByX(...): ReactTestInstance
 ### `getAllBy*` queries {#get-all-by}
 
 ```ts
-getAllByX(...): ReactTestInstance[]
+getAllByX(...): HostElement[]
 ```
 
 `getAllBy*` queries return an array of all matching elements for a query and throw an error if no elements match.
@@ -79,7 +79,7 @@ getAllByX(...): ReactTestInstance[]
 ### `queryBy*` queries {#query-by}
 
 ```ts
-queryByX(...): ReactTestInstance | null
+queryByX(...): HostElement | null
 ```
 
 `queryBy*` queries return the first matching node for a query, and return `null` if no elements match. This is useful for asserting an element that is not present. This throws if more than one match is found (use `queryAllBy` instead).
@@ -87,7 +87,7 @@ queryByX(...): ReactTestInstance | null
 ### `queryAllBy*` queries {#query-all-by}
 
 ```ts
-queryAllByX(...): ReactTestInstance[]
+queryAllByX(...): HostElement[]
 ```
 
 `queryAllBy*` queries return an array of all matching nodes for a query and return an empty array (`[]`) when no elements match.
@@ -101,7 +101,7 @@ findByX(
     timeout?: number,
     interval?: number,
   },
-): Promise<ReactTestInstance>
+): Promise<HostElement>
 ```
 
 `findBy*` queries return a promise which resolves when a matching element is found. The promise is rejected if no elements match or if more than one match is found after a default timeout of 1000 ms. If you need to find more than one element use `findAllBy*` queries.
@@ -115,7 +115,7 @@ findAllByX(
     timeout?: number,
     interval?: number,
   },
-): Promise<ReactTestInstance[]>
+): Promise<HostElement[]>
 ```
 
 `findAllBy*` queries return a promise which resolves to an array of matching elements. The promise is rejected if no elements match after a default timeout of 1000 ms.
@@ -130,14 +130,14 @@ In cases when your `findBy*` and `findAllBy*` queries throw when unable to find
 
 ## Query predicates
 
-_Note: most methods like this one return a [`ReactTestInstance`](https://reactjs.org/docs/test-renderer.html#testinstance) with following properties that you may be interested in:_
+_Note: most methods like this one return a [`HostElement`](https://reactjs.org/docs/test-renderer.html#testinstance) with following properties that you may be interested in:_
 
 ```typescript
-type ReactTestInstance = {
+type HostElement = {
   type: string | Function;
   props: { [propName: string]: any };
-  parent: ReactTestInstance | null;
-  children: Array<ReactTestInstance | string>;
+  parent: HostElement | null;
+  children: Array<HostElement | string>;
 };
 ```
 
@@ -163,10 +163,10 @@ getByRole(
     },
     includeHiddenElements?: boolean;
   }
-): ReactTestInstance;
+): HostElement;
 ```
 
-Returns a `ReactTestInstance` with matching `role` or `accessibilityRole` prop.
+Returns a `HostElement` with matching `role` or `accessibilityRole` prop.
 
 :::info
 In order for `*ByRole` queries to match an element it needs to be considered an accessibility element:
@@ -230,10 +230,10 @@ getByLabelText(
     normalizer?: (text: string) => string;
     includeHiddenElements?: boolean;
   },
-): ReactTestInstance;
+): HostElement;
 ```
 
-Returns a `ReactTestInstance` with matching label:
+Returns a `HostElement` with matching label:
 
 - either by matching [`aria-label`](https://reactnative.dev/docs/accessibility#aria-label)/[`accessibilityLabel`](https://reactnative.dev/docs/accessibility#accessibilitylabel) prop
 - or by matching text content of view referenced by [`aria-labelledby`](https://reactnative.dev/docs/accessibility#aria-labelledby-android)/[`accessibilityLabelledBy`](https://reactnative.dev/docs/accessibility#accessibilitylabelledby-android) prop
@@ -257,10 +257,10 @@ getByPlaceholderText(
     normalizer?: (text: string) => string;
     includeHiddenElements?: boolean;
   }
-): ReactTestInstance;
+): HostElement;
 ```
 
-Returns a `ReactTestInstance` for a `TextInput` with a matching placeholder – may be a string or regular expression.
+Returns a `HostElement` for a `TextInput` with a matching placeholder – may be a string or regular expression.
 
 ```jsx
 import { render, screen } from '@testing-library/react-native';
@@ -281,10 +281,10 @@ getByDisplayValue(
     normalizer?: (text: string) => string;
     includeHiddenElements?: boolean;
   },
-): ReactTestInstance;
+): HostElement;
 ```
 
-Returns a `ReactTestInstance` for a `TextInput` with a matching display value – may be a string or regular expression.
+Returns a `HostElement` for a `TextInput` with a matching display value – may be a string or regular expression.
 
 ```jsx
 import { render, screen } from '@testing-library/react-native';
@@ -305,10 +305,10 @@ getByText(
     normalizer?: (text: string) => string;
     includeHiddenElements?: boolean;
   }
-): ReactTestInstance;
+): HostElement;
 ```
 
-Returns a `ReactTestInstance` with matching text – may be a string or regular expression.
+Returns a `HostElement` with matching text – may be a string or regular expression.
 
 This method will join `<Text>` siblings to find matches, similarly to [how React Native handles these components](https://reactnative.dev/docs/text#containers). This will allow for querying for strings that will be visually rendered together, but may be semantically separate React components.
 
@@ -333,10 +333,10 @@ getByHintText(
     normalizer?: (text: string) => string;
     includeHiddenElements?: boolean;
   },
-): ReactTestInstance;
+): HostElement;
 ```
 
-Returns a `ReactTestInstance` with matching `accessibilityHint` prop.
+Returns a `HostElement` with matching `accessibilityHint` prop.
 
 ```jsx
 import { render, screen } from '@testing-library/react-native';
@@ -361,10 +361,10 @@ getByTestId(
     normalizer?: (text: string) => string;
     includeHiddenElements?: boolean;
   },
-): ReactTestInstance;
+): HostElement;
 ```
 
-Returns a `ReactTestInstance` with matching `testID` prop. `testID` – may be a string or a regular expression.
+Returns a `HostElement` with matching `testID` prop. `testID` – may be a string or a regular expression.
 
 ```jsx
 import { render, screen } from '@testing-library/react-native';
@@ -514,7 +514,7 @@ The interface is the same as for other queries, but we won't provide full names
 
 > UNSAFE_getByType, UNSAFE_getAllByType, UNSAFE_queryByType, UNSAFE_queryAllByType
 
-Returns a `ReactTestInstance` with matching a React component type.
+Returns a `HostElement` with matching a React component type.
 
 :::caution
 This query has been marked unsafe, since it requires knowledge about implementation details of the component. Use responsibly.
@@ -524,7 +524,7 @@ This query has been marked unsafe, since it requires knowledge about implementat
 
 > UNSAFE_getByProps, UNSAFE_getAllByProps, UNSAFE_queryByProps, UNSAFE_queryAllByProps
 
-Returns a `ReactTestInstance` with matching props object.
+Returns a `HostElement` with matching props object.
 
 :::caution
 This query has been marked unsafe, since it requires knowledge about implementation details of the component. Use responsibly.
diff --git a/website/docs/14.x/docs/api/render.mdx b/website/docs/14.x/docs/api/render.mdx
index 9ae4417a0..bd3b360b1 100644
--- a/website/docs/14.x/docs/api/render.mdx
+++ b/website/docs/14.x/docs/api/render.mdx
@@ -3,19 +3,19 @@
 ## `render` function {#render}
 
 ```jsx
-function render(
+async function render(
   component: React.Element<any>,
   options?: RenderOptions
-): RenderResult
+): Promise<RenderResult>
 ```
 
-The `render` function is the entry point for writing React Native Testing Library tests. It deeply renders the given React element and returns helpers to query the output components' structure.
+The `render` function is the entry point for writing React Native Testing Library tests. It deeply renders the given React element and returns helpers to query the output components' structure. This function is async by default and uses async `act` internally to ensure all pending React updates are executed during rendering, making it compatible with React 19, React Suspense, and `React.use()`.
 
 ```jsx
 import { render, screen } from '@testing-library/react-native';
 
-test('basic test', () => {
-  render(<MyApp />);
+test('basic test', async () => {
+  await render(<MyApp />);
   expect(screen.getAllByRole('button', { name: 'start' })).toBeOnTheScreen();
 });
 ```
@@ -45,64 +45,64 @@ Otherwise, `render` will default to using concurrent rendering used in the React
 createNodeMock?: (element: React.Element) => unknown,
 ```
 
-This option allows you to pass `createNodeMock` option to `ReactTestRenderer.create()` method in order to allow for custom mock refs. You can learn more about this option from [React Test Renderer documentation](https://reactjs.org/docs/test-renderer.html#ideas).
+This option allows you to pass `createNodeMock` option to the renderer's `create()` method in order to allow for custom mock refs. This option is passed through to [Universal Test Renderer](https://github.com/mdjastrzebski/universal-test-renderer).
 
-#### `unstable_validateStringsRenderedWithinText`
+:::note Text string validation
 
-```ts
-unstable_validateStringsRenderedWithinText?: boolean;
-```
-
-:::note
-This options is experimental, in some cases it might not work as intended, and its behavior might change without observing [SemVer](https://semver.org/) requirements for breaking changes.
-:::
+Universal Test Renderer automatically enforces React Native's requirement that text strings must be rendered within a `<Text>` component. If you try to render a `string` value under components other than `<Text>` (e.g., under `<View>`), it will throw an `Invariant Violation: Text strings must be rendered within a <Text> component` error, matching React Native's runtime behavior.
 
-This **experimental** option allows you to replicate React Native behavior of throwing `Invariant Violation: Text strings must be rendered within a <Text> component` error when you try to render `string` value under components different than `<Text>`, e.g., under `<View>`.
+This validation is always enabled and cannot be disabled, ensuring your tests accurately reflect how your code will behave in production.
 
-React Test Renderer does not enforce this check; hence, by default, React Native Testing Library also does not check this. That might result in runtime errors when running your code on a device, while the code works without errors in tests.
+:::
 
 ### Result
 
-The `render` function returns the same queries and utilities as the [`screen`](docs/api/screen) object. We recommended using the `screen` object as more developer-friendly way.
+The `render` function returns a promise that resolves to the same queries and utilities as the [`screen`](docs/api/screen) object. We recommend using the `screen` object for queries and the lifecycle methods from the render result when needed.
 
 See [this article](https://kentcdodds.com/blog/common-mistakes-with-react-testing-library#not-using-screen) from Kent C. Dodds for more details.
 
-## `renderAsync` function {#render-async}
+:::warning Async lifecycle methods
 
-:::info RNTL minimal version
+When using `render`, the lifecycle methods `rerender`, `update`, and `unmount` are async and must be awaited.
 
-This API requires RNTL v13.3.0 or later.
+:::
+
+## `unsafe_renderSync` function {#unsafe-render-sync}
+
+:::warning Deprecated
+
+This function is deprecated and provided for migration purposes only. Use async `render` instead.
 
 :::
 
 ```tsx
-async function renderAsync(
+function unsafe_renderSync(
   component: React.Element<any>,
-  options?: RenderAsyncOptions
-): Promise<RenderAsyncResult>;
+  options?: RenderSyncOptions
+): RenderSyncResult;
 ```
 
-The `renderAsync` function is the async version of [`render`](#render) designed for working with React 19 and React Suspense. This function uses async `act` function internally to ensure all pending React updates are executed during rendering.
+The `unsafe_renderSync` function is the synchronous version of [`render`](#render). It was the default `render` function in previous versions but is now deprecated in favor of the async `render` function.
 
 ```jsx
-import { renderAsync, screen } from '@testing-library/react-native';
+import { unsafe_renderSync, screen } from '@testing-library/react-native';
 
-test('async component test', async () => {
-  await renderAsync(<MyAsyncApp />);
+test('sync component test', () => {
+  unsafe_renderSync(<MyApp />);
   expect(screen.getAllByRole('button', { name: 'start' })).toBeOnTheScreen();
 });
 ```
 
 ### Options
 
-`renderAsync` accepts the same options as `render`.
+`unsafe_renderSync` accepts the same options as `render`.
 
 ### Result
 
-The `renderAsync` function returns a promise that resolves to the same queries and utilities as the [`screen`](docs/api/screen) object. We recommend using the `screen` object for queries and the lifecycle methods from the render result when needed.
+The `unsafe_renderSync` function returns the same queries and utilities as the [`screen`](docs/api/screen) object. We recommended using the `screen` object as more developer-friendly way.
 
-:::warning Async lifecycle methods
+:::note Migration
 
-When using `renderAsync`, you have to use correspodning lifecycle methods: `rerenderAsync` and `unmountAsync` instead of their sync versions.
+To migrate from `unsafe_renderSync` to `render`, see the [migration guide](../migration/v14#render-async-default).
 
 :::
diff --git a/website/docs/14.x/docs/api/screen.mdx b/website/docs/14.x/docs/api/screen.mdx
index d9cf25865..0d9b9142d 100644
--- a/website/docs/14.x/docs/api/screen.mdx
+++ b/website/docs/14.x/docs/api/screen.mdx
@@ -3,12 +3,12 @@
 ```ts
 let screen: {
   ...queries;
-  rerender(element: React.Element<unknown>): void;
-  unmount(): void;
+  rerender(element: React.Element<unknown>): Promise<void>;
+  unmount(): Promise<void>;
   debug(options?: DebugOptions): void
-  toJSON(): ReactTestRendererJSON | null;
-  root: ReactTestInstance;
-  UNSAFE_root: ReactTestInstance;
+  toJSON(): JsonElement | null;
+  container: HostElement;
+  root: HostElement;
 };
 ```
 
@@ -27,8 +27,10 @@ See [Queries](docs/api/queries) for a complete list.
 ```jsx
 import { render, screen } from '@testing-library/react-native';
 
-render(<MyComponent />);
-const buttonStart = screen.getByRole('button', { name: 'start' });
+test('example', async () => {
+  await render(<MyComponent />);
+  const buttonStart = screen.getByRole('button', { name: 'start' });
+});
 ```
 
 ### `rerender`
@@ -36,32 +38,20 @@ const buttonStart = screen.getByRole('button', { name: 'start' });
 _Also available under `update` alias_
 
 ```ts
-function rerender(element: React.Element<unknown>): void;
+function rerender(element: React.Element<unknown>): Promise<void>;
 ```
 
 Re-render the in-memory tree with a new root element. This simulates a React update render at the root. If the new element has the same type (and `key`) as the previous element, the tree will be updated; otherwise, it will re-mount a new tree, in both cases triggering the appropriate lifecycle events.
 
-### `rerenderAsync`
-
-_Also available under `updateAsync` alias_
-
-:::info RNTL minimal version
-This API requires RNTL v13.3.0 or later.
-:::
-
-```ts
-function rerenderAsync(element: React.Element<unknown>): Promise<void>;
-```
-
-Async versions of [`rerender`](#rerender) designed for working with React 19 and React Suspense. This method uses async `act` function internally to ensure all pending React updates are executed during updating.
+This method is async and uses async `act` function internally to ensure all pending React updates are executed during updating, making it compatible with React 19, React Suspense, and `React.use()`.
 
 ```jsx
-import { renderAsync, screen } from '@testing-library/react-native';
+import { render, screen } from '@testing-library/react-native';
 
 test('async rerender test', async () => {
-  await renderAsync(<MyComponent initialData="first" />);
+  await render(<MyComponent initialData="first" />);
 
-  await screen.rerenderAsync(<MyComponent initialData="updated" />);
+  await screen.rerender(<MyComponent initialData="updated" />);
   expect(screen.getByText('updated')).toBeOnTheScreen();
 });
 ```
@@ -69,33 +59,19 @@ test('async rerender test', async () => {
 ### `unmount`
 
 ```ts
-function unmount(): void;
+function unmount(): Promise<void>;
 ```
 
 Unmount the in-memory tree, triggering the appropriate lifecycle events.
 
+This method is async and uses async `act` function internally to ensure all pending React updates are executed during unmounting, making it compatible with React 19, React Suspense, and `React.use()`.
+
 :::note
 
 Usually you should not need to call `unmount` as it is done automatically if your test runner supports `afterEach` hook (like Jest, mocha, Jasmine).
 
 :::
 
-### `unmountAsync`
-
-:::info RNTL minimal version
-This API requires RNTL v13.3.0 or later.
-:::
-
-```ts
-function unmountAsync(): Promise<void>;
-```
-
-Async version of [`unmount`](#unmount) designed for working with React 19 and React Suspense. This method uses async `act` function internally to ensure all pending React updates are executed during unmounting.
-
-:::note
-Usually you should not need to call `unmountAsync` as it is done automatically if your test runner supports `afterEach` hook (like Jest, mocha, Jasmine).
-:::
-
 ### `debug`
 
 ```ts
@@ -109,7 +85,7 @@ Pretty prints deeply rendered component passed to `render`.
 You can provide a message that will be printed on top.
 
 ```jsx
-render(<Component />);
+await render(<Component />);
 screen.debug({ message: 'optional message' });
 ```
 
@@ -134,7 +110,7 @@ function debug({ mapProps: (props) => ({}) });
 You can use the `mapProps` option to transform the props that will be printed :
 
 ```jsx
-render(<View style={{ backgroundColor: 'red' }} />);
+await render(<View style={{ backgroundColor: 'red' }} />);
 screen.debug({ mapProps: ({ style, ...props }) => ({ props }) });
 ```
 
@@ -161,33 +137,52 @@ screen.debug({ mapProps: ({ path, ...props }) => ({ ...props }) });
 ### `toJSON`
 
 ```ts
-function toJSON(): ReactTestRendererJSON | null;
+function toJSON(): JsonElement | null;
 ```
 
 Get the rendered component JSON representation, e.g. for snapshot testing.
 
-### `root`
+### `container`
 
 ```ts
-const root: ReactTestInstance;
+const container: HostElement;
 ```
 
-Returns the rendered root [host element](docs/advanced/testing-env#host-and-composite-components).
+Returns a pseudo-element container whose children are the elements you asked to render. This is the root container element from [Universal Test Renderer](https://github.com/mdjastrzebski/universal-test-renderer).
 
-This API is primarily useful for component tests, as it allows you to access root host view without using `*ByTestId` queries or similar methods.
+The `container` is safe to use and provides access to the entire rendered tree. It's useful when you need to query or manipulate the entire rendered output, similar to how `container` works in [React Testing Library](https://testing-library.com/docs/react-testing-library/other#container-1).
+
+```jsx
+import { render, screen } from '@testing-library/react-native';
 
-### `UNSAFE_root`
+test('example', async () => {
+  await render(<MyComponent />);
+  // container contains the entire rendered tree
+  const container = screen.container;
+  expect(container).toBeTruthy();
+});
+```
 
-:::caution
-This API typically will return a composite view, which goes against recommended testing practices. This API is primarily available for legacy test suites that rely on such testing.
-:::
+### `root`
 
 ```ts
-const UNSAFE_root: ReactTestInstance;
+const root: HostElement;
 ```
 
-Returns the rendered [composite root element](docs/advanced/testing-env#host-and-composite-components).
+Returns the rendered root [host element](docs/advanced/testing-env#host-and-composite-components). This is the first child of the `container`, which represents the actual root element you rendered.
 
-:::note
-This API has been previously named `container` for compatibility with [React Testing Library](https://testing-library.com/docs/react-testing-library/other#container-1). However, despite the same name, the actual behavior has been significantly different; hence, we decided to change the name to `UNSAFE_root`.
-:::
+This API is primarily useful for component tests, as it allows you to access root host view without using `*ByTestId` queries or similar methods.
+
+```jsx
+import { render, screen } from '@testing-library/react-native';
+
+test('example', async () => {
+  await render(
+    <View testID="root-view">
+      <Text>Hello</Text>
+    </View>
+  );
+  // root is the View element you rendered
+  expect(screen.root.props.testID).toBe('root-view');
+});
+```
diff --git a/website/docs/14.x/docs/guides/faq.mdx b/website/docs/14.x/docs/guides/faq.mdx
index 8a446bfb7..005caaa44 100644
--- a/website/docs/14.x/docs/guides/faq.mdx
+++ b/website/docs/14.x/docs/guides/faq.mdx
@@ -8,7 +8,7 @@ React Native Testing Library does not provide an entire React Native runtime sin
 or iOS simulator/Android emulator to provision the underlying OS and platform APIs.
 
 Instead of using React Native renderer, it simulates only the JavaScript part of its runtime
-using [React Test Renderer](https://reactjs.org/docs/test-renderer.html) while providing queries
+using [Universal Test Renderer](https://github.com/mdjastrzebski/universal-test-renderer) while providing queries
 and event APIs ([User Event](docs/api/events/user-event), [Fire Event](docs/api/events/fire-event)) that mimicking certain behaviors from the actual runtime.
 
 You can learn more about our testing environment [here](docs/advanced/testing-env).
diff --git a/website/docs/14.x/docs/guides/how-to-query.mdx b/website/docs/14.x/docs/guides/how-to-query.mdx
index 12be2a442..e3519dd72 100644
--- a/website/docs/14.x/docs/guides/how-to-query.mdx
+++ b/website/docs/14.x/docs/guides/how-to-query.mdx
@@ -18,14 +18,14 @@ For this query, `getBy*` is the query variant, and `*ByRole` is the predicate.
 
 The query variants describe the expected number (and timing) of matching elements, so they differ in their return type.
 
-| Variant                                        | Assertion                     | Return type                                | Is Async? |
-| ---------------------------------------------- | ----------------------------- | ------------------------------------------ | --------- |
-| [`getBy*`](docs/api/queries#get-by)            | Exactly one matching element  | `ReactTestInstance`                        | No        |
-| [`getAllBy*`](docs/api/queries#get-all-by)     | At least one matching element | `Array<ReactTestInstance>`                 | No        |
-| [`queryBy*`](docs/api/queries#query-by)        | Zero or one matching element  | <code>ReactTestInstance &#124; null</code> | No        |
-| [`queryAllBy*`](docs/api/queries#query-all-by) | No assertion                  | `Array<ReactTestInstance>`                 | No        |
-| [`findBy*`](docs/api/queries#find-by)          | Exactly one matching element  | `Promise<ReactTestInstance>`               | Yes       |
-| [`findAllBy*`](docs/api/queries#find-all-by)   | At least one matching element | `Promise<Array<ReactTestInstance>>`        | Yes       |
+| Variant                                        | Assertion                     | Return type                          | Is Async? |
+| ---------------------------------------------- | ----------------------------- | ------------------------------------ | --------- |
+| [`getBy*`](docs/api/queries#get-by)            | Exactly one matching element  | `HostElement`                        | No        |
+| [`getAllBy*`](docs/api/queries#get-all-by)     | At least one matching element | `Array<HostElement>`                 | No        |
+| [`queryBy*`](docs/api/queries#query-by)        | Zero or one matching element  | <code>HostElement &#124; null</code> | No        |
+| [`queryAllBy*`](docs/api/queries#query-all-by) | No assertion                  | `Array<HostElement>`                 | No        |
+| [`findBy*`](docs/api/queries#find-by)          | Exactly one matching element  | `Promise<HostElement>`               | Yes       |
+| [`findAllBy*`](docs/api/queries#find-all-by)   | At least one matching element | `Promise<Array<HostElement>>`        | Yes       |
 
 Queries work as implicit assertions on the number of matching elements and will throw an error when the assertion fails.
 
diff --git a/website/docs/14.x/docs/guides/react-19.mdx b/website/docs/14.x/docs/guides/react-19.mdx
index cfb61cbbf..c04b96f0c 100644
--- a/website/docs/14.x/docs/guides/react-19.mdx
+++ b/website/docs/14.x/docs/guides/react-19.mdx
@@ -6,13 +6,13 @@ When testing components that use these features, React requires the [`async act`
 
 ## New async APIs
 
-RNTL 13.3 introduces async versions of the core testing APIs to handle React 19's async rendering:
+RNTL 14 introduces async versions of the core testing APIs to handle React 19's async rendering:
 
 **Rendering APIs:**
 
-- **[`renderAsync`](docs/api/render#render-async)** - async version of `render`
-- **[`screen.rerenderAsync`](docs/api/screen#rerender-async)** - async version of `screen.rerender`
-- **[`screen.unmountAsync`](docs/api/screen#unmount-async)** - async version of `screen.unmount`
+- **[`render`](docs/api/render#render)** - now async by default (was `renderAsync` in v13)
+- **[`screen.rerender`](docs/api/screen#rerender)** - now async (returns `Promise<void>`)
+- **[`screen.unmount`](docs/api/screen#unmount)** - now async (returns `Promise<void>`)
 
 **Event APIs:**
 
@@ -30,21 +30,21 @@ Many existing APIs continue to work without modification:
 
 ### Making tests async
 
-The main change is using [`renderAsync`](docs/api/render#renderasync) instead of `render`, which requires:
+The main change is using [`render`](docs/api/render#render) which is now async by default, which requires:
 
 1. Making your test function `async`
-2. Adding `await` before `renderAsync`
+2. Adding `await` before `render`
 
 ```tsx
-// Synchronous approach (React 18 pattern)
+// Synchronous approach (deprecated in v14)
 test('my component', () => {
-  render(<MyComponent />);
+  unsafe_renderSync(<MyComponent />);
   expect(screen.getByText('Hello')).toBeOnTheScreen();
 });
 
-// Async approach (React 19 ready)
+// Async approach (React 19 ready, default in v14)
 test('my component', async () => {
-  await renderAsync(<MyComponent />);
+  await render(<MyComponent />);
   expect(screen.getByText('Hello')).toBeOnTheScreen();
 });
 ```
@@ -61,16 +61,16 @@ Use the async APIs when your components:
 
 ### New projects
 
-Use the async-ready APIs (`renderAsync`, User Event, Jest Matchers, etc.) from the start. They work with both React 18 and React 19.
+Use the async-ready APIs (`render`, User Event, Jest Matchers, etc.) from the start. They work with both React 18 and React 19.
 
 ### Existing projects
 
 You can migrate gradually:
 
-- **Existing tests** continue to work with synchronous APIs (`render`, etc.)
-- **New tests** should use async APIs
-- **Tests with Suspense/`React.use()`** must use async APIs
+- **Existing tests** can use `unsafe_renderSync` for backward compatibility
+- **New tests** should use async `render` (default in v14)
+- **Tests with Suspense/`React.use()`** must use async `render`
 
-### Future direction
+### Migration
 
-Async APIs will become the default recommendation as React 19 adoption grows. Starting with them now saves migration effort later.
+See the [v14 migration guide](../migration/v14#render-async-default) for detailed migration steps from `unsafe_renderSync` to `render`.
diff --git a/website/docs/14.x/docs/guides/troubleshooting.mdx b/website/docs/14.x/docs/guides/troubleshooting.mdx
index 3ed8ae6b9..1ad97bee2 100644
--- a/website/docs/14.x/docs/guides/troubleshooting.mdx
+++ b/website/docs/14.x/docs/guides/troubleshooting.mdx
@@ -2,17 +2,17 @@
 
 This guide describes common issues found by users when integrating React Native Test Library to their projects:
 
-## Matching React Native, React & React Test Renderer versions
+## Matching React Native, React & Universal Test Renderer versions
 
 Check that you have matching versions of core dependencies:
 
 - React Native
 - React
-- React Test Renderer
+- Universal Test Renderer (automatically installed with RNTL)
 
 React Native uses different versioning scheme from React, you can use [React Native Upgrade Helper](https://react-native-community.github.io/upgrade-helper/) to find the correct matching between React Native & React versions. In case you use Expo, run `npx expo install --fix` in your project to validate and install compatible versions of these dependencies.
 
-React Test Renderer usually has same major & minor version as React, as they are closely related and React Test Renderer is part of [React monorepo](https://github.com/facebook/react).
+Universal Test Renderer is automatically managed as a dependency of React Native Testing Library and is compatible with React 18 and React 19.
 
 Related issues: [#1061](https://github.com/callstack/react-native-testing-library/issues/1061), [#938](https://github.com/callstack/react-native-testing-library/issues/938), [#920](https://github.com/callstack/react-native-testing-library/issues/920)
 
diff --git a/website/docs/14.x/docs/migration/previous/v12.mdx b/website/docs/14.x/docs/migration/previous/v12.mdx
index cf14509f5..249893e50 100644
--- a/website/docs/14.x/docs/migration/previous/v12.mdx
+++ b/website/docs/14.x/docs/migration/previous/v12.mdx
@@ -55,7 +55,7 @@ While following elements will not match:
 
 While potentially breaking, this should not cause issues in tests if you are using recommended queries and Jest Matchers from Jest Native package.
 
-Problematic cases may include: directly checking some prop values (without using Jest Native matchers), referencing other nodes using `parent` or `children` props, examining `type` property of `ReactTestInstance`, etc.
+Problematic cases may include: directly checking some prop values (without using Jest Native matchers), referencing other nodes using `parent` or `children` props, examining `type` property of `HostElement`, etc.
 
 ### 4. `container` API has been renamed to `UNSAFE_root`.
 
diff --git a/website/docs/14.x/docs/migration/previous/v2.mdx b/website/docs/14.x/docs/migration/previous/v2.mdx
index 8eb61e23e..7870096ee 100644
--- a/website/docs/14.x/docs/migration/previous/v2.mdx
+++ b/website/docs/14.x/docs/migration/previous/v2.mdx
@@ -72,7 +72,7 @@ Shallow rendering React component is usually not a good idea, so we decided to r
 ```js
 import ShallowRenderer from 'react-test-renderer/shallow';
 
-export function shallow(instance: ReactTestInstance | React.Element<any>) {
+export function shallow(instance: HostElement | React.Element<any>) {
   const renderer = new ShallowRenderer();
   renderer.render(React.createElement(instance.type, instance.props));
 
diff --git a/website/docs/14.x/docs/migration/previous/v7.mdx b/website/docs/14.x/docs/migration/previous/v7.mdx
index e3305669c..482681409 100644
--- a/website/docs/14.x/docs/migration/previous/v7.mdx
+++ b/website/docs/14.x/docs/migration/previous/v7.mdx
@@ -95,7 +95,7 @@ You can opt-out of this behavior by running tests with `RNTL_SKIP_AUTO_CLEANUP=t
 
 ### No [NativeTestInstance](https://www.native-testing-library.com/docs/api-test-instance) abstraction
 
-We don't provide any abstraction over `ReactTestInstance` returned by queries, but allow to use it directly to access queried component's `props` or `type` for that example.
+We don't provide any abstraction over `HostElement` returned by queries, but allow to use it directly to access queried component's `props` or `type` for that example.
 
 ### No `container` nor `baseElement` returned from `render`
 
@@ -109,7 +109,7 @@ There are slight differences in how `fireEvent` works in both libraries:
 1. Signature is different:
    ```diff
    -fireEvent[eventName](node: FiberRoot, eventProperties: NativeTestEvent)
-   +fireEvent(element: ReactTestInstance, eventName: string, ...data: Array<any>)
+   +fireEvent(element: HostElement, eventName: string, ...data: Array<any>)
    ```
 1. There is no `NativeTestEvent` - second and rest arguments are used instead.
 1. There are only 3 short-hand events: [`fireEvent.press`](docs/api/events/fire-event#press), [`fireEvent.changeText`](docs/api/events/fire-event#change-text) and [`fireEvent.scroll`](docs/api/events/fire-event#scroll). For all other or custom events you can use the base signature.
diff --git a/website/docs/14.x/docs/migration/v14.mdx b/website/docs/14.x/docs/migration/v14.mdx
index 49d974199..908f22378 100644
--- a/website/docs/14.x/docs/migration/v14.mdx
+++ b/website/docs/14.x/docs/migration/v14.mdx
@@ -4,63 +4,245 @@ This guide describes the migration to React Native Testing Library version 14 fr
 
 ## Breaking changes
 
-### `fireEvent` is now async by default
+### Universal Test Renderer replaces React Test Renderer
 
-In v14, `fireEvent` and its helpers (`press`, `changeText`, `scroll`) are now async by default and return a Promise. This change makes it compatible with React 19, React Suspense, and `React.use()`.
+In v14, React Native Testing Library now uses [Universal Test Renderer](https://github.com/mdjastrzebski/universal-test-renderer) instead of the deprecated `react-test-renderer` package. Universal Test Renderer is a modern, actively maintained alternative that provides better compatibility with React 19 and improved type safety.
+
+**What changed:**
+
+- The underlying rendering engine has been switched from `react-test-renderer` to `universal-test-renderer`
+- This change is mostly internal and should not require code changes in most cases
+- Type definitions have been updated to use `HostElement` from Universal Test Renderer instead of `ReactTestInstance`
+
+**Migration:**
+
+#### 1. Update dependencies
+
+Remove `react-test-renderer` and its type definitions from your dev dependencies, and add `universal-test-renderer`:
+
+```bash
+# Using npm
+npm uninstall react-test-renderer @types/react-test-renderer
+npm install -D universal-test-renderer@^0.10.0
+
+# Using yarn
+yarn remove react-test-renderer @types/react-test-renderer
+yarn add -D universal-test-renderer@^0.10.0
+
+# Using pnpm
+pnpm remove react-test-renderer @types/react-test-renderer
+pnpm add -D universal-test-renderer@^0.10.0
+```
+
+#### 2. Update type imports (if needed)
+
+If you were directly importing types from `react-test-renderer`, you may need to update your imports:
+
+```ts
+// Before (v13)
+import type { ReactTestInstance } from 'react-test-renderer';
+
+// After (v14)
+import type { HostElement } from 'universal-test-renderer';
+```
+
+**Note:** Most users won't need to update type imports, as React Native Testing Library now exports the necessary types directly.
+
+For more details, see the [Universal Test Renderer documentation](https://github.com/mdjastrzebski/universal-test-renderer).
+
+### `container` API reintroduced
+
+In v14, the `container` API has been reintroduced and is now safe to use. Previously, `container` was renamed to `UNSAFE_root` in v12 due to behavioral differences from React Testing Library's `container`. In v14, `container` now returns a pseudo-element container whose children are the elements you asked to render, making it safe and consistent with React Testing Library's behavior.
+
+**What changed:**
+
+- `screen.container` is now available and safe to use
+- `container` returns a pseudo-element container from Universal Test Renderer
+- The container's children are the elements you rendered
+- `UNSAFE_root` has been removed
 
 **Before (v13):**
 
 ```ts
-import { fireEvent, screen } from '@testing-library/react-native';
+import { render, screen } from '@testing-library/react-native';
 
-it('should press button', () => {
+it('should access root', () => {
   render(<MyComponent />);
-  fireEvent.press(screen.getByText('Press me'));
-  expect(onPress).toHaveBeenCalled();
+  // UNSAFE_root was the only way to access the container
+  const root = screen.UNSAFE_root;
 });
 ```
 
 **After (v14):**
 
 ```ts
-import { fireEvent, screen } from '@testing-library/react-native';
+import { render, screen } from '@testing-library/react-native';
+
+it('should access container', async () => {
+  await render(<MyComponent />);
+  // container is now safe and available
+  const container = screen.container;
+  // root is the first child of container
+  const root = screen.root;
+});
+```
 
-it('should press button', async () => {
+**Migration:**
+
+If you were using `UNSAFE_root`, replace it with `container`:
+
+```ts
+// Before
+const root = screen.UNSAFE_root;
+
+// After
+const container = screen.container;
+// Or use screen.root if you need the actual root element
+const root = screen.root;
+```
+
+For more details, see the [`screen` API documentation](/docs/api/screen#container).
+
+### `render` is now async by default {#render-async-default}
+
+In v14, `render` is now async by default and returns a Promise. The previous synchronous `render` function has been renamed to `unsafe_renderSync`. This change makes it compatible with React 19, React Suspense, and `React.use()`.
+
+**Before (v13):**
+
+```ts
+import { render, screen } from '@testing-library/react-native';
+
+it('should render component', () => {
   render(<MyComponent />);
-  await fireEvent.press(screen.getByText('Press me'));
-  expect(onPress).toHaveBeenCalled();
+  expect(screen.getByText('Hello')).toBeOnTheScreen();
+});
+```
+
+**After (v14):**
+
+```ts
+import { render, screen } from '@testing-library/react-native';
+
+it('should render component', async () => {
+  await render(<MyComponent />);
+  expect(screen.getByText('Hello')).toBeOnTheScreen();
 });
 ```
 
-### Migration path
+#### Migration path
 
-To ease migration, we provide `deprecated_fireEventSync` which maintains the same synchronous behavior as v13. This allows you to migrate gradually.
+To ease migration, we provide `unsafe_renderSync` which maintains the same synchronous behavior as v13. This allows you to migrate gradually.
 
-#### `deprecated_fireEventSync` {#deprecated-fire-event-sync}
+##### `unsafe_renderSync` {#unsafe-render-sync}
 
 ```ts
-function deprecated_fireEventSync(
-  element: ReactTestInstance,
-  eventName: string,
-  ...data: unknown[]
-): void;
+function unsafe_renderSync(
+  component: React.Element<any>,
+  options?: RenderSyncOptions
+): RenderSyncResult;
 ```
 
-**⚠️ Deprecated**: This function is provided for migration purposes only. Use async `fireEvent` instead.
+**⚠️ Deprecated**: This function is provided for migration purposes only. Use async `render` instead.
 
-The synchronous version of `fireEvent` that returns immediately without awaiting React updates. This maintains backward compatibility with v13 tests but is not recommended for new code.
+The synchronous version of `render` that returns immediately without awaiting React updates. This maintains backward compatibility with v13 tests but is not recommended for new code.
 
 ```ts
 // Old v13 code (still works but deprecated)
-import { deprecated_fireEventSync } from '@testing-library/react-native';
+import { unsafe_renderSync } from '@testing-library/react-native';
 
-it('should press button', () => {
-  render(<MyComponent />);
-  deprecated_fireEventSync.press(screen.getByText('Press me'));
-  expect(onPress).toHaveBeenCalled();
+it('should render component', () => {
+  unsafe_renderSync(<MyComponent />);
+  expect(screen.getByText('Hello')).toBeOnTheScreen();
 });
 ```
 
+#### Step-by-step migration guide
+
+To migrate from `unsafe_renderSync` to `render`:
+
+##### 1. Add `async` to your test function
+
+```ts
+// Before
+it('should render component', () => {
+
+// After
+it('should render component', async () => {
+```
+
+##### 2. Await `render`
+
+```ts
+// Before
+render(<MyComponent />);
+
+// After
+await render(<MyComponent />);
+```
+
+##### 3. Update `rerender` calls to await
+
+```ts
+// Before
+screen.rerender(<MyComponent />);
+
+// After
+await screen.rerender(<MyComponent />);
+```
+
+##### 4. Update `unmount` calls to await
+
+```ts
+// Before
+screen.unmount();
+
+// After
+await screen.unmount();
+```
+
+#### Complete example
+
+**Before (v13):**
+
+```ts
+import { render, screen } from '@testing-library/react-native';
+
+it('should update component', () => {
+  render(<Counter initialCount={0} />);
+  expect(screen.getByText('Count: 0')).toBeOnTheScreen();
+
+  screen.rerender(<Counter initialCount={5} />);
+  expect(screen.getByText('Count: 5')).toBeOnTheScreen();
+
+  screen.unmount();
+});
+```
+
+**After (v14):**
+
+```ts
+import { render, screen } from '@testing-library/react-native';
+
+it('should update component', async () => {
+  await render(<Counter initialCount={0} />);
+  expect(screen.getByText('Count: 0')).toBeOnTheScreen();
+
+  await screen.rerender(<Counter initialCount={5} />);
+  expect(screen.getByText('Count: 5')).toBeOnTheScreen();
+
+  await screen.unmount();
+});
+```
+
+#### Benefits of async `render`
+
+- **React 19 compatibility**: Works seamlessly with React 19's async features
+- **Suspense support**: Properly handles React Suspense boundaries and `React.use()`
+- **Better timing**: Ensures all pending React updates are executed before assertions
+- **Future-proof**: Aligns with React's direction toward async rendering
+
+For more details, see the [`render` API documentation](/docs/api/render).
+
 ### `renderHook` is now async by default
 
 In v14, `renderHook` is now async by default and returns a Promise. This change makes it compatible with React 19, React Suspense, and `React.use()`.
@@ -91,14 +273,14 @@ it('should test hook', async () => {
 });
 ```
 
-### Migration path
+#### Migration path
 
-To ease migration, we provide `deprecated_renderHookSync` which maintains the same synchronous behavior as v13. This allows you to migrate gradually.
+To ease migration, we provide `unsafe_renderHookSync` which maintains the same synchronous behavior as v13. This allows you to migrate gradually.
 
-#### `deprecated_renderHookSync` {#deprecated-render-hook-sync}
+##### `unsafe_renderHookSync` {#unsafe-render-hook-sync}
 
 ```ts
-function deprecated_renderHookSync<Result, Props>(
+function unsafe_renderHookSync<Result, Props>(
   hookFn: (props?: Props) => Result,
   options?: RenderHookOptions<Props>
 ): RenderHookSyncResult<Result, Props>;
@@ -110,10 +292,10 @@ The synchronous version of `renderHook` that returns immediately without awaitin
 
 ```ts
 // Old v13 code (still works but deprecated)
-import { deprecated_renderHookSync } from '@testing-library/react-native';
+import { unsafe_renderHookSync } from '@testing-library/react-native';
 
 it('should increment count', () => {
-  const { result, rerender } = deprecated_renderHookSync(() => useCount());
+  const { result, rerender } = unsafe_renderHookSync(() => useCount());
 
   expect(result.current.count).toBe(0);
   act(() => {
@@ -125,7 +307,7 @@ it('should increment count', () => {
 });
 ```
 
-#### Result types
+##### Result types
 
 **v13 (deprecated):**
 
@@ -149,11 +331,11 @@ interface RenderHookResult<Result, Props> {
 
 **Note**: Both `RenderHookSyncResult` and `RenderHookResult` use `rerender` and `unmount` methods. The difference is that `RenderHookSyncResult` methods are synchronous (return `void`), while `RenderHookResult` methods are async (return `Promise<void>`).
 
-## Step-by-step migration guide
+#### Step-by-step migration guide
 
-To migrate from `deprecated_renderHookSync` to `renderHook`:
+To migrate from `unsafe_renderHookSync` to `renderHook`:
 
-### 1. Add `async` to your test function
+##### 1. Add `async` to your test function
 
 ```ts
 // Before
@@ -163,17 +345,17 @@ it('should test hook', () => {
 it('should test hook', async () => {
 ```
 
-### 2. Await `renderHook`
+##### 2. Await `renderHook`
 
 ```ts
 // Before
-const { result } = deprecated_renderHookSync(() => useMyHook());
+const { result } = unsafe_renderHookSync(() => useMyHook());
 
 // After
 const { result } = await renderHook(() => useMyHook());
 ```
 
-### 3. Update `rerender` calls to await
+##### 3. Update `rerender` calls to await
 
 ```ts
 // Before
@@ -183,7 +365,7 @@ rerender(newProps);
 await rerender(newProps);
 ```
 
-### 4. Update `unmount` calls to await
+##### 4. Update `unmount` calls to await
 
 ```ts
 // Before
@@ -193,7 +375,7 @@ unmount();
 await unmount();
 ```
 
-### 5. Update `act` calls to use async `act`
+##### 5. Update `act` calls to use async `act`
 
 ```ts
 // Before
@@ -207,7 +389,7 @@ await act(async () => {
 });
 ```
 
-## Complete example
+#### Complete example
 
 **Before (v13):**
 
@@ -253,7 +435,7 @@ it('should increment count', async () => {
 });
 ```
 
-## Benefits of async `renderHook`
+#### Benefits of async `renderHook`
 
 - **React 19 compatibility**: Works seamlessly with React 19's async features
 - **Suspense support**: Properly handles React Suspense boundaries and `React.use()`
@@ -261,3 +443,83 @@ it('should increment count', async () => {
 - **Future-proof**: Aligns with React's direction toward async rendering
 
 For more details, see the [`renderHook` API documentation](/docs/api/misc/render-hook).
+
+### `fireEvent` is now async by default
+
+In v14, `fireEvent` and its helpers (`press`, `changeText`, `scroll`) are now async by default and return a Promise. This change makes it compatible with React 19, React Suspense, and `React.use()`.
+
+**Before (v13):**
+
+```ts
+import { fireEvent, screen } from '@testing-library/react-native';
+
+it('should press button', () => {
+  render(<MyComponent />);
+  fireEvent.press(screen.getByText('Press me'));
+  expect(onPress).toHaveBeenCalled();
+});
+```
+
+**After (v14):**
+
+```ts
+import { fireEvent, screen } from '@testing-library/react-native';
+
+it('should press button', async () => {
+  render(<MyComponent />);
+  await fireEvent.press(screen.getByText('Press me'));
+  expect(onPress).toHaveBeenCalled();
+});
+```
+
+#### Migration path
+
+To ease migration, we provide `unsafe_fireEventSync` which maintains the same synchronous behavior as v13. This allows you to migrate gradually.
+
+##### `unsafe_fireEventSync` {#unsafe-fire-event-sync}
+
+```ts
+function unsafe_fireEventSync(element: HostElement, eventName: string, ...data: unknown[]): void;
+```
+
+**⚠️ Deprecated**: This function is provided for migration purposes only. Use async `fireEvent` instead.
+
+The synchronous version of `fireEvent` that returns immediately without awaiting React updates. This maintains backward compatibility with v13 tests but is not recommended for new code.
+
+```ts
+// Old v13 code (still works but deprecated)
+import { unsafe_fireEventSync } from '@testing-library/react-native';
+
+it('should press button', () => {
+  render(<MyComponent />);
+  unsafe_fireEventSync.press(screen.getByText('Press me'));
+  expect(onPress).toHaveBeenCalled();
+});
+```
+
+### Text string validation now enforced by default
+
+In v14, Universal Test Renderer automatically enforces React Native's requirement that text strings must be rendered within a `<Text>` component. This means the `unstable_validateStringsRenderedWithinText` option has been removed from `RenderOptions`, as this validation is now always enabled.
+
+**What changed:**
+
+- Text string validation is now always enabled and cannot be disabled
+- The `unstable_validateStringsRenderedWithinText` option has been removed
+- Tests will now throw `Invariant Violation: Text strings must be rendered within a <Text> component` errors when attempting to render strings outside of `<Text>` components, matching React Native's runtime behavior
+
+**Migration:**
+
+If you were using `unstable_validateStringsRenderedWithinText: true` in your render options, you can simply remove this option as the validation is now always enabled:
+
+```ts
+// Before (v13)
+await render(<MyComponent />, {
+  unstable_validateStringsRenderedWithinText: true,
+});
+
+// After (v14)
+await render(<MyComponent />);
+// Validation is now always enabled
+```
+
+If you were relying on the previous behavior where strings could be rendered outside of `<Text>` components, you'll need to fix your components to wrap strings in `<Text>` components, as this matches React Native's actual runtime behavior.
diff --git a/website/docs/14.x/docs/start/intro.md b/website/docs/14.x/docs/start/intro.md
index 9da2bc174..00bfb76be 100644
--- a/website/docs/14.x/docs/start/intro.md
+++ b/website/docs/14.x/docs/start/intro.md
@@ -6,7 +6,7 @@ You want to write maintainable tests for your React Native components. As a part
 
 ## This solution
 
-The React Native Testing Library (RNTL) is a lightweight solution for testing React Native components. It provides light utility functions on top of React Test Renderer, in a way that encourages better testing practices. Its primary guiding principle is:
+The React Native Testing Library (RNTL) is a lightweight solution for testing React Native components. It provides light utility functions on top of [Universal Test Renderer](https://github.com/mdjastrzebski/universal-test-renderer), in a way that encourages better testing practices. Its primary guiding principle is:
 
 > The more your tests resemble how your software is used, the more confidence they can give you.
 
diff --git a/website/docs/14.x/docs/start/quick-start.mdx b/website/docs/14.x/docs/start/quick-start.mdx
index 8a813a9ae..4871874d5 100644
--- a/website/docs/14.x/docs/start/quick-start.mdx
+++ b/website/docs/14.x/docs/start/quick-start.mdx
@@ -13,7 +13,7 @@ Open a Terminal in your project's folder and run:
   }}
 />
 
-This library has a peer dependency for `react-test-renderer` package. Make sure that your `react-test-renderer` version matches exactly your `react` version.
+This library uses [Universal Test Renderer](https://github.com/mdjastrzebski/universal-test-renderer) as its underlying rendering engine. Universal Test Renderer is automatically installed as a dependency and provides better compatibility with React 19 and improved type safety compared to the deprecated `react-test-renderer` package.
 
 ### Jest matchers