diff --git a/packages/jest-preset/jest/mocks/RendererProxy.js b/packages/jest-preset/jest/mocks/RendererProxy.js
index e6139fadf4e5..a6b412b146fd 100644
--- a/packages/jest-preset/jest/mocks/RendererProxy.js
+++ b/packages/jest-preset/jest/mocks/RendererProxy.js
@@ -23,7 +23,6 @@ const {
   isProfilingRenderer,
   renderElement,
   sendAccessibilityEvent,
-  unmountComponentAtNodeAndRemoveContainer,
   unstable_batchedUpdates,
 } = jest.requireActual<TRendererImplementation>(
   'react-native/Libraries/ReactNative/RendererImplementation',
@@ -40,6 +39,5 @@ export {
   isProfilingRenderer,
   renderElement,
   sendAccessibilityEvent,
-  unmountComponentAtNodeAndRemoveContainer,
   unstable_batchedUpdates,
 };
diff --git a/packages/react-native/Libraries/Components/TextInput/__tests__/TextInput-itest.js b/packages/react-native/Libraries/Components/TextInput/__tests__/TextInput-itest.js
index fd69977b889e..fc3984b6281c 100644
--- a/packages/react-native/Libraries/Components/TextInput/__tests__/TextInput-itest.js
+++ b/packages/react-native/Libraries/Components/TextInput/__tests__/TextInput-itest.js
@@ -148,6 +148,138 @@ describe('<TextInput>', () => {
         expect(blurEvent).toHaveBeenCalledTimes(1);
       });
     });
+
+    describe('id and nativeID', () => {
+      it(`has 'id' propagated as 'nativeID' to the mounting layer`, () => {
+        const root = Fantom.createRoot();
+
+        Fantom.runTask(() => {
+          root.render(<TextInput id="alpha" />);
+        });
+
+        expect(root.getRenderedOutput({props: ['nativeID']}).toJSX()).toEqual(
+          <rn-androidTextInput nativeID="alpha" />,
+        );
+      });
+
+      it(`has 'nativeID' propagated correctly`, () => {
+        const root = Fantom.createRoot();
+
+        Fantom.runTask(() => {
+          root.render(<TextInput nativeID="alpha" />);
+        });
+
+        expect(root.getRenderedOutput({props: ['nativeID']}).toJSX()).toEqual(
+          <rn-androidTextInput nativeID="alpha" />,
+        );
+      });
+
+      it(`has a precedence of 'id' over 'nativeID'`, () => {
+        const root = Fantom.createRoot();
+
+        Fantom.runTask(() => {
+          root.render(<TextInput id="alpha" nativeID="gamma" />);
+        });
+
+        expect(root.getRenderedOutput({props: ['nativeID']}).toJSX()).toEqual(
+          <rn-androidTextInput nativeID="alpha" />,
+        );
+      });
+    });
+
+    describe('testID', () => {
+      it('is propagated to the mounting layer', () => {
+        const root = Fantom.createRoot();
+
+        Fantom.runTask(() => {
+          root.render(<TextInput testID="my-test-id" />);
+        });
+
+        expect(root.getRenderedOutput({props: ['testID']}).toJSX()).toEqual(
+          <rn-androidTextInput testID="my-test-id" />,
+        );
+      });
+    });
+
+    describe('aria-label and accessibilityLabel', () => {
+      it(`has 'aria-label' propagated as 'accessibilityLabel'`, () => {
+        const root = Fantom.createRoot();
+
+        Fantom.runTask(() => {
+          root.render(<TextInput aria-label="label" />);
+        });
+
+        expect(
+          root.getRenderedOutput({props: ['accessibilityLabel']}).toJSX(),
+        ).toEqual(<rn-androidTextInput accessibilityLabel="label" />);
+      });
+
+      it(`has 'accessibilityLabel' propagated correctly`, () => {
+        const root = Fantom.createRoot();
+
+        Fantom.runTask(() => {
+          root.render(<TextInput accessibilityLabel="label" />);
+        });
+
+        expect(
+          root.getRenderedOutput({props: ['accessibilityLabel']}).toJSX(),
+        ).toEqual(<rn-androidTextInput accessibilityLabel="label" />);
+      });
+    });
+
+    describe('aria-* and accessibilityState', () => {
+      it(`maps 'aria-*' state props to 'accessibilityState'`, () => {
+        const root = Fantom.createRoot();
+
+        Fantom.runTask(() => {
+          root.render(
+            <TextInput
+              aria-busy={true}
+              aria-checked={true}
+              aria-disabled={true}
+              aria-expanded={true}
+              aria-selected={true}
+            />,
+          );
+        });
+
+        expect(
+          root.getRenderedOutput({props: ['accessibilityState']}).toJSX(),
+        ).toEqual(
+          <rn-androidTextInput accessibilityState="{disabled:true,selected:true,checked:Checked,busy:true,expanded:true}" />,
+        );
+      });
+    });
+
+    describe('accessibilityRole', () => {
+      it('is propagated to the mounting layer', () => {
+        const root = Fantom.createRoot();
+
+        Fantom.runTask(() => {
+          root.render(<TextInput accessibilityRole="button" />);
+        });
+
+        expect(
+          root.getRenderedOutput({props: ['accessibilityRole']}).toJSX(),
+        ).toEqual(<rn-androidTextInput accessibilityRole="button" />);
+      });
+    });
+
+    describe('style', () => {
+      it('propagates style values to the mounting layer', () => {
+        const root = Fantom.createRoot();
+
+        Fantom.runTask(() => {
+          root.render(<TextInput style={{backgroundColor: 'white'}} />);
+        });
+
+        expect(
+          root.getRenderedOutput({props: ['backgroundColor']}).toJSX(),
+        ).toEqual(
+          <rn-androidTextInput backgroundColor="rgba(255, 255, 255, 1)" />,
+        );
+      });
+    });
   });
 
   describe('ref', () => {
@@ -276,6 +408,43 @@ describe('<TextInput>', () => {
           'Command {type: "AndroidTextInput", nativeID: "text-input", name: "focus"}',
         ]);
       });
+
+      it('unfocuses any previously focused TextInput when a new one is focused', () => {
+        const root = Fantom.createRoot();
+        const ref1 = createRef<TextInputInstance>();
+        const ref2 = createRef<TextInputInstance>();
+
+        Fantom.runTask(() => {
+          root.render(
+            <>
+              <TextInput nativeID="text-input-1" ref={ref1} />
+              <TextInput nativeID="text-input-2" ref={ref2} />
+            </>,
+          );
+        });
+
+        const instance1 = nullthrows(ref1.current);
+        const instance2 = nullthrows(ref2.current);
+
+        expect(instance1.isFocused()).toBe(false);
+        expect(instance2.isFocused()).toBe(false);
+
+        Fantom.runTask(() => {
+          instance1.focus();
+        });
+
+        expect(instance1.isFocused()).toBe(true);
+        expect(instance2.isFocused()).toBe(false);
+        expect(TextInput.State.currentlyFocusedInput()).toBe(instance1);
+
+        Fantom.runTask(() => {
+          instance2.focus();
+        });
+
+        expect(instance1.isFocused()).toBe(false);
+        expect(instance2.isFocused()).toBe(true);
+        expect(TextInput.State.currentlyFocusedInput()).toBe(instance2);
+      });
     });
 
     describe('blur()', () => {
@@ -459,4 +628,8 @@ describe('<TextInput>', () => {
       });
     });
   });
+
+  it('has the correct displayName', () => {
+    expect(TextInput.displayName).toBe('TextInput');
+  });
 });
diff --git a/packages/react-native/Libraries/Components/TextInput/__tests__/TextInput-test.js b/packages/react-native/Libraries/Components/TextInput/__tests__/TextInput-test.js
deleted file mode 100644
index 7bd2bc66dd3d..000000000000
--- a/packages/react-native/Libraries/Components/TextInput/__tests__/TextInput-test.js
+++ /dev/null
@@ -1,568 +0,0 @@
-/**
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- *
- * @flow strict-local
- * @format
- */
-
-const ReactNative = require('../../../ReactNative/RendererProxy');
-const {
-  enter,
-  expectRendersMatchingSnapshot,
-} = require('../../../Utilities/ReactNativeTestTools');
-const TextInput = require('../TextInput').default;
-const {create, update} = require('@react-native/jest-preset/jest/renderer');
-const React = require('react');
-const {createRef, useState} = require('react');
-const ReactTestRenderer = require('react-test-renderer');
-
-jest.unmock('../TextInput');
-
-[true, false].forEach(useTextChildren => {
-  describe(`TextInput tests (useTextChildren = ${String(useTextChildren)})`, () => {
-    let input;
-    let inputRef;
-    let onChangeListener;
-    let onChangeTextListener;
-    const initialValue = 'initialValue';
-    beforeEach(async () => {
-      jest.resetModules();
-
-      inputRef = createRef<React.ElementRef<typeof TextInput>>();
-      onChangeListener = jest.fn();
-      onChangeTextListener = jest.fn();
-
-      function TextInputWrapper() {
-        const [state, setState] = useState({text: initialValue});
-
-        return (
-          <TextInput
-            ref={inputRef}
-            value={useTextChildren ? undefined : state.text}
-            onChangeText={text => {
-              onChangeTextListener(text);
-              setState({text});
-            }}
-            onChange={event => {
-              onChangeListener(event);
-            }}>
-            {useTextChildren ? state.text : undefined}
-          </TextInput>
-        );
-      }
-      const renderTree = await create(<TextInputWrapper />);
-      input = renderTree.root.findByType(TextInput);
-    });
-
-    it('has expected instance functions', () => {
-      const inputElement = inputRef.current;
-      if (inputElement == null) {
-        throw new Error('Expected `inputElement` to be non-null');
-      }
-
-      expect(inputElement.isFocused).toBeInstanceOf(Function); // Would have prevented S168585
-      expect(inputElement.clear).toBeInstanceOf(Function);
-      // $FlowFixMe[method-unbinding]
-      expect(inputElement.focus).toBeInstanceOf(jest.fn().constructor);
-      // $FlowFixMe[method-unbinding]
-      expect(inputElement.blur).toBeInstanceOf(jest.fn().constructor);
-      // $FlowFixMe[method-unbinding]
-      expect(inputElement.setNativeProps).toBeInstanceOf(jest.fn().constructor);
-      // $FlowFixMe[method-unbinding]
-      expect(inputElement.measure).toBeInstanceOf(jest.fn().constructor);
-      // $FlowFixMe[method-unbinding]
-      expect(inputElement.measureInWindow).toBeInstanceOf(
-        jest.fn().constructor,
-      );
-      // $FlowFixMe[method-unbinding]
-      expect(inputElement.measureLayout).toBeInstanceOf(jest.fn().constructor);
-    });
-    it('calls onChange callbacks', () => {
-      if (!useTextChildren) {
-        expect(input.props.value).toBe(initialValue);
-      } else {
-        expect(input.props.children).toBe(initialValue);
-      }
-      const message = 'This is a test message';
-      ReactTestRenderer.act(() => {
-        enter(input, message);
-      });
-      if (!useTextChildren) {
-        expect(input.props.value).toBe(message);
-      } else {
-        expect(input.props.children).toBe(message);
-      }
-      expect(onChangeTextListener).toHaveBeenCalledWith(message);
-      expect(onChangeListener).toHaveBeenCalledWith({
-        nativeEvent: {text: message},
-      });
-    });
-
-    async function createTextInput(
-      extraProps: ?React.ElementConfig<typeof TextInput>,
-    ) {
-      const textInputRef = createRef<React.ElementRef<typeof TextInput>>();
-      await create(
-        <TextInput
-          ref={textInputRef}
-          value={useTextChildren ? undefined : 'value1'}
-          {...extraProps}>
-          {useTextChildren ? 'value1' : undefined}
-        </TextInput>,
-      );
-      return textInputRef;
-    }
-
-    it('focus() should not do anything if the TextInput is not editable', async () => {
-      const textInputRef = await createTextInput({editable: false});
-      const textInputElement = textInputRef.current;
-      if (textInputElement == null) {
-        throw new Error('Expected `textInputElement` to be non-null');
-      }
-
-      // $FlowFixMe[prop-missing]
-      textInputElement.currentProps = textInputElement.props;
-      expect(textInputElement.isFocused()).toBe(false);
-
-      TextInput.State.focusTextInput(textInputElement);
-      expect(textInputElement.isFocused()).toBe(false);
-    });
-
-    it('should have support for being focused and blurred', async () => {
-      const textInputRef = await createTextInput();
-      const textInputElement = textInputRef.current;
-      if (textInputElement == null) {
-        throw new Error('Expected `textInputElement` to be non-null');
-      }
-
-      expect(textInputElement.isFocused()).toBe(false);
-      jest.spyOn(ReactNative, 'findNodeHandle').mockImplementation(ref => {
-        if (ref == null) {
-          return null;
-        }
-
-        if (
-          ref === textInputElement ||
-          ref === textInputElement.getNativeRef()
-        ) {
-          return 1;
-        }
-
-        return 2;
-      });
-
-      TextInput.State.focusTextInput(textInputElement);
-      expect(textInputElement.isFocused()).toBe(true);
-      expect(TextInput.State.currentlyFocusedInput()).toBe(textInputElement);
-
-      TextInput.State.blurTextInput(textInputElement);
-      expect(textInputElement.isFocused()).toBe(false);
-      expect(TextInput.State.currentlyFocusedInput()).toBe(null);
-    });
-
-    it('change selection keeps content', async () => {
-      const defaultValue = 'value1';
-      // create content
-      let renderTree = await create(
-        // $FlowFixMe[incompatible-use]
-        <TextInput
-          value={useTextChildren ? undefined : defaultValue}
-          position={{start: 1, end: 1}}>
-          {useTextChildren ? defaultValue : undefined}
-        </TextInput>,
-      );
-      input = renderTree.root.findByType(TextInput);
-      expect(
-        // $FlowFixMe[prop-missing]
-        useTextChildren ? input.children[0].props.children : input.props.value,
-      ).toBe(defaultValue);
-      expect(input.props.position.start).toBe(1);
-      expect(input.props.position.end).toBe(1);
-
-      // update position
-      // $FlowFixMe[incompatible-type]
-      renderTree = await update(
-        renderTree,
-        // $FlowFixMe[incompatible-use]
-        <TextInput
-          value={useTextChildren ? undefined : defaultValue}
-          position={{start: 2, end: 2}}>
-          {useTextChildren ? defaultValue : undefined}
-        </TextInput>,
-      );
-      expect(
-        // $FlowFixMe[prop-missing]
-        useTextChildren ? input.children[0].props.children : input.props.value,
-      ).toBe(defaultValue);
-      expect(input.props.position.start).toBe(2);
-      expect(input.props.position.end).toBe(2);
-    });
-
-    it('should unfocus when other TextInput is focused', async () => {
-      const textInputRe1 = createRef<React.ElementRef<typeof TextInput>>();
-      const textInputRe2 = createRef<React.ElementRef<typeof TextInput>>();
-
-      await create(
-        <>
-          <TextInput
-            ref={textInputRe1}
-            value={useTextChildren ? undefined : 'value1'}>
-            {useTextChildren ? 'value1' : undefined}
-          </TextInput>
-          <TextInput
-            ref={textInputRe2}
-            value={useTextChildren ? undefined : 'value2'}>
-            {useTextChildren ? 'value2' : undefined}
-          </TextInput>
-        </>,
-      );
-      jest.spyOn(ReactNative, 'findNodeHandle').mockImplementation(ref => {
-        if (
-          ref === textInputRe1.current ||
-          ref === textInputRe1.current?.getNativeRef()
-        ) {
-          return 1;
-        }
-
-        if (
-          ref === textInputRe2.current ||
-          ref === textInputRe2.current?.getNativeRef()
-        ) {
-          return 2;
-        }
-
-        return 3;
-      });
-
-      expect(textInputRe1.current?.isFocused()).toBe(false);
-      expect(textInputRe2.current?.isFocused()).toBe(false);
-
-      TextInput.State.focusTextInput(textInputRe1.current);
-
-      expect(textInputRe1.current?.isFocused()).toBe(true);
-      expect(textInputRe2.current?.isFocused()).toBe(false);
-      expect(TextInput.State.currentlyFocusedInput()).toBe(
-        textInputRe1.current,
-      );
-
-      TextInput.State.focusTextInput(textInputRe2.current);
-
-      expect(textInputRe1.current?.isFocused()).toBe(false);
-      expect(textInputRe2.current?.isFocused()).toBe(true);
-      expect(TextInput.State.currentlyFocusedInput()).toBe(
-        textInputRe2.current,
-      );
-    });
-
-    it('should give precedence to `textContentType` when set', async () => {
-      const instance = await create(
-        <TextInput autoComplete="tel" textContentType="emailAddress" />,
-      );
-
-      expect(instance.toJSON()).toMatchInlineSnapshot(`
-      <RCTSinglelineTextInputView
-        accessible={true}
-        allowFontScaling={true}
-        focusable={true}
-        mostRecentEventCount={0}
-        onBlur={[Function]}
-        onChange={[Function]}
-        onClick={[Function]}
-        onFocus={[Function]}
-        onResponderGrant={[Function]}
-        onResponderMove={[Function]}
-        onResponderRelease={[Function]}
-        onResponderTerminate={[Function]}
-        onResponderTerminationRequest={[Function]}
-        onScroll={[Function]}
-        onSelectionChange={[Function]}
-        onSelectionChangeShouldSetResponder={[Function]}
-        onStartShouldSetResponder={[Function]}
-        rejectResponderTermination={true}
-        selection={null}
-        submitBehavior="blurAndSubmit"
-        textContentType="emailAddress"
-        underlineColorAndroid="transparent"
-      />
-    `);
-    });
-
-    it('should render as expected', async () => {
-      await expectRendersMatchingSnapshot(
-        'TextInput',
-        () => <TextInput />,
-        () => {
-          jest.dontMock('../TextInput');
-        },
-      );
-    });
-  });
-
-  describe('TextInput', () => {
-    it('default render', async () => {
-      const instance = await create(<TextInput />);
-
-      expect(instance.toJSON()).toMatchInlineSnapshot(`
-      <RCTSinglelineTextInputView
-        accessible={true}
-        allowFontScaling={true}
-        focusable={true}
-        mostRecentEventCount={0}
-        onBlur={[Function]}
-        onChange={[Function]}
-        onClick={[Function]}
-        onFocus={[Function]}
-        onResponderGrant={[Function]}
-        onResponderMove={[Function]}
-        onResponderRelease={[Function]}
-        onResponderTerminate={[Function]}
-        onResponderTerminationRequest={[Function]}
-        onScroll={[Function]}
-        onSelectionChange={[Function]}
-        onSelectionChangeShouldSetResponder={[Function]}
-        onStartShouldSetResponder={[Function]}
-        rejectResponderTermination={true}
-        selection={null}
-        submitBehavior="blurAndSubmit"
-        underlineColorAndroid="transparent"
-      />
-    `);
-    });
-
-    it('has displayName', () => {
-      expect(TextInput.displayName).toEqual('TextInput');
-    });
-  });
-
-  describe('TextInput compat with web', () => {
-    it('renders core props', async () => {
-      const props = {
-        id: 'id',
-        tabIndex: 0,
-        testID: 'testID',
-      };
-
-      // $FlowFixMe[incompatible-use]
-      const instance = await create(<TextInput {...props} />);
-
-      expect(instance.toJSON()).toMatchInlineSnapshot(`
-      <RCTSinglelineTextInputView
-        accessible={true}
-        allowFontScaling={true}
-        focusable={true}
-        mostRecentEventCount={0}
-        nativeID="id"
-        onBlur={[Function]}
-        onChange={[Function]}
-        onClick={[Function]}
-        onFocus={[Function]}
-        onResponderGrant={[Function]}
-        onResponderMove={[Function]}
-        onResponderRelease={[Function]}
-        onResponderTerminate={[Function]}
-        onResponderTerminationRequest={[Function]}
-        onScroll={[Function]}
-        onSelectionChange={[Function]}
-        onSelectionChangeShouldSetResponder={[Function]}
-        onStartShouldSetResponder={[Function]}
-        rejectResponderTermination={true}
-        selection={null}
-        submitBehavior="blurAndSubmit"
-        testID="testID"
-        underlineColorAndroid="transparent"
-      />
-    `);
-    });
-
-    it('renders "aria-*" props', async () => {
-      const props = {
-        'aria-activedescendant': 'activedescendant',
-        'aria-atomic': true,
-        'aria-autocomplete': 'list',
-        'aria-busy': true,
-        'aria-checked': true,
-        'aria-columncount': 5,
-        'aria-columnindex': 3,
-        'aria-columnspan': 2,
-        'aria-controls': 'controls',
-        'aria-current': 'current',
-        'aria-describedby': 'describedby',
-        'aria-details': 'details',
-        'aria-disabled': true,
-        'aria-errormessage': 'errormessage',
-        'aria-expanded': true,
-        'aria-flowto': 'flowto',
-        'aria-haspopup': true,
-        'aria-hidden': true,
-        'aria-invalid': true,
-        'aria-keyshortcuts': 'Cmd+S',
-        'aria-label': 'label',
-        'aria-labelledby': 'labelledby',
-        'aria-level': 3,
-        'aria-live': 'polite',
-        'aria-modal': true,
-        'aria-multiline': true,
-        'aria-multiselectable': true,
-        'aria-orientation': 'portrait',
-        'aria-owns': 'owns',
-        'aria-placeholder': 'placeholder',
-        'aria-posinset': 5,
-        'aria-pressed': true,
-        'aria-readonly': true,
-        'aria-required': true,
-        role: 'main',
-        'aria-roledescription': 'roledescription',
-        'aria-rowcount': 5,
-        'aria-rowindex': 3,
-        'aria-rowspan': 3,
-        'aria-selected': true,
-        'aria-setsize': 5,
-        'aria-sort': 'ascending',
-        'aria-valuemax': 5,
-        'aria-valuemin': 0,
-        'aria-valuenow': 3,
-        'aria-valuetext': '3',
-      };
-
-      // $FlowFixMe[incompatible-use]
-      const instance = await create(<TextInput {...props} />);
-
-      expect(instance.toJSON()).toMatchInlineSnapshot(`
-      <RCTSinglelineTextInputView
-        accessibilityElementsHidden={true}
-        accessibilityLabel="label"
-        accessibilityState={
-          Object {
-            "busy": true,
-            "checked": true,
-            "disabled": true,
-            "expanded": true,
-            "selected": true,
-          }
-        }
-        accessible={true}
-        allowFontScaling={true}
-        aria-activedescendant="activedescendant"
-        aria-atomic={true}
-        aria-autocomplete="list"
-        aria-columncount={5}
-        aria-columnindex={3}
-        aria-columnspan={2}
-        aria-controls="controls"
-        aria-current="current"
-        aria-describedby="describedby"
-        aria-details="details"
-        aria-errormessage="errormessage"
-        aria-flowto="flowto"
-        aria-haspopup={true}
-        aria-hidden={true}
-        aria-invalid={true}
-        aria-keyshortcuts="Cmd+S"
-        aria-label="label"
-        aria-labelledby="labelledby"
-        aria-level={3}
-        aria-live="polite"
-        aria-modal={true}
-        aria-multiline={true}
-        aria-multiselectable={true}
-        aria-orientation="portrait"
-        aria-owns="owns"
-        aria-placeholder="placeholder"
-        aria-posinset={5}
-        aria-pressed={true}
-        aria-readonly={true}
-        aria-required={true}
-        aria-roledescription="roledescription"
-        aria-rowcount={5}
-        aria-rowindex={3}
-        aria-rowspan={3}
-        aria-setsize={5}
-        aria-sort="ascending"
-        aria-valuemax={5}
-        aria-valuemin={0}
-        aria-valuenow={3}
-        aria-valuetext="3"
-        focusable={true}
-        mostRecentEventCount={0}
-        onBlur={[Function]}
-        onChange={[Function]}
-        onClick={[Function]}
-        onFocus={[Function]}
-        onResponderGrant={[Function]}
-        onResponderMove={[Function]}
-        onResponderRelease={[Function]}
-        onResponderTerminate={[Function]}
-        onResponderTerminationRequest={[Function]}
-        onScroll={[Function]}
-        onSelectionChange={[Function]}
-        onSelectionChangeShouldSetResponder={[Function]}
-        onStartShouldSetResponder={[Function]}
-        rejectResponderTermination={true}
-        role="main"
-        selection={null}
-        submitBehavior="blurAndSubmit"
-        underlineColorAndroid="transparent"
-      />
-    `);
-    });
-
-    it('renders styles', async () => {
-      const style = {
-        display: 'flex',
-        flex: 1,
-        backgroundColor: 'white',
-        marginInlineStart: 10,
-        userSelect: 'none',
-        verticalAlign: 'middle',
-      };
-
-      // $FlowFixMe[incompatible-use]
-      const instance = await create(<TextInput style={style} />);
-
-      expect(instance.toJSON()).toMatchInlineSnapshot(`
-      <RCTSinglelineTextInputView
-        accessible={true}
-        allowFontScaling={true}
-        focusable={true}
-        mostRecentEventCount={0}
-        onBlur={[Function]}
-        onChange={[Function]}
-        onClick={[Function]}
-        onFocus={[Function]}
-        onResponderGrant={[Function]}
-        onResponderMove={[Function]}
-        onResponderRelease={[Function]}
-        onResponderTerminate={[Function]}
-        onResponderTerminationRequest={[Function]}
-        onScroll={[Function]}
-        onSelectionChange={[Function]}
-        onSelectionChangeShouldSetResponder={[Function]}
-        onStartShouldSetResponder={[Function]}
-        rejectResponderTermination={true}
-        selection={null}
-        style={
-          Array [
-            Object {
-              "backgroundColor": "white",
-              "display": "flex",
-              "flex": 1,
-              "marginInlineStart": 10,
-              "userSelect": "none",
-              "verticalAlign": "middle",
-            },
-            Object {
-              "textAlignVertical": "center",
-              "verticalAlign": undefined,
-            },
-          ]
-        }
-        submitBehavior="blurAndSubmit"
-        underlineColorAndroid="transparent"
-      />
-    `);
-    });
-  });
-});
diff --git a/packages/react-native/Libraries/Components/TextInput/__tests__/__snapshots__/TextInput-test.js.snap b/packages/react-native/Libraries/Components/TextInput/__tests__/__snapshots__/TextInput-test.js.snap
deleted file mode 100644
index 8eed524569e4..000000000000
--- a/packages/react-native/Libraries/Components/TextInput/__tests__/__snapshots__/TextInput-test.js.snap
+++ /dev/null
@@ -1,105 +0,0 @@
-// Jest Snapshot v1, https://goo.gl/fbAQLP
-
-exports[`TextInput tests (useTextChildren = false) should render as expected: should deep render when mocked (please verify output manually) 1`] = `
-<RCTSinglelineTextInputView
-  accessible={true}
-  allowFontScaling={true}
-  focusable={true}
-  mostRecentEventCount={0}
-  onBlur={[Function]}
-  onChange={[Function]}
-  onClick={[Function]}
-  onFocus={[Function]}
-  onResponderGrant={[Function]}
-  onResponderMove={[Function]}
-  onResponderRelease={[Function]}
-  onResponderTerminate={[Function]}
-  onResponderTerminationRequest={[Function]}
-  onScroll={[Function]}
-  onSelectionChange={[Function]}
-  onSelectionChangeShouldSetResponder={[Function]}
-  onStartShouldSetResponder={[Function]}
-  rejectResponderTermination={true}
-  selection={null}
-  submitBehavior="blurAndSubmit"
-  underlineColorAndroid="transparent"
-/>
-`;
-
-exports[`TextInput tests (useTextChildren = false) should render as expected: should deep render when not mocked (please verify output manually) 1`] = `
-<RCTSinglelineTextInputView
-  accessible={true}
-  allowFontScaling={true}
-  focusable={true}
-  mostRecentEventCount={0}
-  onBlur={[Function]}
-  onChange={[Function]}
-  onClick={[Function]}
-  onFocus={[Function]}
-  onResponderGrant={[Function]}
-  onResponderMove={[Function]}
-  onResponderRelease={[Function]}
-  onResponderTerminate={[Function]}
-  onResponderTerminationRequest={[Function]}
-  onScroll={[Function]}
-  onSelectionChange={[Function]}
-  onSelectionChangeShouldSetResponder={[Function]}
-  onStartShouldSetResponder={[Function]}
-  rejectResponderTermination={true}
-  selection={null}
-  submitBehavior="blurAndSubmit"
-  underlineColorAndroid="transparent"
-/>
-`;
-
-exports[`TextInput tests (useTextChildren = true) should render as expected: should deep render when mocked (please verify output manually) 1`] = `
-<RCTSinglelineTextInputView
-  accessible={true}
-  allowFontScaling={true}
-  focusable={true}
-  mostRecentEventCount={0}
-  onBlur={[Function]}
-  onChange={[Function]}
-  onClick={[Function]}
-  onFocus={[Function]}
-  onResponderGrant={[Function]}
-  onResponderMove={[Function]}
-  onResponderRelease={[Function]}
-  onResponderTerminate={[Function]}
-  onResponderTerminationRequest={[Function]}
-  onScroll={[Function]}
-  onSelectionChange={[Function]}
-  onSelectionChangeShouldSetResponder={[Function]}
-  onStartShouldSetResponder={[Function]}
-  rejectResponderTermination={true}
-  selection={null}
-  submitBehavior="blurAndSubmit"
-  underlineColorAndroid="transparent"
-/>
-`;
-
-exports[`TextInput tests (useTextChildren = true) should render as expected: should deep render when not mocked (please verify output manually) 1`] = `
-<RCTSinglelineTextInputView
-  accessible={true}
-  allowFontScaling={true}
-  focusable={true}
-  mostRecentEventCount={0}
-  onBlur={[Function]}
-  onChange={[Function]}
-  onClick={[Function]}
-  onFocus={[Function]}
-  onResponderGrant={[Function]}
-  onResponderMove={[Function]}
-  onResponderRelease={[Function]}
-  onResponderTerminate={[Function]}
-  onResponderTerminationRequest={[Function]}
-  onScroll={[Function]}
-  onSelectionChange={[Function]}
-  onSelectionChangeShouldSetResponder={[Function]}
-  onStartShouldSetResponder={[Function]}
-  rejectResponderTermination={true}
-  selection={null}
-  submitBehavior="blurAndSubmit"
-  underlineColorAndroid="transparent"
-/>
-`;
diff --git a/packages/react-native/Libraries/ReactNative/AppRegistryImpl.js b/packages/react-native/Libraries/ReactNative/AppRegistryImpl.js
index e6bd106713d6..1a6ee823fdbc 100644
--- a/packages/react-native/Libraries/ReactNative/AppRegistryImpl.js
+++ b/packages/react-native/Libraries/ReactNative/AppRegistryImpl.js
@@ -26,7 +26,6 @@ import createPerformanceLogger from '../Utilities/createPerformanceLogger';
 import SceneTracker from '../Utilities/SceneTracker';
 import {coerceDisplayMode} from './DisplayMode';
 import HeadlessJsTaskError from './HeadlessJsTaskError';
-import {unmountComponentAtNodeAndRemoveContainer} from './RendererProxy';
 import invariant from 'invariant';
 
 type TaskCanceller = () => void;
@@ -210,7 +209,9 @@ export function setSurfaceProps(
  * See https://reactnative.dev/docs/appregistry#unmountapplicationcomponentatroottag
  */
 export function unmountApplicationComponentAtRootTag(rootTag: RootTag): void {
-  unmountComponentAtNodeAndRemoveContainer(rootTag);
+  console.error(
+    'Unexpected call to unmountApplicationComponentAtRootTag in Fabric.',
+  );
 }
 
 /**
diff --git a/packages/react-native/Libraries/ReactNative/RendererImplementation.js b/packages/react-native/Libraries/ReactNative/RendererImplementation.js
index 057572a634da..243b3cbadadb 100644
--- a/packages/react-native/Libraries/ReactNative/RendererImplementation.js
+++ b/packages/react-native/Libraries/ReactNative/RendererImplementation.js
@@ -10,8 +10,6 @@
 
 import type {HostInstance} from '../../src/private/types/HostInstance';
 import typeof ReactFabricType from '../Renderer/shims/ReactFabric';
-import typeof ReactNativeType from '../Renderer/shims/ReactNative';
-import type {RootTag} from './RootTag';
 
 import {
   onCaughtError,
@@ -21,7 +19,6 @@ import {
 import * as React from 'react';
 
 let cachedFabricRenderer;
-let cachedPaperRenderer;
 
 function getFabricRenderer(): ReactFabricType {
   if (cachedFabricRenderer == null) {
@@ -30,21 +27,10 @@ function getFabricRenderer(): ReactFabricType {
   return cachedFabricRenderer;
 }
 
-function getPaperRenderer(): ReactNativeType {
-  if (cachedPaperRenderer == null) {
-    cachedPaperRenderer = require('../Renderer/shims/ReactNative').default;
-  }
-  return cachedPaperRenderer;
-}
-
-const getMethod: (<MethodName extends keyof ReactFabricType>(
+const getMethod: <MethodName extends keyof ReactFabricType>(
   () => ReactFabricType,
   MethodName,
-) => ReactFabricType[MethodName]) &
-  (<MethodName extends keyof ReactNativeType>(
-    () => ReactNativeType,
-    MethodName,
-  ) => ReactNativeType[MethodName]) = (getRenderer, methodName) => {
+) => ReactFabricType[MethodName] = (getRenderer, methodName) => {
   let cachedImpl;
 
   // $FlowExpectedError[incompatible-type]
@@ -66,14 +52,7 @@ function getFabricMethod<MethodName extends keyof ReactFabricType>(
   return getMethod(getFabricRenderer, methodName);
 }
 
-function getPaperMethod<MethodName extends keyof ReactNativeType>(
-  methodName: MethodName,
-): ReactNativeType[MethodName] {
-  return getMethod(getPaperRenderer, methodName);
-}
-
 let cachedFabricRender;
-let cachedPaperRender;
 
 export function renderElement({
   element,
@@ -86,52 +65,29 @@ export function renderElement({
   useFabric: boolean,
   useConcurrentRoot: boolean,
 }): void {
-  if (useFabric) {
-    if (cachedFabricRender == null) {
-      cachedFabricRender = getFabricRenderer().render;
-    }
-
-    cachedFabricRender(element, rootTag, null, useConcurrentRoot, {
-      onCaughtError,
-      onUncaughtError,
-      onRecoverableError,
-    });
-  } else {
-    if (cachedPaperRender == null) {
-      cachedPaperRender = getPaperRenderer().render;
-    }
-
-    cachedPaperRender(element, rootTag, undefined, {
-      onCaughtError,
-      onUncaughtError,
-      onRecoverableError,
-    });
+  if (cachedFabricRender == null) {
+    cachedFabricRender = getFabricRenderer().render;
   }
+
+  cachedFabricRender(element, rootTag, null, useConcurrentRoot, {
+    onCaughtError,
+    onUncaughtError,
+    onRecoverableError,
+  });
 }
 
 let cachedFabricDispatchCommand;
-let cachedPaperDispatchCommand;
 
 export function dispatchCommand(
   handle: HostInstance,
   command: string,
   args: Array<unknown>,
 ): void {
-  if (global.RN$Bridgeless === true) {
-    // Note: this function has the same implementation in the legacy and new renderer.
-    // However, evaluating the old renderer comes with some side effects.
-    if (cachedFabricDispatchCommand == null) {
-      cachedFabricDispatchCommand = getFabricRenderer().dispatchCommand;
-    }
-
-    return cachedFabricDispatchCommand(handle, command, args);
-  } else {
-    if (cachedPaperDispatchCommand == null) {
-      cachedPaperDispatchCommand = getPaperRenderer().dispatchCommand;
-    }
-
-    return cachedPaperDispatchCommand(handle, command, args);
+  if (cachedFabricDispatchCommand == null) {
+    cachedFabricDispatchCommand = getFabricRenderer().dispatchCommand;
   }
+
+  return cachedFabricDispatchCommand(handle, command, args);
 }
 
 export const findHostInstance_DEPRECATED: <
@@ -139,31 +95,25 @@ export const findHostInstance_DEPRECATED: <
 >(
   // $FlowExpectedError[incompatible-type]
   componentOrHandle: ?(React.ElementRef<TElementType> | number),
-) => ?HostInstance = getPaperMethod('findHostInstance_DEPRECATED');
+) => ?HostInstance = getFabricMethod('findHostInstance_DEPRECATED');
 
 export const findNodeHandle: <TElementType extends React.ElementType>(
   // $FlowExpectedError[incompatible-type]
   componentOrHandle: ?(React.ElementRef<TElementType> | number),
-) => ?number = getPaperMethod('findNodeHandle');
+) => ?number = getFabricMethod('findNodeHandle');
 
-export const sendAccessibilityEvent: ReactNativeType['sendAccessibilityEvent'] =
-  getPaperMethod('sendAccessibilityEvent');
+export const sendAccessibilityEvent: ReactFabricType['sendAccessibilityEvent'] =
+  getFabricMethod('sendAccessibilityEvent');
 
-/**
- * This method is used by AppRegistry to unmount a root when using the old
- * React Native renderer (Paper).
- */
-export const unmountComponentAtNodeAndRemoveContainer: (
-  rootTag: RootTag,
-) => void =
-  // $FlowExpectedError[incompatible-type]
-  getPaperMethod('unmountComponentAtNodeAndRemoveContainer');
-
-export const unstable_batchedUpdates: ReactNativeType['unstable_batchedUpdates'] =
-  getPaperMethod('unstable_batchedUpdates');
+export function unstable_batchedUpdates<T>(
+  fn: (bookkeeping: T) => void,
+  bookkeeping: T,
+): void {
+  fn(bookkeeping);
+}
 
-export const isChildPublicInstance: ReactNativeType['isChildPublicInstance'] =
-  getPaperMethod('isChildPublicInstance');
+export const isChildPublicInstance: ReactFabricType['isChildPublicInstance'] =
+  getFabricMethod('isChildPublicInstance');
 
 export const getNodeFromInternalInstanceHandle: ReactFabricType['getNodeFromInternalInstanceHandle'] =
   getFabricMethod('getNodeFromInternalInstanceHandle');
diff --git a/packages/react-native/Libraries/ReactNative/RendererProxy.js b/packages/react-native/Libraries/ReactNative/RendererProxy.js
index c3ef70aabb7d..83c98fa706b0 100644
--- a/packages/react-native/Libraries/ReactNative/RendererProxy.js
+++ b/packages/react-native/Libraries/ReactNative/RendererProxy.js
@@ -8,19 +8,8 @@
  * @format
  */
 
-/**
- * This module exists to allow apps to select their renderer implementation
- * (e.g.: Fabric-only, Paper-only) without having to pull all the renderer
- * implementations into their app bundle, which affects app size.
- *
- * By default, the setup will be:
- *   -> RendererProxy
- *     -> RendererImplementation (which uses Fabric or Paper depending on a flag at runtime)
- *
- * But this will allow a setup like this without duplicating logic:
- *   -> RendererProxy (fork)
- *     -> RendererImplementation (which uses Fabric or Paper depending on a flag at runtime)
- *     or -> OtherImplementation (which uses Fabric only)
- */
-
+// This module allows app bundles to set up the appropriate Fabric renderer
+// variant (e.g., profiling vs production) before React Native is initialized.
+// The internal implementation (RendererProxy.fb.js) provides the indirection
+// needed to swap the renderer implementation at runtime.
 export * from './RendererImplementation';