diff --git a/packages/react-debug-tools/src/ReactDebugHooks.js b/packages/react-debug-tools/src/ReactDebugHooks.js
index 1de7794bbece9..c4a65ac5ba37d 100644
--- a/packages/react-debug-tools/src/ReactDebugHooks.js
+++ b/packages/react-debug-tools/src/ReactDebugHooks.js
@@ -11,6 +11,7 @@ import type {
   ReactContext,
   ReactProviderType,
   ReactEventResponder,
+  ReactEventResponderListener,
 } from 'shared/ReactTypes';
 import type {Fiber} from 'react-reconciler/src/ReactFiber';
 import type {Hook} from 'react-reconciler/src/ReactFiberHooks';
@@ -25,8 +26,6 @@ import {
   ForwardRef,
 } from 'shared/ReactWorkTags';
 
-const emptyObject = {};
-
 type CurrentDispatcherRef = typeof ReactSharedInternals.ReactCurrentDispatcher;
 
 // Used to track hooks called during a render
@@ -221,17 +220,20 @@ function useMemo<T>(
   return value;
 }
 
-function useListener(
+function useResponder(
   responder: ReactEventResponder<any, any>,
-  hookProps: ?Object,
-): void {
-  const listenerProps = hookProps || emptyObject;
+  listenerProps: Object,
+): ReactEventResponderListener<any, any> {
   // Don't put the actual event responder object in, just its displayName
   const value = {
     responder: responder.displayName || 'EventResponder',
     props: listenerProps,
   };
-  hookLog.push({primitive: 'Listener', stackError: new Error(), value});
+  hookLog.push({primitive: 'Responder', stackError: new Error(), value});
+  return {
+    responder,
+    props: listenerProps,
+  };
 }
 
 const Dispatcher: DispatcherType = {
@@ -246,7 +248,7 @@ const Dispatcher: DispatcherType = {
   useReducer,
   useRef,
   useState,
-  useListener,
+  useResponder,
 };
 
 // Inspect
diff --git a/packages/react-debug-tools/src/__tests__/ReactHooksInspection-test.internal.js b/packages/react-debug-tools/src/__tests__/ReactHooksInspection-test.internal.js
index ac838e2a24492..b449e0120d5fe 100644
--- a/packages/react-debug-tools/src/__tests__/ReactHooksInspection-test.internal.js
+++ b/packages/react-debug-tools/src/__tests__/ReactHooksInspection-test.internal.js
@@ -22,19 +22,21 @@ describe('ReactHooksInspection', () => {
     ReactDebugTools = require('react-debug-tools');
   });
 
-  it('should inspect a simple useListener hook', () => {
+  it('should inspect a simple useResponder hook', () => {
     const TestResponder = React.unstable_createResponder('TestResponder', {});
 
     function Foo(props) {
-      React.unstable_useListener(TestResponder, {preventDefault: false});
-      return <div responders={<TestResponder />}>Hello world</div>;
+      const listener = React.unstable_useResponder(TestResponder, {
+        preventDefault: false,
+      });
+      return <div listeners={listener}>Hello world</div>;
     }
     let tree = ReactDebugTools.inspectHooks(Foo, {});
     expect(tree).toEqual([
       {
         isStateEditable: false,
         id: 0,
-        name: 'Listener',
+        name: 'Responder',
         value: {props: {preventDefault: false}, responder: 'TestResponder'},
         subHooks: [],
       },
diff --git a/packages/react-dom/src/client/ReactDOMComponent.js b/packages/react-dom/src/client/ReactDOMComponent.js
index 55db92a52f3ce..c2c3b791867a3 100644
--- a/packages/react-dom/src/client/ReactDOMComponent.js
+++ b/packages/react-dom/src/client/ReactDOMComponent.js
@@ -98,7 +98,7 @@ const AUTOFOCUS = 'autoFocus';
 const CHILDREN = 'children';
 const STYLE = 'style';
 const HTML = '__html';
-const RESPONDERS = 'responders';
+const LISTENERS = 'listeners';
 
 const {html: HTML_NAMESPACE} = Namespaces;
 
@@ -341,7 +341,7 @@ function setInitialDOMProperties(
         setTextContent(domElement, '' + nextProp);
       }
     } else if (
-      (enableFlareAPI && propKey === RESPONDERS) ||
+      (enableFlareAPI && propKey === LISTENERS) ||
       propKey === SUPPRESS_CONTENT_EDITABLE_WARNING ||
       propKey === SUPPRESS_HYDRATION_WARNING
     ) {
@@ -698,7 +698,7 @@ export function diffProperties(
     } else if (propKey === DANGEROUSLY_SET_INNER_HTML || propKey === CHILDREN) {
       // Noop. This is handled by the clear text mechanism.
     } else if (
-      (enableFlareAPI && propKey === RESPONDERS) ||
+      (enableFlareAPI && propKey === LISTENERS) ||
       propKey === SUPPRESS_CONTENT_EDITABLE_WARNING ||
       propKey === SUPPRESS_HYDRATION_WARNING
     ) {
@@ -790,7 +790,7 @@ export function diffProperties(
         (updatePayload = updatePayload || []).push(propKey, '' + nextProp);
       }
     } else if (
-      (enableFlareAPI && propKey === RESPONDERS) ||
+      (enableFlareAPI && propKey === LISTENERS) ||
       propKey === SUPPRESS_CONTENT_EDITABLE_WARNING ||
       propKey === SUPPRESS_HYDRATION_WARNING
     ) {
@@ -1045,7 +1045,7 @@ export function diffHydratedProperties(
       if (suppressHydrationWarning) {
         // Don't bother comparing. We're ignoring all these warnings.
       } else if (
-        (enableFlareAPI && propKey === RESPONDERS) ||
+        (enableFlareAPI && propKey === LISTENERS) ||
         propKey === SUPPRESS_CONTENT_EDITABLE_WARNING ||
         propKey === SUPPRESS_HYDRATION_WARNING ||
         // Controlled attributes are not validated
diff --git a/packages/react-dom/src/events/DOMEventResponderSystem.js b/packages/react-dom/src/events/DOMEventResponderSystem.js
index 4be4fa81399ab..f034670465b0e 100644
--- a/packages/react-dom/src/events/DOMEventResponderSystem.js
+++ b/packages/react-dom/src/events/DOMEventResponderSystem.js
@@ -12,12 +12,7 @@ import {
   PASSIVE_NOT_SUPPORTED,
 } from 'events/EventSystemFlags';
 import type {AnyNativeEvent} from 'events/PluginModuleType';
-import {
-  HostComponent,
-  FunctionComponent,
-  MemoComponent,
-  ForwardRef,
-} from 'shared/ReactWorkTags';
+import {HostComponent} from 'shared/ReactWorkTags';
 import type {EventPriority} from 'shared/ReactTypes';
 import type {
   ReactDOMEventResponder,
@@ -67,7 +62,7 @@ export function setListenToResponderEventTypes(
 }
 
 type EventQueueItem = {|
-  listeners: Array<(val: any) => void>,
+  listener: (val: any) => void,
   value: any,
 |};
 type EventQueue = Array<EventQueueItem>;
@@ -103,8 +98,8 @@ let currentDocument: null | Document = null;
 
 const eventResponderContext: ReactDOMResponderContext = {
   dispatchEvent(
-    eventProp: string,
     eventValue: any,
+    eventListener: any => void,
     eventPriority: EventPriority,
   ): void {
     validateResponderContext();
@@ -112,15 +107,9 @@ const eventResponderContext: ReactDOMResponderContext = {
     if (eventPriority < currentEventQueuePriority) {
       currentEventQueuePriority = eventPriority;
     }
-    const responderInstance = ((currentInstance: any): ReactDOMEventResponderInstance);
-    const target = responderInstance.fiber;
-    const responder = responderInstance.responder;
-    const listeners = collectListeners(eventProp, responder, target);
-    if (listeners.length !== 0) {
-      ((currentEventQueue: any): EventQueue).push(
-        createEventQueueItem(eventValue, listeners),
-      );
-    }
+    ((currentEventQueue: any): EventQueue).push(
+      createEventQueueItem(eventValue, eventListener),
+    );
   },
   isTargetWithinResponder(target: Element | Document): boolean {
     validateResponderContext();
@@ -392,11 +381,11 @@ function collectFocusableElements(
 
 function createEventQueueItem(
   value: any,
-  listeners: Array<(val: any) => void>,
+  listener: (val: any) => void,
 ): EventQueueItem {
   return {
     value,
-    listeners,
+    listener,
   };
 }
 
@@ -519,70 +508,11 @@ function createDOMResponderEvent(
   };
 }
 
-function collectListeners(
-  eventProp: string,
-  eventResponder: ReactDOMEventResponder,
-  target: Fiber,
-): Array<(any) => void> {
-  const eventListeners = [];
-  let node = target.return;
-  nodeTraversal: while (node !== null) {
-    switch (node.tag) {
-      case HostComponent: {
-        const dependencies = node.dependencies;
-
-        if (dependencies !== null) {
-          const respondersMap = dependencies.responders;
-
-          if (respondersMap !== null && respondersMap.has(eventResponder)) {
-            break nodeTraversal;
-          }
-        }
-        break;
-      }
-      case FunctionComponent:
-      case MemoComponent:
-      case ForwardRef: {
-        const dependencies = node.dependencies;
-
-        if (dependencies !== null) {
-          const listeners = dependencies.listeners;
-
-          if (listeners !== null) {
-            for (
-              let s = 0, listenersLength = listeners.length;
-              s < listenersLength;
-              s++
-            ) {
-              const listener = listeners[s];
-              const {responder, props} = listener;
-              const listenerFunc = props[eventProp];
-
-              if (
-                responder === eventResponder &&
-                typeof listenerFunc === 'function'
-              ) {
-                eventListeners.push(listenerFunc);
-              }
-            }
-          }
-        }
-      }
-    }
-    node = node.return;
-  }
-  return eventListeners;
-}
-
 function processEvents(eventQueue: EventQueue): void {
   for (let i = 0, length = eventQueue.length; i < length; i++) {
-    const {value, listeners} = eventQueue[i];
-    for (let s = 0, length2 = listeners.length; s < length2; s++) {
-      const listener = listeners[s];
-      const type =
-        typeof value === 'object' && value !== null ? value.type : '';
-      invokeGuardedCallbackAndCatchFirstError(type, listener, undefined, value);
-    }
+    const {value, listener} = eventQueue[i];
+    const type = typeof value === 'object' && value !== null ? value.type : '';
+    invokeGuardedCallbackAndCatchFirstError(type, listener, undefined, value);
   }
 }
 
@@ -663,6 +593,7 @@ function traverseAndHandleEventResponderInstances(
   // - Bubble target responder phase
   // - Root responder phase
 
+  const visitedResponders = new Set();
   const responderEvent = createDOMResponderEvent(
     topLevelType,
     nativeEvent,
@@ -670,7 +601,6 @@ function traverseAndHandleEventResponderInstances(
     isPassiveEvent,
     isPassiveSupported,
   );
-  const visitedResponders = new Set();
   let node = targetFiber;
   while (node !== null) {
     const {dependencies, tag} = node;
@@ -687,8 +617,8 @@ function traverseAndHandleEventResponderInstances(
               !visitedResponders.has(responder) &&
               validateResponderTargetEventTypes(eventType, responder)
             ) {
-              const onEvent = responder.onEvent;
               visitedResponders.add(responder);
+              const onEvent = responder.onEvent;
               if (onEvent !== null) {
                 currentInstance = responderInstance;
                 responderEvent.responderTarget = ((target: any):
diff --git a/packages/react-dom/src/events/__tests__/DOMEventResponderSystem-test.internal.js b/packages/react-dom/src/events/__tests__/DOMEventResponderSystem-test.internal.js
index 7efbeaa5f1a5b..6a4894de1736b 100644
--- a/packages/react-dom/src/events/__tests__/DOMEventResponderSystem-test.internal.js
+++ b/packages/react-dom/src/events/__tests__/DOMEventResponderSystem-test.internal.js
@@ -87,19 +87,28 @@ describe('DOMEventResponderSystem', () => {
     jest.resetModules();
     ReactFeatureFlags = require('shared/ReactFeatureFlags');
     ReactFeatureFlags.enableFlareAPI = true;
+    React = require('react');
     ReactTestRenderer = require('react-test-renderer');
     const TestResponder = createEventResponder({});
-    const renderer = ReactTestRenderer.create(
-      <div responders={<TestResponder />}>Hello world</div>,
-    );
+
+    function Test() {
+      const listener = React.unstable_useResponder(TestResponder, {});
+
+      return <div listeners={listener}>Hello world</div>;
+    }
+    const renderer = ReactTestRenderer.create(<Test />);
     expect(renderer).toMatchRenderedOutput(<div>Hello world</div>);
   });
 
   it('can render correctly with the ReactDOMServer', () => {
     const TestResponder = createEventResponder({});
-    const output = ReactDOMServer.renderToString(
-      <div responders={<TestResponder />}>Hello world</div>,
-    );
+
+    function Test() {
+      const listener = React.unstable_useResponder(TestResponder, {});
+
+      return <div listeners={listener}>Hello world</div>;
+    }
+    const output = ReactDOMServer.renderToString(<Test />);
     expect(output).toBe(`<div data-reactroot="">Hello world</div>`);
   });
 
@@ -121,11 +130,15 @@ describe('DOMEventResponderSystem', () => {
       },
     });
 
-    const Test = () => (
-      <button ref={buttonRef} responders={<TestResponder />}>
-        Click me!
-      </button>
-    );
+    function Test() {
+      const listener = React.unstable_useResponder(TestResponder, {});
+
+      return (
+        <button ref={buttonRef} listeners={listener}>
+          Click me!
+        </button>
+      );
+    }
 
     ReactDOM.render(<Test />, container);
     expect(container.innerHTML).toBe('<button>Click me!</button>');
@@ -177,11 +190,15 @@ describe('DOMEventResponderSystem', () => {
       },
     });
 
-    const Test = () => (
-      <button ref={buttonRef} responders={<TestResponder />}>
-        Click me!
-      </button>
-    );
+    function Test() {
+      const listener = React.unstable_useResponder(TestResponder, {});
+
+      return (
+        <button ref={buttonRef} listeners={listener}>
+          Click me!
+        </button>
+      );
+    }
 
     ReactDOM.render(<Test />, container);
 
@@ -217,15 +234,23 @@ describe('DOMEventResponderSystem', () => {
       },
     });
 
-    let Test = () => (
-      <button
-        ref={buttonRef}
-        responders={[<TestResponder />, <TestResponder />]}>
-        Click me!
-      </button>
-    );
+    function Test() {
+      const listener = React.unstable_useResponder(TestResponder, {});
+      const listener2 = React.unstable_useResponder(TestResponder, {});
 
-    ReactDOM.render(<Test />, container);
+      return (
+        <button ref={buttonRef} listeners={[listener, listener2]}>
+          Click me!
+        </button>
+      );
+    }
+
+    expect(() => {
+      ReactDOM.render(<Test />, container);
+    }).toWarnDev(
+      'Duplicate event responder "TestEventResponder" found in event listeners. ' +
+        'Event listeners passed to elements cannot use the same event responder more than once.',
+    );
 
     // Clicking the button should trigger the event responder onEvent()
     let buttonElement = buttonRef.current;
@@ -244,15 +269,19 @@ describe('DOMEventResponderSystem', () => {
 
     eventLog = [];
 
-    Test = () => (
-      <div responders={<TestResponder />}>
-        <button ref={buttonRef} responders={<TestResponder />}>
-          Click me!
-        </button>
-      </div>
-    );
+    function Test2() {
+      const listener = React.unstable_useResponder(TestResponder, {});
 
-    ReactDOM.render(<Test />, container);
+      return (
+        <div listeners={listener}>
+          <button ref={buttonRef} listeners={listener}>
+            Click me!
+          </button>
+        </div>
+      );
+    }
+
+    ReactDOM.render(<Test2 />, container);
 
     // Clicking the button should trigger the event responder onEvent()
     buttonElement = buttonRef.current;
@@ -288,13 +317,16 @@ describe('DOMEventResponderSystem', () => {
       },
     });
 
-    let Test = () => (
-      <button
-        ref={buttonRef}
-        responders={[<TestResponderA />, <TestResponderB />]}>
-        Click me!
-      </button>
-    );
+    function Test() {
+      const listener = React.unstable_useResponder(TestResponderA, {});
+      const listener2 = React.unstable_useResponder(TestResponderB, {});
+
+      return (
+        <button ref={buttonRef} listeners={[listener, listener2]}>
+          Click me!
+        </button>
+      );
+    }
 
     ReactDOM.render(<Test />, container);
 
@@ -306,15 +338,20 @@ describe('DOMEventResponderSystem', () => {
 
     eventLog = [];
 
-    Test = () => (
-      <div responders={<TestResponderA />}>
-        <button ref={buttonRef} responders={<TestResponderB />}>
-          Click me!
-        </button>
-      </div>
-    );
+    function Test2() {
+      const listener = React.unstable_useResponder(TestResponderA, {});
+      const listener2 = React.unstable_useResponder(TestResponderB, {});
 
-    ReactDOM.render(<Test />, container);
+      return (
+        <div listeners={listener}>
+          <button ref={buttonRef} listeners={listener2}>
+            Click me!
+          </button>
+        </div>
+      );
+    }
+
+    ReactDOM.render(<Test2 />, container);
 
     // Clicking the button should trigger the event responder onEvent()
     buttonElement = buttonRef.current;
@@ -323,7 +360,7 @@ describe('DOMEventResponderSystem', () => {
     expect(eventLog).toEqual(['B [bubble]', 'A [bubble]']);
   });
 
-  it('nested event responders should fire in the correct order', () => {
+  it('nested event responders should fire in the correct order #2', () => {
     let eventLog = [];
     const buttonRef = React.createRef();
 
@@ -334,13 +371,17 @@ describe('DOMEventResponderSystem', () => {
       },
     });
 
-    const Test = () => (
-      <div responders={<TestResponder name="A" />}>
-        <button ref={buttonRef} responders={<TestResponder name="B" />}>
-          Click me!
-        </button>
-      </div>
-    );
+    const Test = () => {
+      const listener = React.unstable_useResponder(TestResponder, {name: 'A'});
+      const listener2 = React.unstable_useResponder(TestResponder, {name: 'B'});
+      return (
+        <div listeners={listener}>
+          <button ref={buttonRef} listeners={listener2}>
+            Click me!
+          </button>
+        </div>
+      );
+    };
 
     ReactDOM.render(<Test />, container);
 
@@ -364,7 +405,11 @@ describe('DOMEventResponderSystem', () => {
           phase: 'bubble',
           timeStamp: context.getTimeStamp(),
         };
-        context.dispatchEvent('onMagicClick', syntheticEvent, DiscreteEvent);
+        context.dispatchEvent(
+          syntheticEvent,
+          props.onMagicClick,
+          DiscreteEvent,
+        );
       },
     });
 
@@ -373,12 +418,12 @@ describe('DOMEventResponderSystem', () => {
     }
 
     const Test = () => {
-      React.unstable_useListener(TestResponder, {
+      const listener = React.unstable_useResponder(TestResponder, {
         onMagicClick: handleMagicEvent,
       });
 
       return (
-        <button ref={buttonRef} responders={<TestResponder />}>
+        <button ref={buttonRef} listeners={listener}>
           Click me!
         </button>
       );
@@ -404,7 +449,7 @@ describe('DOMEventResponderSystem', () => {
         phase,
         timeStamp: context.getTimeStamp(),
       };
-      context.dispatchEvent('onPress', pressEvent, DiscreteEvent);
+      context.dispatchEvent(pressEvent, props.onPress, DiscreteEvent);
 
       context.setTimeout(() => {
         const longPressEvent = {
@@ -413,7 +458,7 @@ describe('DOMEventResponderSystem', () => {
           phase,
           timeStamp: context.getTimeStamp(),
         };
-        context.dispatchEvent('onLongPress', longPressEvent, DiscreteEvent);
+        context.dispatchEvent(longPressEvent, props.onLongPress, DiscreteEvent);
 
         const longPressChangeEvent = {
           target: event.target,
@@ -422,8 +467,8 @@ describe('DOMEventResponderSystem', () => {
           timeStamp: context.getTimeStamp(),
         };
         context.dispatchEvent(
-          'onLongPressChange',
           longPressChangeEvent,
+          props.onLongPressChange,
           DiscreteEvent,
         );
       }, 500);
@@ -441,14 +486,14 @@ describe('DOMEventResponderSystem', () => {
     }
 
     const Test = () => {
-      React.unstable_useListener(TestResponder, {
+      const listener = React.unstable_useResponder(TestResponder, {
         onPress: e => log('press ' + e.phase),
         onLongPress: e => log('longpress ' + e.phase),
         onLongPressChange: e => log('longpresschange ' + e.phase),
       });
 
       return (
-        <button ref={buttonRef} responders={<TestResponder />}>
+        <button ref={buttonRef} listeners={listener}>
           Click me!
         </button>
       );
@@ -485,16 +530,19 @@ describe('DOMEventResponderSystem', () => {
       },
     });
 
-    ReactDOM.render(
-      <button responders={[<TestResponder />, <TestResponder2 />]} />,
-      container,
-    );
+    function Test({toggle}) {
+      const listener = React.unstable_useResponder(TestResponder, {});
+      const listener2 = React.unstable_useResponder(TestResponder2, {});
+      if (toggle) {
+        return <button listeners={[listener2, listener]} />;
+      }
+      return <button listeners={[listener, listener2]} />;
+    }
+
+    ReactDOM.render(<Test />, container);
     expect(onMountFired).toEqual(2);
 
-    ReactDOM.render(
-      <button responders={[<TestResponder2 />, <TestResponder />]} />,
-      container,
-    );
+    ReactDOM.render(<Test toggle={true} />, container);
     expect(onMountFired).toEqual(2);
   });
 
@@ -508,24 +556,39 @@ describe('DOMEventResponderSystem', () => {
       },
     });
 
-    ReactDOM.render(<button responders={[<TestResponder />]} />, container);
+    function Test({test}) {
+      const listener = React.unstable_useResponder(TestResponder, {});
+      if (test === 0) {
+        return <button listeners={[listener]} />;
+      } else if (test === 1) {
+        return <button listeners={null} />;
+      } else if (test === 2) {
+        return <button listeners={[]} />;
+      } else if (test === 3) {
+        return <button />;
+      } else if (test === 4) {
+        return <button listeners={listener} />;
+      }
+    }
+
+    ReactDOM.render(<Test test={0} />, container);
     ReactDOM.render(null, container);
     expect(onUnmountFired).toEqual(1);
 
-    ReactDOM.render(<button responders={[<TestResponder />]} />, container);
-    ReactDOM.render(<button responders={null} />, container);
+    ReactDOM.render(<Test test={0} />, container);
+    ReactDOM.render(<Test test={1} />, container);
     expect(onUnmountFired).toEqual(2);
 
-    ReactDOM.render(<button responders={[<TestResponder />]} />, container);
-    ReactDOM.render(<button responders={[]} />, container);
+    ReactDOM.render(<Test test={0} />, container);
+    ReactDOM.render(<Test test={2} />, container);
     expect(onUnmountFired).toEqual(3);
 
-    ReactDOM.render(<button responders={[<TestResponder />]} />, container);
-    ReactDOM.render(<button />, container);
+    ReactDOM.render(<Test test={0} />, container);
+    ReactDOM.render(<Test test={3} />, container);
     expect(onUnmountFired).toEqual(4);
 
-    ReactDOM.render(<button responders={[<TestResponder />]} />, container);
-    ReactDOM.render(<button responders={<TestResponder />} />, container);
+    ReactDOM.render(<Test test={0} />, container);
+    ReactDOM.render(<Test test={4} />, container);
     expect(onUnmountFired).toEqual(4);
   });
 
@@ -542,7 +605,10 @@ describe('DOMEventResponderSystem', () => {
       },
     });
 
-    const Test = () => <button responders={<TestResponder />} />;
+    const Test = () => {
+      const listener = React.unstable_useResponder(TestResponder, {});
+      return <button listeners={listener} />;
+    };
 
     ReactDOM.render(<Test />, container);
     ReactDOM.render(null, container);
@@ -564,9 +630,10 @@ describe('DOMEventResponderSystem', () => {
       },
     });
 
-    const Test = () => (
-      <button ref={buttonRef} responders={<TestResponder />} />
-    );
+    const Test = () => {
+      const listener = React.unstable_useResponder(TestResponder, {});
+      return <button ref={buttonRef} listeners={listener} />;
+    };
 
     ReactDOM.render(<Test />, container);
 
@@ -596,9 +663,10 @@ describe('DOMEventResponderSystem', () => {
       },
     });
 
-    const Test = () => (
-      <button responders={<TestResponder />}>Click me!</button>
-    );
+    const Test = () => {
+      const listener = React.unstable_useResponder(TestResponder, {});
+      return <button listeners={listener}>Click me!</button>;
+    };
 
     ReactDOM.render(<Test />, container);
     expect(container.innerHTML).toBe('<button>Click me!</button>');
@@ -647,13 +715,18 @@ describe('DOMEventResponderSystem', () => {
       },
     });
 
-    const Test = () => (
-      <div responders={<TestResponderA />}>
-        <button ref={buttonRef} responders={<TestResponderB />}>
-          Click me!
-        </button>
-      </div>
-    );
+    const Test = () => {
+      const listener = React.unstable_useResponder(TestResponderA, {});
+      const listener2 = React.unstable_useResponder(TestResponderB, {});
+
+      return (
+        <div listeners={listener}>
+          <button ref={buttonRef} listeners={listener2}>
+            Click me!
+          </button>
+        </div>
+      );
+    };
 
     ReactDOM.render(<Test />, container);
 
@@ -706,11 +779,16 @@ describe('DOMEventResponderSystem', () => {
       },
     });
 
-    const Test = () => (
-      <div responders={<TestResponderA />}>
-        <button responders={<TestResponderB />}>Click me!</button>
-      </div>
-    );
+    const Test = () => {
+      const listener = React.unstable_useResponder(TestResponderA, {});
+      const listener2 = React.unstable_useResponder(TestResponderB, {});
+
+      return (
+        <div listeners={listener}>
+          <button listeners={listener2}>Click me!</button>
+        </div>
+      );
+    };
 
     ReactDOM.render(<Test />, container);
 
@@ -744,17 +822,17 @@ describe('DOMEventResponderSystem', () => {
           type: 'click',
           timeStamp: context.getTimeStamp(),
         };
-        context.dispatchEvent('onClick', syntheticEvent, DiscreteEvent);
+        context.dispatchEvent(syntheticEvent, props.onClick, DiscreteEvent);
       },
     });
 
     let handler;
     const Test = () => {
-      React.unstable_useListener(TestResponder, {
+      const listener = React.unstable_useResponder(TestResponder, {
         onClick: handler,
       });
 
-      return <button responders={<TestResponder />}>Click me!</button>;
+      return <button listeners={listener}>Click me!</button>;
     };
     expect(() => {
       handler = event => {
@@ -819,7 +897,7 @@ describe('DOMEventResponderSystem', () => {
     expect(container.innerHTML).toBe('<button>Click me!</button>');
   });
 
-  it('should work with event listener hooks', () => {
+  it('should work with event responder hooks', () => {
     const buttonRef = React.createRef();
     const eventLogs = [];
     const TestResponder = createEventResponder({
@@ -830,16 +908,16 @@ describe('DOMEventResponderSystem', () => {
           type: 'foo',
           timeStamp: context.getTimeStamp(),
         };
-        context.dispatchEvent('onFoo', fooEvent, DiscreteEvent);
+        context.dispatchEvent(fooEvent, props.onFoo, DiscreteEvent);
       },
     });
 
     const Test = () => {
-      React.unstable_useListener(TestResponder, {
+      const listener = React.unstable_useResponder(TestResponder, {
         onFoo: e => eventLogs.push('hook'),
       });
 
-      return <button ref={buttonRef} responders={<TestResponder />} />;
+      return <button ref={buttonRef} listeners={listener} />;
     };
 
     ReactDOM.render(<Test />, container);
@@ -850,11 +928,11 @@ describe('DOMEventResponderSystem', () => {
     eventLogs.length = 0;
 
     const Test2 = () => {
-      React.unstable_useListener(TestResponder, {
+      const listener = React.unstable_useResponder(TestResponder, {
         onFoo: e => eventLogs.push('hook'),
       });
 
-      return <button ref={buttonRef} responders={<TestResponder />} />;
+      return <button ref={buttonRef} listeners={listener} />;
     };
 
     ReactDOM.render(<Test2 />, container);
diff --git a/packages/react-dom/src/server/ReactPartialRenderer.js b/packages/react-dom/src/server/ReactPartialRenderer.js
index 4a1f808caad45..718108abbbf94 100644
--- a/packages/react-dom/src/server/ReactPartialRenderer.js
+++ b/packages/react-dom/src/server/ReactPartialRenderer.js
@@ -360,7 +360,7 @@ function createOpenTagMarkup(
     if (!hasOwnProperty.call(props, propKey)) {
       continue;
     }
-    if (enableFlareAPI && propKey === 'responders') {
+    if (enableFlareAPI && propKey === 'listeners') {
       continue;
     }
     let propValue = props[propKey];
diff --git a/packages/react-dom/src/server/ReactPartialRendererHooks.js b/packages/react-dom/src/server/ReactPartialRendererHooks.js
index 10ebe9a9fbc02..dbe2c4f7816c4 100644
--- a/packages/react-dom/src/server/ReactPartialRendererHooks.js
+++ b/packages/react-dom/src/server/ReactPartialRendererHooks.js
@@ -9,7 +9,10 @@
 
 import type {Dispatcher as DispatcherType} from 'react-reconciler/src/ReactFiberHooks';
 import type {ThreadID} from './ReactThreadIDAllocator';
-import type {ReactContext} from 'shared/ReactTypes';
+import type {
+  ReactContext,
+  ReactEventResponderListener,
+} from 'shared/ReactTypes';
 
 import {validateContextBounds} from './ReactPartialRendererContext';
 
@@ -447,6 +450,13 @@ export function useCallback<T>(
   return callback;
 }
 
+function useResponder(responder, props): ReactEventResponderListener<any, any> {
+  return {
+    props,
+    responder,
+  };
+}
+
 function noop(): void {}
 
 export let currentThreadID: ThreadID = 0;
@@ -470,5 +480,5 @@ export const Dispatcher: DispatcherType = {
   useEffect: noop,
   // Debugging effect
   useDebugValue: noop,
-  useListener: noop,
+  useResponder,
 };
diff --git a/packages/react-dom/src/shared/ReactControlledValuePropTypes.js b/packages/react-dom/src/shared/ReactControlledValuePropTypes.js
index c43ad47c23dab..b7096e2a3348b 100644
--- a/packages/react-dom/src/shared/ReactControlledValuePropTypes.js
+++ b/packages/react-dom/src/shared/ReactControlledValuePropTypes.js
@@ -36,7 +36,7 @@ if (__DEV__) {
         props.readOnly ||
         props.disabled ||
         props[propName] == null ||
-        (enableFlareAPI && props.responders)
+        (enableFlareAPI && props.listeners)
       ) {
         return null;
       }
@@ -53,7 +53,7 @@ if (__DEV__) {
         props.readOnly ||
         props.disabled ||
         props[propName] == null ||
-        (enableFlareAPI && props.responders)
+        (enableFlareAPI && props.listeners)
       ) {
         return null;
       }
diff --git a/packages/react-events/src/dom/Drag.js b/packages/react-events/src/dom/Drag.js
index 68dfba08f8e83..5f34158d56b22 100644
--- a/packages/react-events/src/dom/Drag.js
+++ b/packages/react-events/src/dom/Drag.js
@@ -11,7 +11,10 @@ import type {
   ReactDOMResponderEvent,
   ReactDOMResponderContext,
 } from 'shared/ReactDOMTypes';
-import type {EventPriority} from 'shared/ReactTypes';
+import type {
+  EventPriority,
+  ReactEventResponderListener,
+} from 'shared/ReactTypes';
 
 import React from 'react';
 import {DiscreteEvent, UserBlockingEvent} from 'shared/ReactTypes';
@@ -19,14 +22,16 @@ import {DiscreteEvent, UserBlockingEvent} from 'shared/ReactTypes';
 const targetEventTypes = ['pointerdown'];
 const rootEventTypes = ['pointerup', 'pointercancel', 'pointermove_active'];
 
-type DragListenerProps = {|
+type DragProps = {
+  disabled: boolean,
+  shouldClaimOwnership: () => boolean,
   onDragStart: (e: DragEvent) => void,
   onDragMove: (e: DragEvent) => void,
   onDragEnd: (e: DragEvent) => void,
   onDragChange: boolean => void,
-|};
+};
 
-type DragState = {
+type DragState = {|
   dragTarget: null | Element | Document,
   isPointerDown: boolean,
   isDragging: boolean,
@@ -35,7 +40,7 @@ type DragState = {
   x: number,
   y: number,
   ownershipClaimed: boolean,
-};
+|};
 
 // In the case we don't have PointerEvents (Safari), we listen to touch events
 // too
@@ -78,9 +83,13 @@ function createDragEvent(
   };
 }
 
+function isFunction(obj): boolean {
+  return typeof obj === 'function';
+}
+
 function dispatchDragEvent(
-  eventPropName: string,
   context: ReactDOMResponderContext,
+  listener: DragEvent => void,
   name: DragEventType,
   state: DragState,
   eventPriority: EventPriority,
@@ -88,7 +97,7 @@ function dispatchDragEvent(
 ): void {
   const target = ((state.dragTarget: any): Element | Document);
   const syntheticEvent = createDragEvent(context, name, target, eventData);
-  context.dispatchEvent(eventPropName, syntheticEvent, eventPriority);
+  context.dispatchEvent(syntheticEvent, listener, eventPriority);
 }
 
 const dragResponderImpl = {
@@ -108,7 +117,7 @@ const dragResponderImpl = {
   onEvent(
     event: ReactDOMResponderEvent,
     context: ReactDOMResponderContext,
-    props: Object,
+    props: DragProps,
     state: DragState,
   ): void {
     const {target, type, nativeEvent} = event;
@@ -128,14 +137,17 @@ const dragResponderImpl = {
           state.y = y;
           state.dragTarget = target;
           state.isPointerDown = true;
+          const onDragStart = props.onDragStart;
 
-          dispatchDragEvent(
-            'onDragStart',
-            context,
-            'dragstart',
-            state,
-            DiscreteEvent,
-          );
+          if (isFunction(onDragStart)) {
+            dispatchDragEvent(
+              context,
+              onDragStart,
+              'dragstart',
+              state,
+              DiscreteEvent,
+            );
+          }
           context.addRootEventTypes(rootEventTypes);
         }
         break;
@@ -145,7 +157,7 @@ const dragResponderImpl = {
   onRootEvent(
     event: ReactDOMResponderEvent,
     context: ReactDOMResponderContext,
-    props: Object,
+    props: DragProps,
     state: DragState,
   ): void {
     const {type, nativeEvent} = event;
@@ -180,25 +192,31 @@ const dragResponderImpl = {
             }
             if (shouldEnableDragging) {
               state.isDragging = true;
-              context.dispatchEvent('onDragChange', true, UserBlockingEvent);
+              const onDragChange = props.onDragChange;
+              if (isFunction(onDragChange)) {
+                context.dispatchEvent(true, onDragChange, UserBlockingEvent);
+              }
             } else {
               state.dragTarget = null;
               state.isPointerDown = false;
               context.removeRootEventTypes(rootEventTypes);
             }
           } else {
-            const eventData = {
-              diffX: x - state.startX,
-              diffY: y - state.startY,
-            };
-            dispatchDragEvent(
-              'onDragMove',
-              context,
-              'dragmove',
-              state,
-              UserBlockingEvent,
-              eventData,
-            );
+            const onDragMove = props.onDragMove;
+            if (isFunction(onDragMove)) {
+              const eventData = {
+                diffX: x - state.startX,
+                diffY: y - state.startY,
+              };
+              dispatchDragEvent(
+                context,
+                onDragMove,
+                'dragmove',
+                state,
+                UserBlockingEvent,
+                eventData,
+              );
+            }
             (nativeEvent: any).preventDefault();
           }
         }
@@ -213,14 +231,20 @@ const dragResponderImpl = {
           if (state.ownershipClaimed) {
             context.releaseOwnership();
           }
-          dispatchDragEvent(
-            'onDragEnd',
-            context,
-            'dragend',
-            state,
-            DiscreteEvent,
-          );
-          context.dispatchEvent('onDragChange', false, UserBlockingEvent);
+          const onDragEnd = props.onDragEnd;
+          if (isFunction(onDragEnd)) {
+            dispatchDragEvent(
+              context,
+              onDragEnd,
+              'dragend',
+              state,
+              DiscreteEvent,
+            );
+          }
+          const onDragChange = props.onDragChange;
+          if (isFunction(onDragChange)) {
+            context.dispatchEvent(false, onDragChange, UserBlockingEvent);
+          }
           state.isDragging = false;
         }
         if (state.isPointerDown) {
@@ -239,6 +263,8 @@ export const DragResponder = React.unstable_createResponder(
   dragResponderImpl,
 );
 
-export function useDragListener(props: DragListenerProps): void {
-  React.unstable_useListener(DragResponder, props);
+export function useDragResponder(
+  props: DragProps,
+): ReactEventResponderListener<any, any> {
+  return React.unstable_useResponder(DragResponder, props);
 }
diff --git a/packages/react-events/src/dom/Focus.js b/packages/react-events/src/dom/Focus.js
index 044b30df3be0f..85f9b8455ea82 100644
--- a/packages/react-events/src/dom/Focus.js
+++ b/packages/react-events/src/dom/Focus.js
@@ -12,6 +12,7 @@ import type {
   ReactDOMResponderContext,
   PointerType,
 } from 'shared/ReactDOMTypes';
+import type {ReactEventResponderListener} from 'shared/ReactTypes';
 
 import React from 'react';
 import {DiscreteEvent} from 'shared/ReactTypes';
@@ -34,26 +35,20 @@ type FocusState = {
   pointerType: PointerType,
 };
 
-type FocusListenerProps = {|
+type FocusProps = {
+  disabled: boolean,
   onBlur: (e: FocusEvent) => void,
   onFocus: (e: FocusEvent) => void,
   onFocusChange: boolean => void,
   onFocusVisibleChange: boolean => void,
-|};
-
-type FocusProps = {
-  disabled: boolean,
 };
 
 type FocusEventType = 'focus' | 'blur' | 'focuschange' | 'focusvisiblechange';
 
-type FocusWithinListenerProps = {|
-  onFocusWithinChange: boolean => void,
-  onFocusWithinVisibleChange: boolean => void,
-|};
-
 type FocusWithinProps = {
   disabled: boolean,
+  onFocusWithinChange: boolean => void,
+  onFocusWithinVisibleChange: boolean => void,
 };
 
 type FocusWithinEventType = 'focuswithinvisiblechange' | 'focuswithinchange';
@@ -91,6 +86,10 @@ if (typeof window !== 'undefined' && window.PointerEvent === undefined) {
   );
 }
 
+function isFunction(obj): boolean {
+  return typeof obj === 'function';
+}
+
 function createFocusEvent(
   context: ReactDOMResponderContext,
   type: FocusEventType | FocusWithinEventType,
@@ -195,16 +194,19 @@ function dispatchFocusEvents(
 ) {
   const pointerType = state.pointerType;
   const target = ((state.focusTarget: any): Element | Document);
-  const syntheticEvent = createFocusEvent(
-    context,
-    'focus',
-    target,
-    pointerType,
-  );
-  context.dispatchEvent('onFocus', syntheticEvent, DiscreteEvent);
-  context.dispatchEvent('onFocusChange', true, DiscreteEvent);
+  const onFocus = props.onFocus;
+  if (isFunction(onFocus)) {
+    const syntheticEvent = createFocusEvent(
+      context,
+      'focus',
+      target,
+      pointerType,
+    );
+    context.dispatchEvent(syntheticEvent, onFocus, DiscreteEvent);
+  }
+  dispatchFocusChange(context, props, true);
   if (state.isFocusVisible) {
-    dispatchFocusVisibleChangeEvent(context, true);
+    dispatchFocusVisibleChangeEvent(context, props, true);
   }
 }
 
@@ -215,19 +217,42 @@ function dispatchBlurEvents(
 ) {
   const pointerType = state.pointerType;
   const target = ((state.focusTarget: any): Element | Document);
-  const syntheticEvent = createFocusEvent(context, 'blur', target, pointerType);
-  context.dispatchEvent('onBlur', syntheticEvent, DiscreteEvent);
-  context.dispatchEvent('onFocusChange', false, DiscreteEvent);
+  const onBlur = props.onBlur;
+  if (isFunction(onBlur)) {
+    const syntheticEvent = createFocusEvent(
+      context,
+      'blur',
+      target,
+      pointerType,
+    );
+    context.dispatchEvent(syntheticEvent, onBlur, DiscreteEvent);
+  }
+  dispatchFocusChange(context, props, false);
   if (state.isFocusVisible) {
-    dispatchFocusVisibleChangeEvent(context, false);
+    dispatchFocusVisibleChangeEvent(context, props, false);
+  }
+}
+
+function dispatchFocusChange(
+  context: ReactDOMResponderContext,
+  props: FocusProps,
+  value: boolean,
+): void {
+  const onFocusChange = props.onFocusChange;
+  if (isFunction(onFocusChange)) {
+    context.dispatchEvent(value, onFocusChange, DiscreteEvent);
   }
 }
 
 function dispatchFocusVisibleChangeEvent(
   context: ReactDOMResponderContext,
+  props: FocusProps,
   value: boolean,
 ) {
-  context.dispatchEvent('onFocusVisibleChange', value, DiscreteEvent);
+  const onFocusVisibleChange = props.onFocusVisibleChange;
+  if (isFunction(onFocusVisibleChange)) {
+    context.dispatchEvent(value, onFocusVisibleChange, DiscreteEvent);
+  }
 }
 
 function unmountFocusResponder(
@@ -299,7 +324,7 @@ const focusResponderImpl = {
     handleRootEvent(event, context, state, isFocusVisible => {
       if (state.isFocusVisible !== isFocusVisible) {
         state.isFocusVisible = isFocusVisible;
-        dispatchFocusVisibleChangeEvent(context, isFocusVisible);
+        dispatchFocusVisibleChangeEvent(context, props, isFocusVisible);
       }
     });
   },
@@ -324,8 +349,10 @@ export const FocusResponder = React.unstable_createResponder(
   focusResponderImpl,
 );
 
-export function useFocusListener(props: FocusListenerProps): void {
-  React.unstable_useListener(FocusResponder, props);
+export function useFocusResponder(
+  props: FocusProps,
+): ReactEventResponderListener<any, any> {
+  return React.unstable_useResponder(FocusResponder, props);
 }
 
 /**
@@ -338,7 +365,10 @@ function dispatchFocusWithinChangeEvent(
   state: FocusState,
   value: boolean,
 ) {
-  context.dispatchEvent('onFocusWithinChange', value, DiscreteEvent);
+  const onFocusWithinChange = props.onFocusWithinChange;
+  if (isFunction(onFocusWithinChange)) {
+    context.dispatchEvent(value, onFocusWithinChange, DiscreteEvent);
+  }
   if (state.isFocusVisible) {
     dispatchFocusWithinVisibleChangeEvent(context, props, state, value);
   }
@@ -350,7 +380,10 @@ function dispatchFocusWithinVisibleChangeEvent(
   state: FocusState,
   value: boolean,
 ) {
-  context.dispatchEvent('onFocusWithinVisibleChange', value, DiscreteEvent);
+  const onFocusWithinVisibleChange = props.onFocusWithinVisibleChange;
+  if (isFunction(onFocusWithinVisibleChange)) {
+    context.dispatchEvent(value, onFocusWithinVisibleChange, DiscreteEvent);
+  }
 }
 
 function unmountFocusWithinResponder(
@@ -459,6 +492,8 @@ export const FocusWithinResponder = React.unstable_createResponder(
   focusWithinResponderImpl,
 );
 
-export function useFocusWithinListener(props: FocusWithinListenerProps): void {
-  React.unstable_useListener(FocusWithinResponder, props);
+export function useFocusWithinResponder(
+  props: FocusWithinProps,
+): ReactEventResponderListener<any, any> {
+  return React.unstable_useResponder(FocusWithinResponder, props);
 }
diff --git a/packages/react-events/src/dom/Hover.js b/packages/react-events/src/dom/Hover.js
index 29da49f810069..3d83313100b3e 100644
--- a/packages/react-events/src/dom/Hover.js
+++ b/packages/react-events/src/dom/Hover.js
@@ -11,20 +11,18 @@ import type {
   ReactDOMResponderEvent,
   ReactDOMResponderContext,
 } from 'shared/ReactDOMTypes';
+import type {ReactEventResponderListener} from 'shared/ReactTypes';
 
 import React from 'react';
 import {UserBlockingEvent} from 'shared/ReactTypes';
 
-type HoverListenerProps = {|
+type HoverProps = {
+  disabled: boolean,
+  preventDefault: boolean,
   onHoverChange: boolean => void,
   onHoverEnd: (e: HoverEvent) => void,
   onHoverMove: (e: HoverEvent) => void,
   onHoverStart: (e: HoverEvent) => void,
-|};
-
-type HoverProps = {
-  disabled: boolean,
-  preventDefault: boolean,
 };
 
 type HoverState = {
@@ -65,6 +63,10 @@ if (typeof window !== 'undefined' && window.PointerEvent === undefined) {
   targetEventTypes.push('touchstart', 'mouseover', 'mousemove', 'mouseout');
 }
 
+function isFunction(obj): boolean {
+  return typeof obj === 'function';
+}
+
 function createHoverEvent(
   event: ?ReactDOMResponderEvent,
   context: ReactDOMResponderContext,
@@ -104,8 +106,11 @@ function dispatchHoverChangeEvent(
   props: HoverProps,
   state: HoverState,
 ): void {
-  const bool = state.isActiveHovered;
-  context.dispatchEvent('onHoverChange', bool, UserBlockingEvent);
+  const onHoverChange = props.onHoverChange;
+  if (isFunction(onHoverChange)) {
+    const bool = state.isActiveHovered;
+    context.dispatchEvent(bool, onHoverChange, UserBlockingEvent);
+  }
 }
 
 function dispatchHoverStartEvents(
@@ -133,13 +138,16 @@ function dispatchHoverStartEvents(
 
   if (!state.isActiveHovered) {
     state.isActiveHovered = true;
-    const syntheticEvent = createHoverEvent(
-      event,
-      context,
-      'hoverstart',
-      ((target: any): Element | Document),
-    );
-    context.dispatchEvent('onHoverStart', syntheticEvent, UserBlockingEvent);
+    const onHoverStart = props.onHoverStart;
+    if (isFunction(onHoverStart)) {
+      const syntheticEvent = createHoverEvent(
+        event,
+        context,
+        'hoverstart',
+        ((target: any): Element | Document),
+      );
+      context.dispatchEvent(syntheticEvent, onHoverStart, UserBlockingEvent);
+    }
     dispatchHoverChangeEvent(event, context, props, state);
   }
 }
@@ -169,14 +177,16 @@ function dispatchHoverEndEvents(
 
   if (state.isActiveHovered) {
     state.isActiveHovered = false;
-
-    const syntheticEvent = createHoverEvent(
-      event,
-      context,
-      'hoverend',
-      ((target: any): Element | Document),
-    );
-    context.dispatchEvent('onHoverEnd', syntheticEvent, UserBlockingEvent);
+    const onHoverEnd = props.onHoverEnd;
+    if (isFunction(onHoverEnd)) {
+      const syntheticEvent = createHoverEvent(
+        event,
+        context,
+        'hoverend',
+        ((target: any): Element | Document),
+      );
+      context.dispatchEvent(syntheticEvent, onHoverEnd, UserBlockingEvent);
+    }
     dispatchHoverChangeEvent(event, context, props, state);
     state.hoverTarget = null;
     state.ignoreEmulatedMouseEvents = false;
@@ -262,7 +272,8 @@ const hoverResponderImpl = {
       case 'pointermove':
       case 'mousemove': {
         if (state.isHovered && !isEmulatedMouseEvent(event, state)) {
-          if (state.hoverTarget !== null) {
+          const onHoverMove = props.onHoverMove;
+          if (state.hoverTarget !== null && isFunction(onHoverMove)) {
             const syntheticEvent = createHoverEvent(
               event,
               context,
@@ -270,8 +281,8 @@ const hoverResponderImpl = {
               state.hoverTarget,
             );
             context.dispatchEvent(
-              'onHoverMove',
               syntheticEvent,
+              onHoverMove,
               UserBlockingEvent,
             );
           }
@@ -317,6 +328,8 @@ export const HoverResponder = React.unstable_createResponder(
   hoverResponderImpl,
 );
 
-export function useHoverListener(props: HoverListenerProps): void {
-  React.unstable_useListener(HoverResponder, props);
+export function useHoverResponder(
+  props: HoverProps,
+): ReactEventResponderListener<any, any> {
+  return React.unstable_useResponder(HoverResponder, props);
 }
diff --git a/packages/react-events/src/dom/Input.js b/packages/react-events/src/dom/Input.js
index 84ac774a0c608..5b9046c61350b 100644
--- a/packages/react-events/src/dom/Input.js
+++ b/packages/react-events/src/dom/Input.js
@@ -14,17 +14,15 @@ import type {
 
 import React from 'react';
 import {DiscreteEvent} from 'shared/ReactTypes';
+import type {ReactEventResponderListener} from 'shared/ReactTypes';
 
 type InputEventType = 'change' | 'beforechange' | 'valuechange';
 
-type InputListenerProps = {|
+type InputResponderProps = {
+  disabled: boolean,
   onBeforeChange: (e: InputEvent) => void,
   onChange: (e: InputEvent) => void,
   onValueChange: (value: string | boolean) => void,
-|};
-
-type InputResponderProps = {
-  disabled: boolean,
 };
 
 type InputEvent = {|
@@ -57,6 +55,10 @@ const supportedInputTypes = new Set([
   'week',
 ]);
 
+function isFunction(obj): boolean {
+  return typeof obj === 'function';
+}
+
 function createInputEvent(
   event: ReactDOMResponderEvent,
   context: ReactDOMResponderContext,
@@ -76,14 +78,14 @@ function createInputEvent(
 }
 
 function dispatchInputEvent(
-  eventPropName: string,
   event: ReactDOMResponderEvent,
+  listener: InputEvent => void,
   context: ReactDOMResponderContext,
   type: InputEventType,
   target: Element | Document,
 ): void {
   const syntheticEvent = createInputEvent(event, context, type, target);
-  context.dispatchEvent(eventPropName, syntheticEvent, DiscreteEvent);
+  context.dispatchEvent(syntheticEvent, listener, DiscreteEvent);
 }
 
 function getNodeName(elem: Element | Document): string {
@@ -115,10 +117,14 @@ function shouldUseChangeEvent(elem: Element | Document): boolean {
 
 function dispatchChangeEvent(
   context: ReactDOMResponderContext,
+  props: InputResponderProps,
   target: Element | Document,
 ): void {
-  const value = getValueFromNode(target);
-  context.dispatchEvent('onValueChange', value, DiscreteEvent);
+  const onValueChange = props.onValueChange;
+  if (isFunction(onValueChange)) {
+    const value = getValueFromNode(target);
+    context.dispatchEvent(value, onValueChange, DiscreteEvent);
+  }
 }
 
 function dispatchBothChangeEvents(
@@ -128,8 +134,11 @@ function dispatchBothChangeEvents(
   target: Document | Element,
 ): void {
   context.enqueueStateRestore(target);
-  dispatchInputEvent('onChange', event, context, 'change', target);
-  dispatchChangeEvent(context, target);
+  const onChange = props.onChange;
+  if (isFunction(onChange)) {
+    dispatchInputEvent(event, onChange, context, 'change', target);
+  }
+  dispatchChangeEvent(context, props, target);
 }
 
 function updateValueIfChanged(elem: Element | Document): boolean {
@@ -206,6 +215,8 @@ export const InputResponder = React.unstable_createResponder(
   inputResponderImpl,
 );
 
-export function useInputListener(props: InputListenerProps): void {
-  React.unstable_useListener(InputResponder, props);
+export function useInputResponder(
+  props: InputResponderProps,
+): ReactEventResponderListener<any, any> {
+  return React.unstable_useResponder(InputResponder, props);
 }
diff --git a/packages/react-events/src/dom/Keyboard.js b/packages/react-events/src/dom/Keyboard.js
index de576ea9b99ba..b03da8516191a 100644
--- a/packages/react-events/src/dom/Keyboard.js
+++ b/packages/react-events/src/dom/Keyboard.js
@@ -14,16 +14,14 @@ import type {
 
 import React from 'react';
 import {DiscreteEvent} from 'shared/ReactTypes';
+import type {ReactEventResponderListener} from 'shared/ReactTypes';
 
 type KeyboardEventType = 'keydown' | 'keyup';
 
-type KeyboardListenerProps = {|
+type KeyboardProps = {
+  disabled: boolean,
   onKeyDown: (e: KeyboardEvent) => void,
   onKeyUp: (e: KeyboardEvent) => void,
-|};
-
-type KeyboardResponderProps = {
-  disabled: boolean,
 };
 
 type KeyboardEvent = {|
@@ -105,6 +103,10 @@ const translateToKey = {
   '224': 'Meta',
 };
 
+function isFunction(obj): boolean {
+  return typeof obj === 'function';
+}
+
 function getEventKey(nativeEvent): string {
   const nativeKey = nativeEvent.key;
   if (nativeKey) {
@@ -154,14 +156,14 @@ function createKeyboardEvent(
 }
 
 function dispatchKeyboardEvent(
-  eventPropName: string,
   event: ReactDOMResponderEvent,
+  listener: KeyboardEvent => void,
   context: ReactDOMResponderContext,
   type: KeyboardEventType,
   target: Element | Document,
 ): void {
   const syntheticEvent = createKeyboardEvent(event, context, type, target);
-  context.dispatchEvent(eventPropName, syntheticEvent, DiscreteEvent);
+  context.dispatchEvent(syntheticEvent, listener, DiscreteEvent);
 }
 
 const keyboardResponderImpl = {
@@ -169,7 +171,7 @@ const keyboardResponderImpl = {
   onEvent(
     event: ReactDOMResponderEvent,
     context: ReactDOMResponderContext,
-    props: KeyboardResponderProps,
+    props: KeyboardProps,
   ): void {
     const {responderTarget, type} = event;
 
@@ -177,21 +179,27 @@ const keyboardResponderImpl = {
       return;
     }
     if (type === 'keydown') {
-      dispatchKeyboardEvent(
-        'onKeyDown',
-        event,
-        context,
-        'keydown',
-        ((responderTarget: any): Element | Document),
-      );
+      const onKeyDown = props.onKeyDown;
+      if (isFunction(onKeyDown)) {
+        dispatchKeyboardEvent(
+          event,
+          onKeyDown,
+          context,
+          'keydown',
+          ((responderTarget: any): Element | Document),
+        );
+      }
     } else if (type === 'keyup') {
-      dispatchKeyboardEvent(
-        'onKeyUp',
-        event,
-        context,
-        'keyup',
-        ((responderTarget: any): Element | Document),
-      );
+      const onKeyUp = props.onKeyUp;
+      if (isFunction(onKeyUp)) {
+        dispatchKeyboardEvent(
+          event,
+          onKeyUp,
+          context,
+          'keyup',
+          ((responderTarget: any): Element | Document),
+        );
+      }
     }
   },
 };
@@ -201,6 +209,8 @@ export const KeyboardResponder = React.unstable_createResponder(
   keyboardResponderImpl,
 );
 
-export function useKeyboardListener(props: KeyboardListenerProps): void {
-  React.unstable_useListener(KeyboardResponder, props);
+export function useKeyboardResponder(
+  props: KeyboardProps,
+): ReactEventResponderListener<any, any> {
+  return React.unstable_useResponder(KeyboardResponder, props);
 }
diff --git a/packages/react-events/src/dom/Press.js b/packages/react-events/src/dom/Press.js
index 52274f3846ab3..e63ee0330eb74 100644
--- a/packages/react-events/src/dom/Press.js
+++ b/packages/react-events/src/dom/Press.js
@@ -12,20 +12,14 @@ import type {
   ReactDOMResponderContext,
   PointerType,
 } from 'shared/ReactDOMTypes';
-import type {EventPriority} from 'shared/ReactTypes';
+import type {
+  EventPriority,
+  ReactEventResponderListener,
+} from 'shared/ReactTypes';
 
 import React from 'react';
 import {DiscreteEvent, UserBlockingEvent} from 'shared/ReactTypes';
 
-type PressListenerProps = {|
-  onContextMenu: (e: PressEvent) => void,
-  onPress: (e: PressEvent) => void,
-  onPressChange: boolean => void,
-  onPressEnd: (e: PressEvent) => void,
-  onPressMove: (e: PressEvent) => void,
-  onPressStart: (e: PressEvent) => void,
-|};
-
 type PressProps = {|
   disabled: boolean,
   pressRetentionOffset: {
@@ -37,6 +31,12 @@ type PressProps = {|
   preventContextMenu: boolean,
   preventDefault: boolean,
   stopPropagation: boolean,
+  onContextMenu: (e: PressEvent) => void,
+  onPress: (e: PressEvent) => void,
+  onPressChange: boolean => void,
+  onPressEnd: (e: PressEvent) => void,
+  onPressMove: (e: PressEvent) => void,
+  onPressStart: (e: PressEvent) => void,
 |};
 
 type PressState = {
@@ -51,7 +51,6 @@ type PressState = {
   isPressWithinResponderRegion: boolean,
   pointerType: PointerType,
   pressTarget: null | Element | Document,
-  pressStartTimeout: null | number,
   responderRegionOnActivation: null | $ReadOnly<{|
     bottom: number,
     left: number,
@@ -143,6 +142,10 @@ if (typeof window !== 'undefined' && window.PointerEvent === undefined) {
   );
 }
 
+function isFunction(obj): boolean {
+  return typeof obj === 'function';
+}
+
 function createPressEvent(
   context: ReactDOMResponderContext,
   type: PressEventType,
@@ -202,8 +205,8 @@ function createPressEvent(
 }
 
 function dispatchEvent(
-  eventPropName: string,
   event: ?ReactDOMResponderEvent,
+  listener: any => void,
   context: ReactDOMResponderContext,
   state: PressState,
   name: PressEventType,
@@ -224,15 +227,19 @@ function dispatchEvent(
     touchEvent,
     defaultPrevented,
   );
-  context.dispatchEvent(eventPropName, syntheticEvent, eventPriority);
+  context.dispatchEvent(syntheticEvent, listener, eventPriority);
 }
 
 function dispatchPressChangeEvent(
   context: ReactDOMResponderContext,
+  props: PressProps,
   state: PressState,
 ): void {
-  const bool = state.isActivePressed;
-  context.dispatchEvent('onPressChange', bool, DiscreteEvent);
+  const onPressChange = props.onPressChange;
+  if (isFunction(onPressChange)) {
+    const bool = state.isActivePressed;
+    context.dispatchEvent(bool, onPressChange, DiscreteEvent);
+  }
 }
 
 function dispatchPressStartEvents(
@@ -252,17 +259,20 @@ function dispatchPressStartEvents(
     if (x !== undefined && y !== undefined) {
       state.activationPosition = {x, y};
     }
-
-    dispatchEvent(
-      'onPressStart',
-      event,
-      context,
-      state,
-      'pressstart',
-      DiscreteEvent,
-    );
+    const onPressStart = props.onPressStart;
+
+    if (isFunction(onPressStart)) {
+      dispatchEvent(
+        event,
+        onPressStart,
+        context,
+        state,
+        'pressstart',
+        DiscreteEvent,
+      );
+    }
     if (!wasActivePressed) {
-      dispatchPressChangeEvent(context, state);
+      dispatchPressChangeEvent(context, props, state);
     }
   }
 }
@@ -278,15 +288,19 @@ function dispatchPressEndEvents(
 
   if (state.isActivePressed) {
     state.isActivePressed = false;
-    dispatchEvent(
-      'onPressEnd',
-      event,
-      context,
-      state,
-      'pressend',
-      DiscreteEvent,
-    );
-    dispatchPressChangeEvent(context, state);
+    const onPressEnd = props.onPressEnd;
+
+    if (isFunction(onPressEnd)) {
+      dispatchEvent(
+        event,
+        onPressEnd,
+        context,
+        state,
+        'pressend',
+        DiscreteEvent,
+      );
+    }
+    dispatchPressChangeEvent(context, props, state);
   }
 
   state.responderRegionOnDeactivation = null;
@@ -299,10 +313,6 @@ function dispatchCancel(
   state: PressState,
 ): void {
   state.touchEvent = null;
-  if (state.pressStartTimeout !== null) {
-    context.clearTimeout(state.pressStartTimeout);
-    state.pressStartTimeout = null;
-  }
   if (state.isPressed) {
     state.ignoreEmulatedMouseEvents = false;
     dispatchPressEndEvents(event, context, props, state);
@@ -488,7 +498,6 @@ const pressResponderImpl = {
       isPressed: false,
       isPressWithinResponderRegion: true,
       pointerType: '',
-      pressStartTimeout: null,
       pressTarget: null,
       responderRegionOnActivation: null,
       responderRegionOnDeactivation: null,
@@ -624,14 +633,17 @@ const pressResponderImpl = {
           }
           dispatchCancel(event, context, props, state);
         }
-        dispatchEvent(
-          'onContextMenu',
-          event,
-          context,
-          state,
-          'contextmenu',
-          DiscreteEvent,
-        );
+        const onContextMenu = props.onContextMenu;
+        if (isFunction(onContextMenu)) {
+          dispatchEvent(
+            event,
+            onContextMenu,
+            context,
+            state,
+            'contextmenu',
+            DiscreteEvent,
+          );
+        }
         // Click won't occur, so we need to remove root events
         removeRootEventTypes(context, state);
         break;
@@ -701,14 +713,17 @@ const pressResponderImpl = {
 
         if (state.isPressWithinResponderRegion) {
           if (isPressed) {
-            dispatchEvent(
-              'onPressMove',
-              event,
-              context,
-              state,
-              'pressmove',
-              UserBlockingEvent,
-            );
+            const onPressMove = props.onPressMove;
+            if (isFunction(onPressMove)) {
+              dispatchEvent(
+                event,
+                onPressMove,
+                context,
+                state,
+                'pressmove',
+                UserBlockingEvent,
+              );
+            }
           } else {
             dispatchPressStartEvents(event, context, props, state);
           }
@@ -775,8 +790,9 @@ const pressResponderImpl = {
 
           const pressTarget = state.pressTarget;
           dispatchPressEndEvents(event, context, props, state);
+          const onPress = props.onPress;
 
-          if (pressTarget !== null) {
+          if (pressTarget !== null && isFunction(onPress)) {
             if (
               !isKeyboardEvent &&
               pressTarget !== null &&
@@ -801,8 +817,8 @@ const pressResponderImpl = {
             }
             if (state.isPressWithinResponderRegion && button !== 1) {
               dispatchEvent(
-                'onPress',
                 event,
+                onPress,
                 context,
                 state,
                 'press',
@@ -874,6 +890,8 @@ export const PressResponder = React.unstable_createResponder(
   pressResponderImpl,
 );
 
-export function usePressListener(props: PressListenerProps): void {
-  React.unstable_useListener(PressResponder, props);
+export function usePressResponder(
+  props: PressProps,
+): ReactEventResponderListener<any, any> {
+  return React.unstable_useResponder(PressResponder, props);
 }
diff --git a/packages/react-events/src/dom/Scroll.js b/packages/react-events/src/dom/Scroll.js
index 5a4ebd45b9f6a..5fa1e34a8e5e5 100644
--- a/packages/react-events/src/dom/Scroll.js
+++ b/packages/react-events/src/dom/Scroll.js
@@ -13,20 +13,20 @@ import type {
   PointerType,
 } from 'shared/ReactDOMTypes';
 import {UserBlockingEvent} from 'shared/ReactTypes';
-import type {EventPriority} from 'shared/ReactTypes';
+import type {
+  EventPriority,
+  ReactEventResponderListener,
+} from 'shared/ReactTypes';
 
 import React from 'react';
 
-type ScrollListenerProps = {
+type ScrollProps = {
+  disabled: boolean,
   onScroll: ScrollEvent => void,
   onScrollDragStart: ScrollEvent => void,
   onScrollDragEnd: ScrollEvent => void,
 };
 
-type ScrollProps = {
-  disabled: boolean,
-};
-
 type ScrollState = {
   direction: ScrollDirection,
   pointerType: PointerType,
@@ -71,6 +71,10 @@ const targetEventTypes = [
 ];
 const rootEventTypes = ['touchcancel', 'touchend'];
 
+function isFunction(obj): boolean {
+  return typeof obj === 'function';
+}
+
 function createScrollEvent(
   event: ?ReactDOMResponderEvent,
   context: ReactDOMResponderContext,
@@ -109,8 +113,8 @@ function createScrollEvent(
 }
 
 function dispatchEvent(
-  eventPropName: string,
   event: ?ReactDOMResponderEvent,
+  listener: ScrollEvent => void,
   context: ReactDOMResponderContext,
   state: ScrollState,
   name: ScrollEventType,
@@ -127,7 +131,7 @@ function dispatchEvent(
     pointerType,
     direction,
   );
-  context.dispatchEvent(eventPropName, syntheticEvent, eventPriority);
+  context.dispatchEvent(syntheticEvent, listener, eventPriority);
 }
 
 const scrollResponderImpl = {
@@ -202,23 +206,31 @@ const scrollResponderImpl = {
 
         if (state.isTouching && !state.isDragging) {
           state.isDragging = true;
+          const onScrollDragStart = props.onScrollDragStart;
+
+          if (isFunction(onScrollDragStart)) {
+            dispatchEvent(
+              event,
+              onScrollDragStart,
+              context,
+              state,
+              'scrolldragstart',
+              UserBlockingEvent,
+            );
+          }
+        }
+        const onScroll = props.onScroll;
+
+        if (isFunction(onScroll)) {
           dispatchEvent(
-            'onScrollDragStart',
             event,
+            onScroll,
             context,
             state,
-            'scrolldragstart',
+            'scroll',
             UserBlockingEvent,
           );
         }
-        dispatchEvent(
-          'onScroll',
-          event,
-          context,
-          state,
-          'scroll',
-          UserBlockingEvent,
-        );
         break;
       }
       case 'keyup': {
@@ -253,10 +265,12 @@ const scrollResponderImpl = {
       case 'touchcancel':
       case 'touchend': {
         if (state.isTouching) {
-          if (state.isDragging) {
+          const onScrollDragEnd = props.onScrollDragEnd;
+
+          if (state.isDragging && isFunction(onScrollDragEnd)) {
             dispatchEvent(
-              'onScrollDragEnd',
               event,
+              onScrollDragEnd,
               context,
               state,
               'scrolldragend',
@@ -293,6 +307,8 @@ export const ScrollResponder = React.unstable_createResponder(
   scrollResponderImpl,
 );
 
-export function useScrollListener(props: ScrollListenerProps): void {
-  React.unstable_useListener(ScrollResponder, props);
+export function useScrollResponder(
+  props: ScrollProps,
+): ReactEventResponderListener<any, any> {
+  return React.unstable_useResponder(ScrollResponder, props);
 }
diff --git a/packages/react-events/src/dom/Swipe.js b/packages/react-events/src/dom/Swipe.js
index ba3bbfd462c9c..232ff60aad779 100644
--- a/packages/react-events/src/dom/Swipe.js
+++ b/packages/react-events/src/dom/Swipe.js
@@ -11,11 +11,23 @@ import type {
   ReactDOMResponderEvent,
   ReactDOMResponderContext,
 } from 'shared/ReactDOMTypes';
-import type {EventPriority} from 'shared/ReactTypes';
+import type {
+  EventPriority,
+  ReactEventResponderListener,
+} from 'shared/ReactTypes';
 
 import React from 'react';
 import {UserBlockingEvent, DiscreteEvent} from 'shared/ReactTypes';
 
+type SwipeProps = {
+  disabled: boolean,
+  shouldClaimOwnership: () => boolean,
+  onSwipeMove: (e: SwipeEvent) => void,
+  onSwipeEnd: (e: SwipeEvent) => void,
+  onSwipeLeft: (e: SwipeEvent) => void,
+  onSwipeRight: (e: SwipeEvent) => void,
+};
+
 const targetEventTypes = ['pointerdown'];
 const rootEventTypes = ['pointerup', 'pointercancel', 'pointermove_active'];
 
@@ -46,6 +58,10 @@ type SwipeEvent = {|
   diffY?: number,
 |};
 
+function isFunction(obj): boolean {
+  return typeof obj === 'function';
+}
+
 function createSwipeEvent(
   context: ReactDOMResponderContext,
   type: SwipeEventType,
@@ -63,8 +79,8 @@ function createSwipeEvent(
 }
 
 function dispatchSwipeEvent(
-  eventPropName: string,
   context: ReactDOMResponderContext,
+  listener: SwipeEvent => void,
   name: SwipeEventType,
   state: SwipeState,
   eventPriority: EventPriority,
@@ -72,7 +88,7 @@ function dispatchSwipeEvent(
 ) {
   const target = ((state.swipeTarget: any): Element | Document);
   const syntheticEvent = createSwipeEvent(context, name, target, eventData);
-  context.dispatchEvent(eventPropName, syntheticEvent, eventPriority);
+  context.dispatchEvent(syntheticEvent, listener, eventPriority);
 }
 
 type SwipeState = {
@@ -107,7 +123,7 @@ const swipeResponderImpl = {
   onEvent(
     event: ReactDOMResponderEvent,
     context: ReactDOMResponderContext,
-    props: Object,
+    props: SwipeProps,
     state: SwipeState,
   ): void {
     const {target, type, nativeEvent} = event;
@@ -152,7 +168,7 @@ const swipeResponderImpl = {
   onRootEvent(
     event: ReactDOMResponderEvent,
     context: ReactDOMResponderContext,
-    props: Object,
+    props: SwipeProps,
     state: SwipeState,
   ): void {
     const {type, nativeEvent} = event;
@@ -197,14 +213,18 @@ const swipeResponderImpl = {
             diffX: x - state.startX,
             diffY: y - state.startY,
           };
-          dispatchSwipeEvent(
-            'onSwipeMove',
-            context,
-            'swipemove',
-            state,
-            UserBlockingEvent,
-            eventData,
-          );
+          const onSwipeMove = props.onSwipeMove;
+
+          if (isFunction(onSwipeMove)) {
+            dispatchSwipeEvent(
+              context,
+              onSwipeMove,
+              'swipemove',
+              state,
+              UserBlockingEvent,
+              eventData,
+            );
+          }
           (nativeEvent: any).preventDefault();
         }
         break;
@@ -224,28 +244,38 @@ const swipeResponderImpl = {
           const direction = state.direction;
           const lastDirection = state.lastDirection;
           if (direction !== lastDirection) {
-            if (props.onSwipeLeft && direction === 3) {
-              dispatchSwipeEvent(
-                'onSwipeLeft',
-                context,
-                'swipeleft',
-                state,
-                DiscreteEvent,
-              );
-            } else if (props.onSwipeRight && direction === 1) {
-              dispatchSwipeEvent(
-                'onSwipeRight',
-                context,
-                'swiperight',
-                state,
-                DiscreteEvent,
-              );
+            if (direction === 3) {
+              const onSwipeLeft = props.onSwipeLeft;
+
+              if (isFunction(onSwipeLeft)) {
+                dispatchSwipeEvent(
+                  context,
+                  onSwipeLeft,
+                  'swipeleft',
+                  state,
+                  DiscreteEvent,
+                );
+              }
+            } else if (direction === 1) {
+              const onSwipeRight = props.onSwipeRight;
+
+              if (isFunction(onSwipeRight)) {
+                dispatchSwipeEvent(
+                  context,
+                  onSwipeRight,
+                  'swiperight',
+                  state,
+                  DiscreteEvent,
+                );
+              }
             }
           }
-          if (props.onSwipeEnd) {
+          const onSwipeEnd = props.onSwipeEnd;
+
+          if (isFunction(onSwipeEnd)) {
             dispatchSwipeEvent(
-              'onSwipeEnd',
               context,
+              onSwipeEnd,
               'swipeend',
               state,
               DiscreteEvent,
@@ -268,6 +298,8 @@ export const SwipeResponder = React.unstable_createResponder(
   swipeResponderImpl,
 );
 
-export function useSwipeListener(props: Object): void {
-  React.unstable_useListener(SwipeResponder, props);
+export function useSwipeListener(
+  props: SwipeProps,
+): ReactEventResponderListener<any, any> {
+  return React.unstable_useListener(SwipeResponder, props);
 }
diff --git a/packages/react-events/src/dom/__tests__/Drag-test.internal.js b/packages/react-events/src/dom/__tests__/Drag-test.internal.js
index b117cced1a3c1..560703badff26 100644
--- a/packages/react-events/src/dom/__tests__/Drag-test.internal.js
+++ b/packages/react-events/src/dom/__tests__/Drag-test.internal.js
@@ -12,8 +12,7 @@
 let React;
 let ReactFeatureFlags;
 let ReactDOM;
-let DragResponder;
-let useDragListener;
+let useDragResponder;
 
 describe('Drag event responder', () => {
   let container;
@@ -24,8 +23,7 @@ describe('Drag event responder', () => {
     ReactFeatureFlags.enableFlareAPI = true;
     React = require('react');
     ReactDOM = require('react-dom');
-    DragResponder = require('react-events/drag').DragResponder;
-    useDragListener = require('react-events/drag').useDragListener;
+    useDragResponder = require('react-events/drag').useDragResponder;
 
     container = document.createElement('div');
     document.body.appendChild(container);
@@ -46,11 +44,11 @@ describe('Drag event responder', () => {
     }
 
     function Component() {
-      useDragListener({
+      const listener = useDragResponder({
         onDragChange: handleOnDrag,
       });
       return (
-        <div ref={divRef} responders={<DragResponder />}>
+        <div ref={divRef} listeners={listener}>
           Drag me!
         </div>
       );
@@ -102,12 +100,12 @@ describe('Drag event responder', () => {
     }
 
     function Component() {
-      useDragListener({
+      const listener = useDragResponder({
         onDragStart: handleDragStart,
         onDragEnd: handleDragEnd,
       });
       return (
-        <div ref={divRef} responders={<DragResponder />}>
+        <div ref={divRef} listeners={listener}>
           Drag me!
         </div>
       );
@@ -156,14 +154,13 @@ describe('Drag event responder', () => {
     }
 
     function Component() {
-      useDragListener({
+      const listener = useDragResponder({
         onDragStart: handleDragStart,
         onDragEnd: handleDragEnd,
+        shouldClaimOwnership: () => true,
       });
       return (
-        <div
-          ref={divRef}
-          responders={<DragResponder shouldClaimOwnership={() => true} />}>
+        <div ref={divRef} listeners={listener}>
           Drag me!
         </div>
       );
@@ -211,11 +208,11 @@ describe('Drag event responder', () => {
     }
 
     function Component() {
-      useDragListener({
+      const listener = useDragResponder({
         onDragMove: handleDragMove,
       });
       return (
-        <div ref={divRef} responders={<DragResponder />}>
+        <div ref={divRef} listeners={listener}>
           Drag me!
         </div>
       );
diff --git a/packages/react-events/src/dom/__tests__/Focus-test.internal.js b/packages/react-events/src/dom/__tests__/Focus-test.internal.js
index 100bdb267e739..1c685a14e42ed 100644
--- a/packages/react-events/src/dom/__tests__/Focus-test.internal.js
+++ b/packages/react-events/src/dom/__tests__/Focus-test.internal.js
@@ -14,8 +14,8 @@ let ReactFeatureFlags;
 let ReactDOM;
 let FocusResponder;
 let FocusWithinResponder;
-let useFocusListener;
-let useFocusWithinListener;
+let useFocusResponder;
+let useFocusWithinResponder;
 
 const createEvent = (type, data) => {
   const event = document.createEvent('CustomEvent');
@@ -43,8 +43,9 @@ const modulesInit = () => {
   ReactDOM = require('react-dom');
   FocusResponder = require('react-events/focus').FocusResponder;
   FocusWithinResponder = require('react-events/focus').FocusWithinResponder;
-  useFocusListener = require('react-events/focus').useFocusListener;
-  useFocusWithinListener = require('react-events/focus').useFocusWithinListener;
+  useFocusResponder = require('react-events/focus').useFocusResponder;
+  useFocusWithinResponder = require('react-events/focus')
+    .useFocusWithinResponder;
 };
 
 describe('Focus event responder', () => {
@@ -72,13 +73,12 @@ describe('Focus event responder', () => {
       onFocus = jest.fn();
       ref = React.createRef();
       const Component = () => {
-        useFocusListener({
+        const listener = useFocusResponder({
+          disabled: true,
           onBlur,
           onFocus,
         });
-        return (
-          <div ref={ref} responders={<FocusResponder disabled={true} />} />
-        );
+        return <div ref={ref} listeners={listener} />;
       };
       ReactDOM.render(<Component />, container);
     });
@@ -98,10 +98,10 @@ describe('Focus event responder', () => {
       onBlur = jest.fn();
       ref = React.createRef();
       const Component = () => {
-        useFocusListener({
+        const listener = useFocusResponder({
           onBlur,
         });
-        return <div ref={ref} responders={<FocusResponder />} />;
+        return <div ref={ref} listeners={listener} />;
       };
       ReactDOM.render(<Component />, container);
     });
@@ -121,11 +121,11 @@ describe('Focus event responder', () => {
       ref = React.createRef();
       innerRef = React.createRef();
       const Component = () => {
-        useFocusListener({
+        const listener = useFocusResponder({
           onFocus,
         });
         return (
-          <div ref={ref} responders={<FocusResponder />}>
+          <div ref={ref} listeners={listener}>
             <a ref={innerRef} />
           </div>
         );
@@ -252,11 +252,11 @@ describe('Focus event responder', () => {
       ref = React.createRef();
       innerRef = React.createRef();
       const Component = () => {
-        useFocusListener({
+        const listener = useFocusResponder({
           onFocusChange,
         });
         return (
-          <div ref={ref} responders={<FocusResponder />}>
+          <div ref={ref} listeners={listener}>
             <div ref={innerRef} />
           </div>
         );
@@ -289,11 +289,11 @@ describe('Focus event responder', () => {
       ref = React.createRef();
       innerRef = React.createRef();
       const Component = () => {
-        useFocusListener({
+        const listener = useFocusResponder({
           onFocusVisibleChange,
         });
         return (
-          <div ref={ref} responders={<FocusResponder />}>
+          <div ref={ref} listeners={listener}>
             <div ref={innerRef} />
           </div>
         );
@@ -353,7 +353,7 @@ describe('Focus event responder', () => {
   });
 
   describe('nested Focus components', () => {
-    it('do not propagate events by default', () => {
+    it('propagates events in the correct order', () => {
       const events = [];
       const innerRef = React.createRef();
       const outerRef = React.createRef();
@@ -362,22 +362,22 @@ describe('Focus event responder', () => {
       };
 
       const Inner = () => {
-        useFocusListener({
+        const listener = useFocusResponder({
           onBlur: createEventHandler('inner: onBlur'),
           onFocus: createEventHandler('inner: onFocus'),
           onFocusChange: createEventHandler('inner: onFocusChange'),
         });
-        return <div ref={innerRef} responders={<FocusResponder />} />;
+        return <div ref={innerRef} listeners={listener} />;
       };
 
       const Outer = () => {
-        useFocusListener({
+        const listener = useFocusResponder({
           onBlur: createEventHandler('outer: onBlur'),
           onFocus: createEventHandler('outer: onFocus'),
           onFocusChange: createEventHandler('outer: onFocusChange'),
         });
         return (
-          <div ref={outerRef} responders={<FocusResponder />}>
+          <div ref={outerRef} listeners={listener}>
             <Inner />
           </div>
         );
@@ -432,16 +432,12 @@ describe('FocusWithin event responder', () => {
       onFocusWithinVisibleChange = jest.fn();
       ref = React.createRef();
       const Component = () => {
-        useFocusWithinListener({
+        const listener = useFocusWithinResponder({
+          disabled: true,
           onFocusWithinChange,
           onFocusWithinVisibleChange,
         });
-        return (
-          <div
-            ref={ref}
-            responders={<FocusWithinResponder disabled={true} />}
-          />
-        );
+        return <div ref={ref} listeners={listener} />;
       };
       ReactDOM.render(<Component />, container);
     });
@@ -463,11 +459,11 @@ describe('FocusWithin event responder', () => {
       innerRef = React.createRef();
       innerRef2 = React.createRef();
       const Component = () => {
-        useFocusWithinListener({
+        const listener = useFocusWithinResponder({
           onFocusWithinChange,
         });
         return (
-          <div ref={ref} responders={<FocusWithinResponder />}>
+          <div ref={ref} listeners={listener}>
             <div ref={innerRef} />
             <div ref={innerRef2} />
           </div>
@@ -534,11 +530,11 @@ describe('FocusWithin event responder', () => {
       innerRef = React.createRef();
       innerRef2 = React.createRef();
       const Component = () => {
-        useFocusWithinListener({
+        const listener = useFocusWithinResponder({
           onFocusWithinVisibleChange,
         });
         return (
-          <div ref={ref} responders={<FocusWithinResponder />}>
+          <div ref={ref} listeners={listener}>
             <div ref={innerRef} />
             <div ref={innerRef2} />
           </div>
diff --git a/packages/react-events/src/dom/__tests__/Hover-test.internal.js b/packages/react-events/src/dom/__tests__/Hover-test.internal.js
index 31965b412b328..895a8236046e6 100644
--- a/packages/react-events/src/dom/__tests__/Hover-test.internal.js
+++ b/packages/react-events/src/dom/__tests__/Hover-test.internal.js
@@ -15,7 +15,7 @@ let ReactDOM;
 let TestUtils;
 let Scheduler;
 let HoverResponder;
-let useHoverListener;
+let useHoverResponder;
 
 const createEvent = (type, data) => {
   const event = document.createEvent('CustomEvent');
@@ -52,7 +52,7 @@ describe('Hover event responder', () => {
     TestUtils = require('react-dom/test-utils');
     Scheduler = require('scheduler');
     HoverResponder = require('react-events/hover').HoverResponder;
-    useHoverListener = require('react-events/hover').useHoverListener;
+    useHoverResponder = require('react-events/hover').useHoverResponder;
     container = document.createElement('div');
     document.body.appendChild(container);
   });
@@ -71,13 +71,12 @@ describe('Hover event responder', () => {
       onHoverEnd = jest.fn();
       ref = React.createRef();
       const Component = () => {
-        useHoverListener({
+        const listener = useHoverResponder({
+          disabled: true,
           onHoverStart: onHoverStart,
           onHoverEnd: onHoverEnd,
         });
-        return (
-          <div ref={ref} responders={<HoverResponder disabled={true} />} />
-        );
+        return <div ref={ref} listeners={listener} />;
       };
       ReactDOM.render(<Component />, container);
     });
@@ -97,10 +96,10 @@ describe('Hover event responder', () => {
       onHoverStart = jest.fn();
       ref = React.createRef();
       const Component = () => {
-        useHoverListener({
+        const listener = useHoverResponder({
           onHoverStart: onHoverStart,
         });
-        return <div ref={ref} responders={<HoverResponder />} />;
+        return <div ref={ref} listeners={listener} />;
       };
       ReactDOM.render(<Component />, container);
     });
@@ -176,10 +175,10 @@ describe('Hover event responder', () => {
       onHoverChange = jest.fn();
       ref = React.createRef();
       const Component = () => {
-        useHoverListener({
+        const listener = useHoverResponder({
           onHoverChange,
         });
-        return <div ref={ref} responders={<HoverResponder />} />;
+        return <div ref={ref} listeners={listener} />;
       };
       ReactDOM.render(<Component />, container);
     });
@@ -214,11 +213,11 @@ describe('Hover event responder', () => {
       const target = React.createRef(null);
       function Foo() {
         const [isHover, setHover] = useState(false);
-        useHoverListener({
+        const listener = useHoverResponder({
           onHoverChange: setHover,
         });
         return (
-          <div ref={target} responders={<HoverResponder />}>
+          <div ref={target} listeners={listener}>
             {isHover ? 'hovered' : 'not hovered'}
           </div>
         );
@@ -246,10 +245,10 @@ describe('Hover event responder', () => {
       onHoverEnd = jest.fn();
       ref = React.createRef();
       const Component = () => {
-        useHoverListener({
+        const listener = useHoverResponder({
           onHoverEnd,
         });
-        return <div ref={ref} responders={<HoverResponder />} />;
+        return <div ref={ref} listeners={listener} />;
       };
       ReactDOM.render(<Component />, container);
     });
@@ -315,10 +314,10 @@ describe('Hover event responder', () => {
       const onHoverMove = jest.fn();
       const ref = React.createRef();
       const Component = () => {
-        useHoverListener({
+        const listener = useHoverResponder({
           onHoverMove,
         });
-        return <div ref={ref} responders={<HoverResponder />} />;
+        return <div ref={ref} listeners={listener} />;
       };
       ReactDOM.render(<Component />, container);
 
@@ -342,7 +341,7 @@ describe('Hover event responder', () => {
   });
 
   describe('nested Hover components', () => {
-    it('do not propagate events by default', () => {
+    it('not propagate by default', () => {
       const events = [];
       const innerRef = React.createRef();
       const outerRef = React.createRef();
@@ -351,22 +350,22 @@ describe('Hover event responder', () => {
       };
 
       const Inner = () => {
-        useHoverListener({
+        const listener = useHoverResponder({
           onHoverStart: createEventHandler('inner: onHoverStart'),
           onHoverEnd: createEventHandler('inner: onHoverEnd'),
           onHoverChange: createEventHandler('inner: onHoverChange'),
         });
-        return <div ref={innerRef} responders={<HoverResponder />} />;
+        return <div ref={innerRef} listeners={listener} />;
       };
 
       const Outer = () => {
-        useHoverListener({
+        const listener = useHoverResponder({
           onHoverStart: createEventHandler('outer: onHoverStart'),
           onHoverEnd: createEventHandler('outer: onHoverEnd'),
           onHoverChange: createEventHandler('outer: onHoverChange'),
         });
         return (
-          <div ref={outerRef} responders={<HoverResponder />}>
+          <div ref={outerRef} listeners={listener}>
             <Inner />
           </div>
         );
@@ -427,12 +426,12 @@ describe('Hover event responder', () => {
       eventLog.push(propertiesWeCareAbout);
     };
     const Component = () => {
-      useHoverListener({
+      const listener = useHoverResponder({
         onHoverStart: logEvent,
         onHoverEnd: logEvent,
         onHoverMove: logEvent,
       });
-      return <div ref={ref} responders={<HoverResponder />} />;
+      return <div ref={ref} listeners={listener} />;
     };
     ReactDOM.render(<Component />, container);
 
diff --git a/packages/react-events/src/dom/__tests__/Input-test.internal.js b/packages/react-events/src/dom/__tests__/Input-test.internal.js
index 9cc9cfb097bea..923e35d905581 100644
--- a/packages/react-events/src/dom/__tests__/Input-test.internal.js
+++ b/packages/react-events/src/dom/__tests__/Input-test.internal.js
@@ -13,9 +13,8 @@ let React;
 let ReactFeatureFlags;
 let ReactDOM;
 let InputResponder;
-let useInputListener;
-let PressResponder;
-let usePressListener;
+let useInputResponder;
+let usePressResponder;
 let Scheduler;
 
 const setUntrackedChecked = Object.getOwnPropertyDescriptor(
@@ -42,9 +41,8 @@ const modulesInit = () => {
   ReactDOM = require('react-dom');
   Scheduler = require('scheduler');
   InputResponder = require('react-events/input').InputResponder;
-  useInputListener = require('react-events/input').useInputListener;
-  PressResponder = require('react-events/press').PressResponder;
-  usePressListener = require('react-events/press').usePressListener;
+  useInputResponder = require('react-events/input').useInputResponder;
+  usePressResponder = require('react-events/press').usePressResponder;
 };
 
 describe('Input event responder', () => {
@@ -72,13 +70,12 @@ describe('Input event responder', () => {
       ref = React.createRef();
 
       function Component() {
-        useInputListener({
+        const listener = useInputResponder({
+          disabled: true,
           onChange,
           onValueChange,
         });
-        return (
-          <input ref={ref} responders={<InputResponder disabled={true} />} />
-        );
+        return <input ref={ref} listeners={listener} />;
       }
       ReactDOM.render(<Component />, container);
     });
@@ -120,7 +117,7 @@ describe('Input event responder', () => {
       }
 
       function Component() {
-        useInputListener({
+        const listener = useInputResponder({
           onChange,
           onValueChange,
         });
@@ -129,7 +126,7 @@ describe('Input event responder', () => {
             type="text"
             ref={ref}
             defaultValue="foo"
-            responders={<InputResponder />}
+            listeners={listener}
           />
         );
       }
@@ -160,7 +157,7 @@ describe('Input event responder', () => {
       }
 
       function Component() {
-        useInputListener({
+        const listener = useInputResponder({
           onChange,
           onValueChange,
         });
@@ -169,7 +166,7 @@ describe('Input event responder', () => {
             type="checkbox"
             ref={ref}
             defaultChecked={true}
-            responders={<InputResponder />}
+            listeners={listener}
           />
         );
       }
@@ -203,7 +200,7 @@ describe('Input event responder', () => {
       }
 
       function Component() {
-        useInputListener({
+        const listener = useInputResponder({
           onChange,
           onValueChange,
         });
@@ -212,7 +209,7 @@ describe('Input event responder', () => {
             type="checkbox"
             ref={ref}
             defaultChecked={false}
-            responders={<InputResponder />}
+            listeners={listener}
           />
         );
       }
@@ -245,13 +242,11 @@ describe('Input event responder', () => {
       }
 
       function Component() {
-        useInputListener({
+        const listener = useInputResponder({
           onChange,
           onValueChange,
         });
-        return (
-          <input type="checkbox" ref={ref} responders={<InputResponder />} />
-        );
+        return <input type="checkbox" ref={ref} listeners={listener} />;
       }
       ReactDOM.render(<Component />, container);
 
@@ -288,7 +283,7 @@ describe('Input event responder', () => {
       }
 
       function Component() {
-        useInputListener({
+        const listener = useInputResponder({
           onChange,
           onValueChange,
         });
@@ -297,7 +292,7 @@ describe('Input event responder', () => {
             type="text"
             defaultValue="foo"
             ref={ref}
-            responders={<InputResponder />}
+            listeners={listener}
           />
         );
       }
@@ -350,17 +345,12 @@ describe('Input event responder', () => {
       }
 
       function Component() {
-        useInputListener({
+        const listener = useInputResponder({
           onChange,
           onValueChange,
         });
         return (
-          <input
-            type="text"
-            defaultValue="42"
-            ref={ref}
-            responders={<InputResponder />}
-          />
+          <input type="text" defaultValue="42" ref={ref} listeners={listener} />
         );
       }
       ReactDOM.render(<Component />, container);
@@ -395,7 +385,7 @@ describe('Input event responder', () => {
       }
 
       function Component() {
-        useInputListener({
+        const listener = useInputResponder({
           onChange,
           onValueChange,
         });
@@ -404,7 +394,7 @@ describe('Input event responder', () => {
             type="checkbox"
             defaultChecked={false}
             ref={ref}
-            responders={<InputResponder />}
+            listeners={listener}
           />
         );
       }
@@ -448,11 +438,11 @@ describe('Input event responder', () => {
       }
 
       function Component() {
-        useInputListener({
+        const listener = useInputResponder({
           onChange,
           onValueChange,
         });
-        return <input type="radio" ref={ref} responders={<InputResponder />} />;
+        return <input type="radio" ref={ref} listeners={listener} />;
       }
       ReactDOM.render(<Component />, container);
 
@@ -493,23 +483,19 @@ describe('Input event responder', () => {
       }
 
       function Radio1() {
-        useInputListener({
+        const listener = useInputResponder({
           onChange: onChange1,
           onValueChange: onValueChange1,
         });
-        return (
-          <input type="radio" name="group" responders={<InputResponder />} />
-        );
+        return <input type="radio" name="group" listeners={listener} />;
       }
 
       function Radio2() {
-        useInputListener({
+        const listener = useInputResponder({
           onChange: onChange2,
           onValueChange: onValueChange2,
         });
-        return (
-          <input type="radio" name="group" responders={<InputResponder />} />
-        );
+        return <input type="radio" name="group" listeners={listener} />;
       }
 
       function Component() {
@@ -572,17 +558,12 @@ describe('Input event responder', () => {
         onChangeCalled = 0;
         onValueChangeCalled = 0;
         function Component() {
-          useInputListener({
+          const listener = useInputResponder({
             onChange,
             onValueChange,
           });
           return (
-            <input
-              type={type}
-              name="group"
-              ref={ref}
-              responders={<InputResponder />}
-            />
+            <input type={type} name="group" ref={ref} listeners={listener} />
           );
         }
         ReactDOM.render(<Component />, container);
@@ -605,13 +586,11 @@ describe('Input event responder', () => {
         onChangeCalled = 0;
         onValueChangeCalled = 0;
         function Component2() {
-          useInputListener({
+          const listener = useInputResponder({
             onChange,
             onValueChange,
           });
-          return (
-            <input type={type} ref={ref} responders={<InputResponder />} />
-          );
+          return <input type={type} ref={ref} listeners={listener} />;
         }
         ReactDOM.render(<Component2 />, container);
         // Should be ignored (no change):
@@ -633,13 +612,11 @@ describe('Input event responder', () => {
         onChangeCalled = 0;
         onValueChangeCalled = 0;
         function Component3() {
-          useInputListener({
+          const listener = useInputResponder({
             onChange,
             onValueChange,
           });
-          return (
-            <input type={type} ref={ref} responders={<InputResponder />} />
-          );
+          return <input type={type} ref={ref} listeners={listener} />;
         }
         ReactDOM.render(<Component3 />, container);
         // Should be ignored (no change):
@@ -675,11 +652,11 @@ describe('Input event responder', () => {
       }
 
       function Component() {
-        useInputListener({
+        const listener = useInputResponder({
           onChange,
           onValueChange,
         });
-        return <input type="range" ref={ref} responders={<InputResponder />} />;
+        return <input type="range" ref={ref} listeners={listener} />;
       }
       ReactDOM.render(<Component />, container);
 
@@ -712,11 +689,11 @@ describe('Input event responder', () => {
       }
 
       function Component() {
-        useInputListener({
+        const listener = useInputResponder({
           onChange,
           onValueChange,
         });
-        return <input type="range" ref={ref} responders={<InputResponder />} />;
+        return <input type="range" ref={ref} listeners={listener} />;
       }
       ReactDOM.render(<Component />, container);
 
@@ -784,7 +761,7 @@ describe('Input event responder', () => {
         let ops = [];
 
         function Component({innerRef, onChange, controlledValue}) {
-          useInputListener({
+          const listener = useInputResponder({
             onChange,
           });
           return (
@@ -792,7 +769,7 @@ describe('Input event responder', () => {
               type="text"
               ref={innerRef}
               value={controlledValue}
-              responders={<InputResponder />}
+              listeners={listener}
             />
           );
         }
@@ -844,7 +821,7 @@ describe('Input event responder', () => {
         let ops = [];
 
         function Component({innerRef, onChange, controlledValue}) {
-          useInputListener({
+          const listener = useInputResponder({
             onChange,
           });
           return (
@@ -852,7 +829,7 @@ describe('Input event responder', () => {
               type="checkbox"
               ref={innerRef}
               checked={controlledValue}
-              responders={<InputResponder />}
+              listeners={listener}
             />
           );
         }
@@ -919,7 +896,7 @@ describe('Input event responder', () => {
         let ops = [];
 
         function Component({innerRef, onChange, controlledValue}) {
-          useInputListener({
+          const listener = useInputResponder({
             onChange,
           });
           return (
@@ -927,7 +904,7 @@ describe('Input event responder', () => {
               type="text"
               ref={innerRef}
               value={controlledValue}
-              responders={<InputResponder />}
+              listeners={listener}
             />
           );
         }
@@ -978,8 +955,13 @@ describe('Input event responder', () => {
 
         let ops = [];
 
-        function Component({innerRef, onChange, controlledValue}) {
-          useInputListener({
+        function Component({
+          innerRef,
+          onChange,
+          controlledValue,
+          pressListener,
+        }) {
+          const inputListener = useInputResponder({
             onChange,
           });
           return (
@@ -987,13 +969,13 @@ describe('Input event responder', () => {
               type="text"
               ref={innerRef}
               value={controlledValue}
-              responders={[<InputResponder />, <PressResponder />]}
+              listeners={[inputListener, pressListener]}
             />
           );
         }
 
         function PressWrapper({innerRef, onPress, onChange, controlledValue}) {
-          usePressListener({
+          const pressListener = usePressResponder({
             onPress,
           });
           return (
@@ -1001,6 +983,7 @@ describe('Input event responder', () => {
               onChange={onChange}
               innerRef={el => (input = el)}
               controlledValue={controlledValue}
+              pressListener={pressListener}
             />
           );
         }
diff --git a/packages/react-events/src/dom/__tests__/Keyboard-test.internal.js b/packages/react-events/src/dom/__tests__/Keyboard-test.internal.js
index d00a028574404..3cb373927b608 100644
--- a/packages/react-events/src/dom/__tests__/Keyboard-test.internal.js
+++ b/packages/react-events/src/dom/__tests__/Keyboard-test.internal.js
@@ -12,8 +12,7 @@
 let React;
 let ReactFeatureFlags;
 let ReactDOM;
-let KeyboardResponder;
-let useKeyboardListener;
+let useKeyboardResponder;
 
 const createEvent = (type, data) => {
   const event = document.createEvent('CustomEvent');
@@ -35,8 +34,8 @@ describe('Keyboard event responder', () => {
     ReactFeatureFlags.enableFlareAPI = true;
     React = require('react');
     ReactDOM = require('react-dom');
-    KeyboardResponder = require('react-events/keyboard').KeyboardResponder;
-    useKeyboardListener = require('react-events/keyboard').useKeyboardListener;
+    useKeyboardResponder = require('react-events/keyboard')
+      .useKeyboardResponder;
 
     container = document.createElement('div');
     document.body.appendChild(container);
@@ -56,13 +55,12 @@ describe('Keyboard event responder', () => {
       onKeyUp = jest.fn();
       ref = React.createRef();
       const Component = () => {
-        useKeyboardListener({
+        const listener = useKeyboardResponder({
+          disabled: true,
           onKeyDown,
           onKeyUp,
         });
-        return (
-          <div ref={ref} responders={<KeyboardResponder disabled={true} />} />
-        );
+        return <div ref={ref} listeners={listener} />;
       };
       ReactDOM.render(<Component />, container);
     });
@@ -81,10 +79,10 @@ describe('Keyboard event responder', () => {
       onKeyDown = jest.fn();
       ref = React.createRef();
       const Component = () => {
-        useKeyboardListener({
+        const listener = useKeyboardResponder({
           onKeyDown,
         });
-        return <div ref={ref} responders={<KeyboardResponder />} />;
+        return <div ref={ref} listeners={listener} />;
       };
       ReactDOM.render(<Component />, container);
     });
@@ -112,11 +110,11 @@ describe('Keyboard event responder', () => {
       onKeyUp = jest.fn();
       ref = React.createRef();
       const Component = () => {
-        useKeyboardListener({
+        const listener = useKeyboardResponder({
           onKeyDown,
           onKeyUp,
         });
-        return <div ref={ref} responders={<KeyboardResponder />} />;
+        return <div ref={ref} listeners={listener} />;
       };
       ReactDOM.render(<Component />, container);
     });
diff --git a/packages/react-events/src/dom/__tests__/Press-test.internal.js b/packages/react-events/src/dom/__tests__/Press-test.internal.js
index 6c9b4f66d119d..b60c59eafc1c5 100644
--- a/packages/react-events/src/dom/__tests__/Press-test.internal.js
+++ b/packages/react-events/src/dom/__tests__/Press-test.internal.js
@@ -13,7 +13,7 @@ let React;
 let ReactFeatureFlags;
 let ReactDOM;
 let PressResponder;
-let usePressListener;
+let usePressResponder;
 let Scheduler;
 
 const createEvent = (type, data) => {
@@ -54,7 +54,7 @@ function init() {
   React = require('react');
   ReactDOM = require('react-dom');
   PressResponder = require('react-events/press').PressResponder;
-  usePressListener = require('react-events/press').usePressListener;
+  usePressResponder = require('react-events/press').usePressResponder;
   Scheduler = require('scheduler');
 }
 
@@ -83,14 +83,13 @@ describe('Event responder: Press', () => {
       onPressEnd = jest.fn();
       ref = React.createRef();
       const Component = () => {
-        usePressListener({
+        const listener = usePressResponder({
+          disabled: true,
           onPressStart,
           onPress,
           onPressEnd,
         });
-        return (
-          <div ref={ref} responders={<PressResponder disabled={true} />} />
-        );
+        return <div ref={ref} listeners={listener} />;
       };
       ReactDOM.render(<Component />, container);
     });
@@ -111,10 +110,10 @@ describe('Event responder: Press', () => {
       onPressStart = jest.fn();
       ref = React.createRef();
       const Component = () => {
-        usePressListener({
+        const listener = usePressResponder({
           onPressStart,
         });
-        return <div ref={ref} responders={<PressResponder />} />;
+        return <div ref={ref} listeners={listener} />;
       };
       ReactDOM.render(<Component />, container);
     });
@@ -269,10 +268,10 @@ describe('Event responder: Press', () => {
       onPressEnd = jest.fn();
       ref = React.createRef();
       const Component = () => {
-        usePressListener({
+        const listener = usePressResponder({
           onPressEnd,
         });
-        return <div ref={ref} responders={<PressResponder />} />;
+        return <div ref={ref} listeners={listener} />;
       };
       ReactDOM.render(<Component />, container);
     });
@@ -433,10 +432,10 @@ describe('Event responder: Press', () => {
       onPressChange = jest.fn();
       ref = React.createRef();
       const Component = () => {
-        usePressListener({
+        const listener = usePressResponder({
           onPressChange,
         });
-        return <div ref={ref} responders={<PressResponder />} />;
+        return <div ref={ref} listeners={listener} />;
       };
       ReactDOM.render(<Component />, container);
     });
@@ -467,10 +466,10 @@ describe('Event responder: Press', () => {
       onPress = jest.fn();
       ref = React.createRef();
       const Component = () => {
-        usePressListener({
+        const listener = usePressResponder({
           onPress,
         });
-        return <div ref={ref} responders={<PressResponder />} />;
+        return <div ref={ref} listeners={listener} />;
       };
       ReactDOM.render(<Component />, container);
       ref.current.getBoundingClientRect = () => ({
@@ -514,10 +513,10 @@ describe('Event responder: Press', () => {
 
     it('is not called after auxillary-button press', () => {
       const Component = () => {
-        usePressListener({
+        const listener = usePressResponder({
           onPress,
         });
-        return <div ref={ref} responders={<PressResponder />} />;
+        return <div ref={ref} listeners={listener} />;
       };
       ReactDOM.render(<Component />, container);
 
@@ -540,10 +539,10 @@ describe('Event responder: Press', () => {
     it('is not called after invalid "keyup" event', () => {
       const inputRef = React.createRef();
       const Component = () => {
-        usePressListener({
+        const listener = usePressResponder({
           onPress,
         });
-        return <input ref={inputRef} responders={<PressResponder />} />;
+        return <input ref={inputRef} listeners={listener} />;
       };
       ReactDOM.render(<Component />, container);
       inputRef.current.dispatchEvent(
@@ -580,11 +579,11 @@ describe('Event responder: Press', () => {
       const divRef = React.createRef();
 
       const Component = () => {
-        usePressListener({
+        const listener = usePressResponder({
           onPress,
         });
         return (
-          <div ref={divRef} responders={<PressResponder />}>
+          <div ref={divRef} listeners={listener}>
             <button ref={buttonRef} />
           </div>
         );
@@ -620,10 +619,10 @@ describe('Event responder: Press', () => {
       const onPressMove = jest.fn();
       const ref = React.createRef();
       const Component = () => {
-        usePressListener({
+        const listener = usePressResponder({
           onPressMove,
         });
-        return <div ref={ref} responders={<PressResponder />} />;
+        return <div ref={ref} listeners={listener} />;
       };
       ReactDOM.render(<Component />, container);
 
@@ -653,10 +652,10 @@ describe('Event responder: Press', () => {
       const onPressMove = jest.fn();
       const ref = React.createRef();
       const Component = () => {
-        usePressListener({
+        const listener = usePressResponder({
           onPressMove,
         });
-        return <div ref={ref} responders={<PressResponder />} />;
+        return <div ref={ref} listeners={listener} />;
       };
       ReactDOM.render(<Component />, container);
 
@@ -681,10 +680,10 @@ describe('Event responder: Press', () => {
       const onPressMove = jest.fn();
       const ref = React.createRef();
       const Component = () => {
-        usePressListener({
+        const listener = usePressResponder({
           onPressMove,
         });
-        return <div ref={ref} responders={<PressResponder />} />;
+        return <div ref={ref} listeners={listener} />;
       };
       ReactDOM.render(<Component />, container);
 
@@ -757,14 +756,14 @@ describe('Event responder: Press', () => {
         };
 
         const Component = () => {
-          usePressListener({
+          const listener = usePressResponder({
             onPress: createEventHandler('onPress'),
             onPressChange: createEventHandler('onPressChange'),
             onPressMove: createEventHandler('onPressMove'),
             onPressStart: createEventHandler('onPressStart'),
             onPressEnd: createEventHandler('onPressEnd'),
           });
-          return <div ref={ref} responders={<PressResponder />} />;
+          return <div ref={ref} listeners={listener} />;
         };
         ReactDOM.render(<Component />, container);
 
@@ -795,7 +794,7 @@ describe('Event responder: Press', () => {
         };
 
         const Component = () => {
-          usePressListener({
+          const listener = usePressResponder({
             onPress: createEventHandler('onPress'),
             onPressChange: createEventHandler('onPressChange'),
             onPressMove: createEventHandler('onPressMove'),
@@ -804,7 +803,7 @@ describe('Event responder: Press', () => {
           });
           return (
             <div ref={outerRef}>
-              <div ref={innerRef} responders={<PressResponder />} />
+              <div ref={innerRef} listeners={listener} />
             </div>
           );
         };
@@ -845,21 +844,15 @@ describe('Event responder: Press', () => {
         const pressRetentionOffset = {top: 40, bottom: 40, left: 40, right: 40};
 
         const Component = () => {
-          usePressListener({
+          const listener = usePressResponder({
             onPress: createEventHandler('onPress'),
             onPressChange: createEventHandler('onPressChange'),
             onPressMove: createEventHandler('onPressMove'),
             onPressStart: createEventHandler('onPressStart'),
             onPressEnd: createEventHandler('onPressEnd'),
+            pressRetentionOffset,
           });
-          return (
-            <div
-              ref={ref}
-              responders={
-                <PressResponder pressRetentionOffset={pressRetentionOffset} />
-              }
-            />
-          );
+          return <div ref={ref} listeners={listener} />;
         };
         ReactDOM.render(<Component />, container);
 
@@ -890,12 +883,12 @@ describe('Event responder: Press', () => {
         };
 
         const Component = () => {
-          usePressListener({
+          const listener = usePressResponder({
             onPress: createEventHandler('onPress'),
             onPressStart: createEventHandler('onPressStart'),
             onPressEnd: createEventHandler('onPressEnd'),
           });
-          return <div ref={ref} responders={<PressResponder />} />;
+          return <div ref={ref} listeners={listener} />;
         };
         ReactDOM.render(<Component />, container);
 
@@ -928,12 +921,12 @@ describe('Event responder: Press', () => {
         };
 
         const Component = () => {
-          usePressListener({
+          const listener = usePressResponder({
             onPress: createEventHandler('onPress'),
             onPressStart: createEventHandler('onPressStart'),
             onPressEnd: createEventHandler('onPressEnd'),
           });
-          return <div ref={ref} responders={<PressResponder />} />;
+          return <div ref={ref} listeners={listener} />;
         };
         ReactDOM.render(<Component />, container);
 
@@ -977,14 +970,14 @@ describe('Event responder: Press', () => {
         };
 
         const Component = () => {
-          usePressListener({
+          const listener = usePressResponder({
             onPress: createEventHandler('onPress'),
             onPressChange: createEventHandler('onPressChange'),
             onPressMove: createEventHandler('onPressMove'),
             onPressStart: createEventHandler('onPressStart'),
             onPressEnd: createEventHandler('onPressEnd'),
           });
-          return <div ref={ref} responders={<PressResponder />} />;
+          return <div ref={ref} listeners={listener} />;
         };
         ReactDOM.render(<Component />, container);
 
@@ -1015,14 +1008,14 @@ describe('Event responder: Press', () => {
       };
 
       const Component = () => {
-        usePressListener({
+        const listener = usePressResponder({
           onPress: createEventHandler('onPress'),
           onPressChange: createEventHandler('onPressChange'),
           onPressMove: createEventHandler('onPressMove'),
           onPressStart: createEventHandler('onPressStart'),
           onPressEnd: createEventHandler('onPressEnd'),
         });
-        return <div ref={ref} responders={<PressResponder />} />;
+        return <div ref={ref} listeners={listener} />;
       };
       ReactDOM.render(<Component />, container);
 
@@ -1069,14 +1062,14 @@ describe('Event responder: Press', () => {
       };
 
       const Component = () => {
-        usePressListener({
+        const listener = usePressResponder({
           onPress: createEventHandler('onPress'),
           onPressChange: createEventHandler('onPressChange'),
           onPressMove: createEventHandler('onPressMove'),
           onPressStart: createEventHandler('onPressStart'),
           onPressEnd: createEventHandler('onPressEnd'),
         });
-        return <div ref={ref} responders={<PressResponder />} />;
+        return <div ref={ref} listeners={listener} />;
       };
       ReactDOM.render(<Component />, container);
 
@@ -1134,14 +1127,14 @@ describe('Event responder: Press', () => {
       };
 
       const Component = () => {
-        usePressListener({
+        const listener = usePressResponder({
           onPress: createEventHandler('onPress'),
           onPressChange: createEventHandler('onPressChange'),
           onPressMove: createEventHandler('onPressMove'),
           onPressStart: createEventHandler('onPressStart'),
           onPressEnd: createEventHandler('onPressEnd'),
         });
-        return <div ref={ref} responders={<PressResponder />} />;
+        return <div ref={ref} listeners={listener} />;
       };
       ReactDOM.render(<Component />, container);
 
@@ -1257,14 +1250,14 @@ describe('Event responder: Press', () => {
         };
 
         const Component = () => {
-          usePressListener({
+          const listener = usePressResponder({
             onPress: createEventHandler('onPress'),
             onPressChange: createEventHandler('onPressChange'),
             onPressMove: createEventHandler('onPressMove'),
             onPressStart: createEventHandler('onPressStart'),
             onPressEnd: createEventHandler('onPressEnd'),
           });
-          return <div ref={ref} responders={<PressResponder />} />;
+          return <div ref={ref} listeners={listener} />;
         };
         ReactDOM.render(<Component />, container);
 
@@ -1308,21 +1301,15 @@ describe('Event responder: Press', () => {
         const pressRetentionOffset = {top: 40, bottom: 40, left: 40, right: 40};
 
         const Component = () => {
-          usePressListener({
+          const listener = usePressResponder({
             onPress: createEventHandler('onPress'),
             onPressChange: createEventHandler('onPressChange'),
             onPressMove: createEventHandler('onPressMove'),
             onPressStart: createEventHandler('onPressStart'),
             onPressEnd: createEventHandler('onPressEnd'),
+            pressRetentionOffset,
           });
-          return (
-            <div
-              ref={ref}
-              responders={
-                <PressResponder pressRetentionOffset={pressRetentionOffset} />
-              }
-            />
-          );
+          return <div ref={ref} listeners={listener} />;
         };
         ReactDOM.render(<Component />, container);
 
@@ -1364,12 +1351,12 @@ describe('Event responder: Press', () => {
         };
 
         const Component = () => {
-          usePressListener({
+          const listener = usePressResponder({
             onPress: createEventHandler('onPress'),
             onPressStart: createEventHandler('onPressStart'),
             onPressEnd: createEventHandler('onPressEnd'),
           });
-          return <div ref={ref} responders={<PressResponder />} />;
+          return <div ref={ref} listeners={listener} />;
         };
         ReactDOM.render(<Component />, container);
 
@@ -1417,12 +1404,12 @@ describe('Event responder: Press', () => {
         };
 
         const Component = () => {
-          usePressListener({
+          const listener = usePressResponder({
             onPress: createEventHandler('onPress'),
             onPressStart: createEventHandler('onPressStart'),
             onPressEnd: createEventHandler('onPressEnd'),
           });
-          return <div ref={ref} responders={<PressResponder />} />;
+          return <div ref={ref} listeners={listener} />;
         };
         ReactDOM.render(<Component />, container);
 
@@ -1481,14 +1468,14 @@ describe('Event responder: Press', () => {
         };
 
         const Component = () => {
-          usePressListener({
+          const listener = usePressResponder({
             onPress: createEventHandler('onPress'),
             onPressChange: createEventHandler('onPressChange'),
             onPressMove: createEventHandler('onPressMove'),
             onPressStart: createEventHandler('onPressStart'),
             onPressEnd: createEventHandler('onPressEnd'),
           });
-          return <div ref={ref} responders={<PressResponder />} />;
+          return <div ref={ref} listeners={listener} />;
         };
         ReactDOM.render(<Component />, container);
 
@@ -1538,14 +1525,14 @@ describe('Event responder: Press', () => {
       };
 
       const Component = () => {
-        usePressListener({
+        const listener = usePressResponder({
           onPress: createEventHandler('onPress'),
           onPressChange: createEventHandler('onPressChange'),
           onPressMove: createEventHandler('onPressMove'),
           onPressStart: createEventHandler('onPressStart'),
           onPressEnd: createEventHandler('onPressEnd'),
         });
-        return <div ref={ref} responders={<PressResponder />} />;
+        return <div ref={ref} listeners={listener} />;
       };
       ReactDOM.render(<Component />, container);
 
@@ -1608,17 +1595,18 @@ describe('Event responder: Press', () => {
       };
 
       const Inner = () => {
-        usePressListener({
+        const listener = usePressResponder({
           onPress: createEventHandler('inner: onPress'),
           onPressChange: createEventHandler('inner: onPressChange'),
           onPressMove: createEventHandler('inner: onPressMove'),
           onPressStart: createEventHandler('inner: onPressStart'),
           onPressEnd: createEventHandler('inner: onPressEnd'),
+          stopPropagation: false,
         });
         return (
           <div
             ref={ref}
-            responders={<PressResponder stopPropagation={false} />}
+            listeners={listener}
             onPointerDown={createEventHandler('pointerdown')}
             onPointerUp={createEventHandler('pointerup')}
             onKeyDown={createEventHandler('keydown')}
@@ -1628,7 +1616,7 @@ describe('Event responder: Press', () => {
       };
 
       const Outer = () => {
-        usePressListener({
+        const listener = usePressResponder({
           onPress: createEventHandler('outer: onPress'),
           onPressChange: createEventHandler('outer: onPressChange'),
           onPressMove: createEventHandler('outer: onPressMove'),
@@ -1636,7 +1624,7 @@ describe('Event responder: Press', () => {
           onPressEnd: createEventHandler('outer: onPressEnd'),
         });
         return (
-          <div responders={<PressResponder />}>
+          <div listeners={listener}>
             <Inner />
           </div>
         );
@@ -1665,24 +1653,24 @@ describe('Event responder: Press', () => {
       ]);
     });
 
-    describe('correctly get propagation stopped and do not bubble', () => {
+    describe('correctly not propagate', () => {
       it('for onPress', () => {
         const ref = React.createRef();
         const fn = jest.fn();
 
         const Inner = () => {
-          usePressListener({
+          const listener = usePressResponder({
             onPress: fn,
           });
-          return <div ref={ref} responders={<PressResponder />} />;
+          return <div ref={ref} listeners={listener} />;
         };
 
         const Outer = () => {
-          usePressListener({
+          const listener = usePressResponder({
             onPress: fn,
           });
           return (
-            <div responders={<PressResponder />}>
+            <div listeners={listener}>
               <Inner />
             </div>
           );
@@ -1709,20 +1697,20 @@ describe('Event responder: Press', () => {
         const fn2 = jest.fn();
 
         const Inner = () => {
-          usePressListener({
+          const listener = usePressResponder({
             onPressStart: fn,
             onPressEnd: fn2,
           });
-          return <div ref={ref} responders={<PressResponder />} />;
+          return <div ref={ref} listeners={listener} />;
         };
 
         const Outer = () => {
-          usePressListener({
+          const listener = usePressResponder({
             onPressStart: fn,
             onPressEnd: fn2,
           });
           return (
-            <div responders={<PressResponder />}>
+            <div listeners={listener}>
               <Inner />
             </div>
           );
@@ -1742,18 +1730,18 @@ describe('Event responder: Press', () => {
         const fn = jest.fn();
 
         const Inner = () => {
-          usePressListener({
+          const listener = usePressResponder({
             onPressChange: fn,
           });
-          return <div ref={ref} responders={<PressResponder />} />;
+          return <div ref={ref} listeners={listener} />;
         };
 
         const Outer = () => {
-          usePressListener({
+          const listener = usePressResponder({
             onPressChange: fn,
           });
           return (
-            <div responders={<PressResponder />}>
+            <div listeners={listener}>
               <Inner />
             </div>
           );
@@ -1775,10 +1763,10 @@ describe('Event responder: Press', () => {
       const ref = React.createRef();
 
       const Component = () => {
-        usePressListener({
+        const listener = usePressResponder({
           onPress,
         });
-        return <a href="#" ref={ref} responders={<PressResponder />} />;
+        return <a href="#" ref={ref} listeners={listener} />;
       };
       ReactDOM.render(<Component />, container);
 
@@ -1802,10 +1790,10 @@ describe('Event responder: Press', () => {
       const ref = React.createRef();
 
       const Component = () => {
-        usePressListener({
+        const listener = usePressResponder({
           onPress,
         });
-        return <a href="#" ref={ref} responders={<PressResponder />} />;
+        return <a href="#" ref={ref} listeners={listener} />;
       };
       ReactDOM.render(<Component />, container);
 
@@ -1824,12 +1812,12 @@ describe('Event responder: Press', () => {
       const buttonRef = React.createRef();
 
       const Component = () => {
-        usePressListener({
+        const listener = usePressResponder({
           onPress,
         });
         return (
           <a href="#">
-            <button ref={buttonRef} responders={<PressResponder />} />
+            <button ref={buttonRef} listeners={listener} />
           </a>
         );
       };
@@ -1852,11 +1840,11 @@ describe('Event responder: Press', () => {
       const ref = React.createRef();
 
       const Component = () => {
-        usePressListener({
+        const listener = usePressResponder({
           onPress,
         });
         return (
-          <a href="#" responders={<PressResponder />}>
+          <a href="#" listeners={listener}>
             <div ref={ref} />
           </a>
         );
@@ -1883,10 +1871,10 @@ describe('Event responder: Press', () => {
       const ref = React.createRef();
 
       const Component = () => {
-        usePressListener({
+        const listener = usePressResponder({
           onPress,
         });
-        return <a href="#" ref={ref} responders={<PressResponder />} />;
+        return <a href="#" ref={ref} listeners={listener} />;
       };
       ReactDOM.render(<Component />, container);
 
@@ -1917,16 +1905,11 @@ describe('Event responder: Press', () => {
       const ref = React.createRef();
 
       const Component = () => {
-        usePressListener({
+        const listener = usePressResponder({
           onPress,
+          preventDefault: false,
         });
-        return (
-          <a
-            href="#"
-            ref={ref}
-            responders={<PressResponder preventDefault={false} />}
-          />
-        );
+        return <a href="#" ref={ref} listeners={listener} />;
       };
       ReactDOM.render(<Component />, container);
 
@@ -1950,16 +1933,11 @@ describe('Event responder: Press', () => {
       const ref = React.createRef();
 
       const Component = () => {
-        usePressListener({
+        const listener = usePressResponder({
           onPress,
+          preventDefault: false,
         });
-        return (
-          <a
-            href="#"
-            ref={ref}
-            responders={<PressResponder preventDefault={false} />}
-          />
-        );
+        return <a href="#" ref={ref} listeners={listener} />;
       };
       ReactDOM.render(<Component />, container);
 
@@ -1979,10 +1957,10 @@ describe('Event responder: Press', () => {
       const ref = React.createRef();
 
       const Component = () => {
-        usePressListener({
+        const listener = usePressResponder({
           onPressEnd,
         });
-        return <a href="#" ref={ref} responders={<PressResponder />} />;
+        return <a href="#" ref={ref} listeners={listener} />;
       };
       ReactDOM.render(<Component />, container);
 
@@ -2048,10 +2026,10 @@ describe('Event responder: Press', () => {
     const ref = React.createRef();
 
     const Component = () => {
-      usePressListener({
+      const listener = usePressResponder({
         onPressEnd,
       });
-      return <a href="#" ref={ref} responders={<PressResponder />} />;
+      return <a href="#" ref={ref} listeners={listener} />;
     };
     ReactDOM.render(<Component />, container);
 
@@ -2066,12 +2044,12 @@ describe('Event responder: Press', () => {
     const containerRef = React.createRef();
 
     const Component = () => {
-      usePressListener({
+      const listener = usePressResponder({
         onPressEnd,
       });
       return (
         <div ref={containerRef}>
-          <a ref={ref} responders={<PressResponder />} />
+          <a ref={ref} listeners={listener} />
         </div>
       );
     };
@@ -2088,12 +2066,12 @@ describe('Event responder: Press', () => {
     const outsideRef = React.createRef();
 
     const Component = () => {
-      usePressListener({
+      const listener = usePressResponder({
         onPressEnd,
       });
       return (
         <div>
-          <a ref={ref} responders={<PressResponder />} />
+          <a ref={ref} listeners={listener} />
           <span ref={outsideRef} />
         </div>
       );
@@ -2145,13 +2123,13 @@ describe('Event responder: Press', () => {
     };
 
     const Component = () => {
-      usePressListener({
+      const listener = usePressResponder({
         onPressStart: logEvent,
         onPressEnd: logEvent,
         onPressMove: logEvent,
         onPress: logEvent,
       });
-      return <button ref={ref} responders={<PressResponder />} />;
+      return <button ref={ref} listeners={listener} />;
     };
     ReactDOM.render(<Component />, container);
 
@@ -2294,7 +2272,7 @@ describe('Event responder: Press', () => {
         updateCounter(count => count + 1);
       }
 
-      usePressListener({
+      const listener = usePressResponder({
         onPress: handlePress,
       });
 
@@ -2302,7 +2280,7 @@ describe('Event responder: Press', () => {
         <div>
           <button
             ref={ref}
-            responders={<PressResponder />}
+            listeners={listener}
             onClick={() => {
               updateCounter(count => count + 1);
             }}>
@@ -2361,7 +2339,7 @@ describe('Event responder: Press', () => {
         updateCounter(count => count + 1);
       }
 
-      usePressListener({
+      const listener = usePressResponder({
         onPress: handlePress,
       });
 
@@ -2369,7 +2347,7 @@ describe('Event responder: Press', () => {
         <div>
           <button
             ref={ref}
-            responders={<PressResponder />}
+            listeners={listener}
             onClick={() => {
               // This should flush synchronously
               ReactDOM.unstable_flushDiscreteUpdates();
@@ -2442,14 +2420,14 @@ describe('Event responder: Press', () => {
           updatePressesCount(pressesCount + 1);
         }
 
-        usePressListener({
+        const listener = usePressResponder({
           onPress: handlePress,
         });
 
         return (
           <div>
             <button
-              responders={<PressResponder />}
+              listeners={listener}
               ref={button}
               onClick={() => updateClicksCount(clicksCount + 1)}>
               Presses: {pressesCount}, Clicks: {clicksCount}
@@ -2481,9 +2459,9 @@ describe('Event responder: Press', () => {
       const onContextMenu = jest.fn();
       const ref = React.createRef();
       const Component = () => {
-        usePressListener({onContextMenu});
+        const listener = usePressResponder({onContextMenu});
 
-        return <div ref={ref} responders={<PressResponder />} />;
+        return <div ref={ref} listeners={listener} />;
       };
       ReactDOM.render(<Component />, container);
 
@@ -2507,9 +2485,9 @@ describe('Event responder: Press', () => {
       const ref = React.createRef();
 
       const Component = () => {
-        usePressListener({onContextMenu});
+        const listener = usePressResponder({onContextMenu});
 
-        return <div ref={ref} responders={<PressResponder />} />;
+        return <div ref={ref} listeners={listener} />;
       };
       ReactDOM.render(<Component />, container);
 
@@ -2538,9 +2516,9 @@ describe('Event responder: Press', () => {
       const ref = React.createRef();
 
       const Component = () => {
-        usePressListener({onContextMenu});
+        const listener = usePressResponder({onContextMenu});
 
-        return <div ref={ref} responders={<PressResponder />} />;
+        return <div ref={ref} listeners={listener} />;
       };
       ReactDOM.render(<Component />, container);
 
@@ -2561,9 +2539,9 @@ describe('Event responder: Press', () => {
       const ref = React.createRef();
 
       const Component = () => {
-        usePressListener({onContextMenu});
+        const listener = usePressResponder({onContextMenu});
 
-        return <div ref={ref} responders={<PressResponder />} />;
+        return <div ref={ref} listeners={listener} />;
       };
       ReactDOM.render(<Component />, container);
 
@@ -2579,14 +2557,12 @@ describe('Event responder: Press', () => {
       const ref = React.createRef();
 
       const Component = () => {
-        usePressListener({onContextMenu});
+        const listener = usePressResponder({
+          onContextMenu,
+          preventContextMenu: true,
+        });
 
-        return (
-          <div
-            ref={ref}
-            responders={<PressResponder preventContextMenu={true} />}
-          />
-        );
+        return <div ref={ref} listeners={listener} />;
       };
       ReactDOM.render(<Component />, container);
 
@@ -2606,9 +2582,9 @@ describe('Event responder: Press', () => {
     const pointerDownEvent = jest.fn();
 
     const Component = () => {
-      return (
-        <div ref={ref} responders={<PressResponder stopPropagation={true} />} />
-      );
+      const listener = usePressResponder({stopPropagation: true});
+
+      return <div ref={ref} listeners={listener} />;
     };
 
     container.addEventListener('pointerdown', pointerDownEvent);
@@ -2625,11 +2601,11 @@ describe('Event responder: Press', () => {
     const ref = React.createRef();
     const onPress = jest.fn();
     const Component = () => {
-      usePressListener({onPress});
+      const listener = usePressResponder({onPress});
 
       return (
         <div>
-          <a href="#" ref={ref} responders={<PressResponder />} />
+          <a href="#" ref={ref} listeners={listener} />
         </div>
       );
     };
diff --git a/packages/react-events/src/dom/__tests__/Scroll-test.internal.js b/packages/react-events/src/dom/__tests__/Scroll-test.internal.js
index b49f40acd79b1..aa55e788ee84f 100644
--- a/packages/react-events/src/dom/__tests__/Scroll-test.internal.js
+++ b/packages/react-events/src/dom/__tests__/Scroll-test.internal.js
@@ -12,8 +12,7 @@
 let React;
 let ReactFeatureFlags;
 let ReactDOM;
-let ScrollResponder;
-let useScrollListener;
+let useScrollResponder;
 
 const createEvent = (type, data) => {
   const event = document.createEvent('CustomEvent');
@@ -35,8 +34,7 @@ describe('Scroll event responder', () => {
     ReactFeatureFlags.enableFlareAPI = true;
     React = require('react');
     ReactDOM = require('react-dom');
-    ScrollResponder = require('react-events/scroll').ScrollResponder;
-    useScrollListener = require('react-events/scroll').useScrollListener;
+    useScrollResponder = require('react-events/scroll').useScrollResponder;
 
     container = document.createElement('div');
     document.body.appendChild(container);
@@ -55,12 +53,11 @@ describe('Scroll event responder', () => {
       onScroll = jest.fn();
       ref = React.createRef();
       const Component = () => {
-        useScrollListener({
+        const listener = useScrollResponder({
+          disabled: true,
           onScroll,
         });
-        return (
-          <div ref={ref} responders={<ScrollResponder disabled={true} />} />
-        );
+        return <div ref={ref} listeners={listener} />;
       };
       ReactDOM.render(<Component />, container);
     });
@@ -78,10 +75,10 @@ describe('Scroll event responder', () => {
       onScroll = jest.fn();
       ref = React.createRef();
       const Component = () => {
-        useScrollListener({
+        const listener = useScrollResponder({
           onScroll,
         });
-        return <div ref={ref} responders={<ScrollResponder />} />;
+        return <div ref={ref} listeners={listener} />;
       };
       ReactDOM.render(<Component />, container);
     });
@@ -229,10 +226,10 @@ describe('Scroll event responder', () => {
       onScrollDragStart = jest.fn();
       ref = React.createRef();
       const Component = () => {
-        useScrollListener({
+        const listener = useScrollResponder({
           onScrollDragStart,
         });
-        return <div ref={ref} responders={<ScrollResponder />} />;
+        return <div ref={ref} listeners={listener} />;
       };
       ReactDOM.render(<Component />, container);
     });
@@ -263,10 +260,10 @@ describe('Scroll event responder', () => {
       onScrollDragEnd = jest.fn();
       ref = React.createRef();
       const Component = () => {
-        useScrollListener({
+        const listener = useScrollResponder({
           onScrollDragEnd,
         });
-        return <div ref={ref} responders={<ScrollResponder />} />;
+        return <div ref={ref} listeners={listener} />;
       };
       ReactDOM.render(<Component />, container);
     });
diff --git a/packages/react-events/src/rn/Press.js b/packages/react-events/src/rn/Press.js
index 78713bcd2904d..d2d774b3ba72c 100644
--- a/packages/react-events/src/rn/Press.js
+++ b/packages/react-events/src/rn/Press.js
@@ -20,30 +20,21 @@ import {
   DiscreteEvent,
   UserBlockingEvent,
 } from 'react-native-renderer/src/ReactNativeTypes';
-
-type PressListenerProps = {|
-  onLongPress: (e: PressEvent) => void,
-  onLongPressChange: boolean => void,
-  onPress: (e: PressEvent) => void,
-  onPressChange: boolean => void,
-  onPressEnd: (e: PressEvent) => void,
-  onPressMove: (e: PressEvent) => void,
-  onPressStart: (e: PressEvent) => void,
-|};
+import type {ReactEventResponderListener} from 'shared/ReactTypes';
 
 type PressProps = {
   disabled: boolean,
-  delayLongPress: number,
-  delayPressEnd: number,
-  delayPressStart: number,
   pressRetentionOffset: {
     top: number,
     right: number,
     bottom: number,
     left: number,
   },
-  enableLongPress: boolean,
-  longPressShouldCancelPress: () => boolean,
+  onPress: (e: PressEvent) => void,
+  onPressChange: boolean => void,
+  onPressEnd: (e: PressEvent) => void,
+  onPressMove: (e: PressEvent) => void,
+  onPressStart: (e: PressEvent) => void,
 };
 
 type PressEvent = {|
@@ -68,14 +59,10 @@ type PressState = {
   addedRootEvents: boolean,
   isActivePressed: boolean,
   isActivePressStart: boolean,
-  isLongPressed: boolean,
   isPressed: boolean,
   isPressWithinResponderRegion: boolean,
-  longPressTimeout: null | number,
   pointerType: PointerType,
   pressTarget: null | ReactNativeEventTarget,
-  pressEndTimeout: null | number,
-  pressStartTimeout: null | number,
   responderRegionOnActivation: null | $ReadOnly<{|
     bottom: number,
     left: number,
@@ -97,13 +84,8 @@ type PressEventType =
   | 'pressmove'
   | 'pressstart'
   | 'pressend'
-  | 'presschange'
-  | 'longpress'
-  | 'longpresschange';
+  | 'presschange';
 
-const DEFAULT_PRESS_END_DELAY_MS = 0;
-const DEFAULT_PRESS_START_DELAY_MS = 0;
-const DEFAULT_LONG_PRESS_DELAY_MS = 500;
 const DEFAULT_PRESS_RETENTION_OFFSET = {
   bottom: 20,
   top: 20,
@@ -114,9 +96,8 @@ const DEFAULT_PRESS_RETENTION_OFFSET = {
 const targetEventTypes = ['topTouchStart'];
 const rootEventTypes = ['topTouchMove', 'topTouchEnd', 'topTouchCancel'];
 
-function calculateDelayMS(delay: ?number, min = 0, fallback = 0) {
-  const maybeNumber = delay == null ? null : delay;
-  return Math.max(min, maybeNumber != null ? maybeNumber : fallback);
+function isFunction(obj): boolean {
+  return typeof obj === 'function';
 }
 
 function createPressEvent(
@@ -163,8 +144,8 @@ function createPressEvent(
 }
 
 function dispatchEvent(
-  eventPropName: string,
   event: ?ReactNativeResponderEvent,
+  listener: any => void,
   context: ReactNativeResponderContext,
   state: PressState,
   name: PressEventType,
@@ -179,7 +160,7 @@ function dispatchEvent(
     pointerType,
     state.touchEvent,
   );
-  context.dispatchEvent(eventPropName, syntheticEvent, eventPriority);
+  context.dispatchEvent(syntheticEvent, listener, eventPriority);
 }
 
 function dispatchCancel(event, context, props, state): void {
@@ -267,46 +248,15 @@ function calculateResponderRegion(
   });
 }
 
-function dispatchPressChangeEvent(context, state): void {
-  const bool = state.isActivePressed;
-  context.dispatchEvent('onPressChange', bool, DiscreteEvent);
-}
-
-function dispatchLongPressChangeEvent(context, state): void {
-  const bool = state.isLongPressed;
-  context.dispatchEvent('onLongPressChange', bool, DiscreteEvent);
-}
-
-function activate(event: ReactNativeResponderEvent, context, props, state) {
-  const {pageX: x, pageY: y} = ((state.touchEvent: any): ReactFaricEventTouch);
-  const wasActivePressed = state.isActivePressed;
-  state.isActivePressed = true;
-  if (x !== null && y !== null) {
-    state.activationPosition = {x, y};
-  }
-
-  dispatchEvent(
-    'onPressStart',
-    event,
-    context,
-    state,
-    'pressstart',
-    DiscreteEvent,
-  );
-  if (!wasActivePressed) {
-    dispatchPressChangeEvent(context, state);
-  }
-}
-
-function deactivate(event, context, props, state) {
-  const wasLongPressed = state.isLongPressed;
-  state.isActivePressed = false;
-  state.isLongPressed = false;
-
-  dispatchEvent('onPressEnd', event, context, state, 'pressend', DiscreteEvent);
-  dispatchPressChangeEvent(context, state);
-  if (wasLongPressed && props.enableLongPress) {
-    dispatchLongPressChangeEvent(context, state);
+function dispatchPressChangeEvent(
+  context: ReactNativeResponderContext,
+  props: PressProps,
+  state: PressState,
+): void {
+  const onPressChange = props.onPressChange;
+  if (isFunction(onPressChange)) {
+    const bool = state.isActivePressed;
+    context.dispatchEvent(bool, onPressChange, DiscreteEvent);
   }
 }
 
@@ -367,97 +317,67 @@ function updateIsPressWithinResponderRegion(
   cb();
 }
 
-function dispatchPressStartEvents(event, context, props, state) {
+function dispatchPressStartEvents(
+  event: ReactNativeResponderEvent,
+  context: ReactNativeResponderContext,
+  props: PressProps,
+  state: PressState,
+): void {
   state.isPressed = true;
 
-  if (state.pressEndTimeout !== null) {
-    context.clearTimeout(state.pressEndTimeout);
-    state.pressEndTimeout = null;
-  }
-
-  const dispatch = () => {
+  if (!state.isActivePressStart) {
     state.isActivePressStart = true;
-    activate(event, context, props, state);
-
-    if (!state.isLongPressed && props.enableLongPress) {
-      const delayLongPress = calculateDelayMS(
-        props.delayLongPress,
-        10,
-        DEFAULT_LONG_PRESS_DELAY_MS,
+    const {
+      pageX: x,
+      pageY: y,
+    } = ((state.touchEvent: any): ReactFaricEventTouch);
+    const wasActivePressed = state.isActivePressed;
+    state.isActivePressed = true;
+    if (x !== undefined && y !== undefined) {
+      state.activationPosition = {x, y};
+    }
+    const onPressStart = props.onPressStart;
+
+    if (isFunction(onPressStart)) {
+      dispatchEvent(
+        event,
+        onPressStart,
+        context,
+        state,
+        'pressstart',
+        DiscreteEvent,
       );
-      state.longPressTimeout = context.setTimeout(() => {
-        state.isLongPressed = true;
-        state.longPressTimeout = null;
-        dispatchEvent(
-          'onLongPress',
-          event,
-          context,
-          state,
-          'longpress',
-          DiscreteEvent,
-        );
-        dispatchLongPressChangeEvent(context, state);
-      }, delayLongPress);
     }
-  };
-
-  if (!state.isActivePressStart) {
-    const delayPressStart = calculateDelayMS(
-      props.delayPressStart,
-      0,
-      DEFAULT_PRESS_START_DELAY_MS,
-    );
-    if (delayPressStart > 0) {
-      state.pressStartTimeout = context.setTimeout(() => {
-        state.pressStartTimeout = null;
-        dispatch();
-      }, delayPressStart);
-    } else {
-      dispatch();
+    if (!wasActivePressed) {
+      dispatchPressChangeEvent(context, props, state);
     }
   }
 }
 
-function dispatchPressEndEvents(event, context, props, state): void {
-  const wasActivePressStart = state.isActivePressStart;
-  let activationWasForced = false;
-
+function dispatchPressEndEvents(
+  event: ?ReactNativeResponderEvent,
+  context: ReactNativeResponderContext,
+  props: PressProps,
+  state: PressState,
+): void {
   state.isActivePressStart = false;
   state.isPressed = false;
 
-  if (state.longPressTimeout !== null) {
-    context.clearTimeout(state.longPressTimeout);
-    state.longPressTimeout = null;
-  }
-
-  if (!wasActivePressStart && state.pressStartTimeout !== null) {
-    context.clearTimeout(state.pressStartTimeout);
-    state.pressStartTimeout = null;
-    // don't activate if a press has moved beyond the responder region
-    if (state.isPressWithinResponderRegion && event != null) {
-      // if we haven't yet activated (due to delays), activate now
-      activate(event, context, props, state);
-      activationWasForced = true;
-    }
-  }
-
   if (state.isActivePressed) {
-    const delayPressEnd = calculateDelayMS(
-      props.delayPressEnd,
-      // if activation and deactivation occur during the same event there's no
-      // time for visual user feedback therefore a small delay is added before
-      // deactivating.
-      activationWasForced ? 10 : 0,
-      DEFAULT_PRESS_END_DELAY_MS,
-    );
-    if (delayPressEnd > 0) {
-      state.pressEndTimeout = context.setTimeout(() => {
-        state.pressEndTimeout = null;
-        deactivate(event, context, props, state);
-      }, delayPressEnd);
-    } else {
-      deactivate(event, context, props, state);
+    state.isActivePressed = false;
+    const onPressEnd = props.onPressEnd;
+
+    if (isFunction(onPressEnd)) {
+      dispatchEvent(
+        event,
+        onPressEnd,
+        context,
+        state,
+        'pressend',
+        DiscreteEvent,
+      );
     }
+    dispatchPressChangeEvent(context, props, state);
   }
 
   state.responderRegionOnDeactivation = null;
@@ -472,13 +392,9 @@ const pressResponderImpl = {
       addedRootEvents: false,
       isActivePressed: false,
       isActivePressStart: false,
-      isLongPressed: false,
       isPressed: false,
       isPressWithinResponderRegion: false,
-      longPressTimeout: null,
       pointerType: '',
-      pressEndTimeout: null,
-      pressStartTimeout: null,
       pressTarget: null,
       responderRegionOnActivation: null,
       responderRegionOnDeactivation: null,
@@ -545,26 +461,16 @@ const pressResponderImpl = {
           () => {
             if (state.isPressWithinResponderRegion) {
               if (state.isPressed) {
-                dispatchEvent(
-                  'onPressMove',
-                  event,
-                  context,
-                  state,
-                  'pressmove',
-                  UserBlockingEvent,
-                );
-                if (
-                  state.activationPosition != null &&
-                  state.longPressTimeout != null
-                ) {
-                  const deltaX = state.activationPosition.x - touchEvent.pageX;
-                  const deltaY = state.activationPosition.y - touchEvent.pageY;
-                  if (
-                    Math.hypot(deltaX, deltaY) > 10 &&
-                    state.longPressTimeout != null
-                  ) {
-                    context.clearTimeout(state.longPressTimeout);
-                  }
+                const onPressMove = props.onPressMove;
+                if (isFunction(onPressMove)) {
+                  dispatchEvent(
+                    event,
+                    onPressMove,
+                    context,
+                    state,
+                    'pressmove',
+                    UserBlockingEvent,
+                  );
                 }
               } else {
                 dispatchPressStartEvents(event, context, props, state);
@@ -583,10 +489,10 @@ const pressResponderImpl = {
             return;
           }
           state.touchEvent = touchEvent;
-          const wasLongPressed = state.isLongPressed;
           dispatchPressEndEvents(event, context, props, state);
+          const onPress = props.onPress;
 
-          if (state.pressTarget !== null) {
+          if (state.pressTarget !== null && isFunction(onPress)) {
             // If the event target isn't within the press target, check if we're still
             // within the responder region. The region may have changed if the
             // element's layout was modified after activation.
@@ -598,23 +504,14 @@ const pressResponderImpl = {
               state,
               () => {
                 if (state.isPressWithinResponderRegion) {
-                  if (
-                    !(
-                      wasLongPressed &&
-                      props.enableLongPress &&
-                      props.longPressShouldCancelPress &&
-                      props.longPressShouldCancelPress()
-                    )
-                  ) {
-                    dispatchEvent(
-                      'onPress',
-                      event,
-                      context,
-                      state,
-                      'press',
-                      DiscreteEvent,
-                    );
-                  }
+                  dispatchEvent(
+                    event,
+                    onPress,
+                    context,
+                    state,
+                    'press',
+                    DiscreteEvent,
+                  );
                 }
               },
             );
@@ -636,6 +533,8 @@ export const PressResponder = React.unstable_createResponder(
   pressResponderImpl,
 );
 
-export function usePressListener(props: PressListenerProps): void {
-  React.unstable_useListener(PressResponder, props);
+export function usePressResponder(
+  props: PressProps,
+): ReactEventResponderListener<any, any> {
+  return React.unstable_useResponder(PressResponder, props);
 }
diff --git a/packages/react-native-renderer/src/ReactFabricEventResponderSystem.js b/packages/react-native-renderer/src/ReactFabricEventResponderSystem.js
index 2e300064876d6..7c9ea64374bc3 100644
--- a/packages/react-native-renderer/src/ReactFabricEventResponderSystem.js
+++ b/packages/react-native-renderer/src/ReactFabricEventResponderSystem.js
@@ -7,12 +7,7 @@
  * @flow
  */
 
-import {
-  HostComponent,
-  FunctionComponent,
-  MemoComponent,
-  ForwardRef,
-} from 'shared/ReactWorkTags';
+import {HostComponent} from 'shared/ReactWorkTags';
 import type {Fiber} from 'react-reconciler/src/ReactFiber';
 import {
   batchedEventUpdates,
@@ -49,7 +44,7 @@ const {
 } = Scheduler;
 
 type EventQueueItem = {|
-  listeners: Array<(val: any) => void>,
+  listener: (val: any) => void,
   value: any,
 |};
 type EventQueue = Array<EventQueueItem>;
@@ -98,8 +93,8 @@ let currentTimerIDCounter = 0;
 
 const eventResponderContext: ReactNativeResponderContext = {
   dispatchEvent(
-    eventProp: string,
     eventValue: any,
+    eventListener: any => void,
     eventPriority: EventPriority,
   ): void {
     validateResponderContext();
@@ -107,15 +102,9 @@ const eventResponderContext: ReactNativeResponderContext = {
     if (eventPriority < currentEventQueuePriority) {
       currentEventQueuePriority = eventPriority;
     }
-    const responderInstance = ((currentInstance: any): ReactNativeEventResponderInstance);
-    const target = responderInstance.fiber;
-    const responder = responderInstance.responder;
-    const listeners = collectListeners(eventProp, responder, target);
-    if (listeners.length !== 0) {
-      ((currentEventQueue: any): EventQueue).push(
-        createEventQueueItem(eventValue, listeners),
-      );
-    }
+    ((currentEventQueue: any): EventQueue).push(
+      createEventQueueItem(eventValue, eventListener),
+    );
   },
   isTargetWithinNode(
     childTarget: ReactNativeEventTarget,
@@ -228,11 +217,11 @@ const eventResponderContext: ReactNativeResponderContext = {
 
 function createEventQueueItem(
   value: any,
-  listeners: Array<(val: any) => void>,
+  listener: (val: any) => void,
 ): EventQueueItem {
   return {
     value,
-    listeners,
+    listener,
   };
 }
 
@@ -390,74 +379,13 @@ function releaseOwnershipForEventResponderInstance(
   return false;
 }
 
-// TODO this function is almost an exact copy of the DOM version, we should
-// somehow share the logic
-function collectListeners(
-  eventProp: string,
-  eventResponder: ReactNativeEventResponder,
-  target: Fiber,
-): Array<(any) => void> {
-  const eventListeners = [];
-  let node = target.return;
-  nodeTraversal: while (node !== null) {
-    switch (node.tag) {
-      case HostComponent: {
-        const dependencies = node.dependencies;
-
-        if (dependencies !== null) {
-          const respondersMap = dependencies.responders;
-
-          if (respondersMap !== null && respondersMap.has(eventResponder)) {
-            break nodeTraversal;
-          }
-        }
-        break;
-      }
-      case FunctionComponent:
-      case MemoComponent:
-      case ForwardRef: {
-        const dependencies = node.dependencies;
-
-        if (dependencies !== null) {
-          const listeners = dependencies.listeners;
-
-          if (listeners !== null) {
-            for (
-              let s = 0, listenersLength = listeners.length;
-              s < listenersLength;
-              s++
-            ) {
-              const listener = listeners[s];
-              const {responder, props} = listener;
-              const listenerFunc = props[eventProp];
-
-              if (
-                responder === eventResponder &&
-                typeof listenerFunc === 'function'
-              ) {
-                eventListeners.push(listenerFunc);
-              }
-            }
-          }
-        }
-      }
-    }
-    node = node.return;
-  }
-  return eventListeners;
-}
-
 // TODO this function is almost an exact copy of the DOM version, we should
 // somehow share the logic
 function processEvents(eventQueue: EventQueue): void {
   for (let i = 0, length = eventQueue.length; i < length; i++) {
-    const {value, listeners} = eventQueue[i];
-    for (let s = 0, length2 = listeners.length; s < length2; s++) {
-      const listener = listeners[s];
-      const type =
-        typeof value === 'object' && value !== null ? value.type : '';
-      invokeGuardedCallbackAndCatchFirstError(type, listener, undefined, value);
-    }
+    const {value, listener} = eventQueue[i];
+    const type = typeof value === 'object' && value !== null ? value.type : '';
+    invokeGuardedCallbackAndCatchFirstError(type, listener, undefined, value);
   }
 }
 
diff --git a/packages/react-native-renderer/src/ReactNativeTypes.js b/packages/react-native-renderer/src/ReactNativeTypes.js
index 200bf86592b57..04200f2bb9fa8 100644
--- a/packages/react-native-renderer/src/ReactNativeTypes.js
+++ b/packages/react-native-renderer/src/ReactNativeTypes.js
@@ -198,8 +198,8 @@ export type ReactNativeResponderEvent = {
 
 export type ReactNativeResponderContext = {
   dispatchEvent: (
-    eventProp: string,
     eventValue: any,
+    listener: (any) => void,
     eventPriority: EventPriority,
   ) => void,
   isTargetWithinNode: (
diff --git a/packages/react-reconciler/src/ReactFiber.js b/packages/react-reconciler/src/ReactFiber.js
index 2e1ba80704379..0463f0a9e889b 100644
--- a/packages/react-reconciler/src/ReactFiber.js
+++ b/packages/react-reconciler/src/ReactFiber.js
@@ -107,10 +107,6 @@ if (__DEV__) {
 export type Dependencies = {
   expirationTime: ExpirationTime,
   firstContext: ContextDependency<mixed> | null,
-  listeners: Array<{
-    responder: ReactEventResponder<any, any>,
-    props: Object,
-  }> | null,
   responders: Map<
     ReactEventResponder<any, any>,
     ReactEventResponderInstance<any, any>,
@@ -457,7 +453,6 @@ export function createWorkInProgress(
       : {
           expirationTime: currentDependencies.expirationTime,
           firstContext: currentDependencies.firstContext,
-          listeners: currentDependencies.listeners,
           responders: currentDependencies.responders,
         };
 
@@ -553,7 +548,6 @@ export function resetWorkInProgress(
         : {
             expirationTime: currentDependencies.expirationTime,
             firstContext: currentDependencies.firstContext,
-            listeners: currentDependencies.listeners,
             responders: currentDependencies.responders,
           };
 
diff --git a/packages/react-reconciler/src/ReactFiberBeginWork.js b/packages/react-reconciler/src/ReactFiberBeginWork.js
index f2f15fe7a5c59..c3b0930a62ccd 100644
--- a/packages/react-reconciler/src/ReactFiberBeginWork.js
+++ b/packages/react-reconciler/src/ReactFiberBeginWork.js
@@ -60,7 +60,6 @@ import {
   enableProfilerTimer,
   enableSchedulerTracing,
   enableSuspenseServerRenderer,
-  enableFlareAPI,
   enableFundamentalAPI,
   warnAboutDefaultPropsOnFunctionComponents,
 } from 'shared/ReactFeatureFlags';
@@ -173,7 +172,6 @@ import {
   requestCurrentTime,
   retryTimedOutBoundary,
 } from './ReactFiberWorkLoop';
-import {prepareToReadListenerHooks} from './ReactFiberEvents';
 
 const ReactCurrentOwner = ReactSharedInternals.ReactCurrentOwner;
 
@@ -302,9 +300,6 @@ function updateForwardRef(
   // The rest is a fork of updateFunctionComponent
   let nextChildren;
   prepareToReadContext(workInProgress, renderExpirationTime);
-  if (enableFlareAPI) {
-    prepareToReadListenerHooks(workInProgress);
-  }
   if (__DEV__) {
     ReactCurrentOwner.current = workInProgress;
     setCurrentPhase('render');
@@ -323,9 +318,6 @@ function updateForwardRef(
     ) {
       // Only double-render components with Hooks
       if (workInProgress.memoizedState !== null) {
-        if (enableFlareAPI) {
-          prepareToReadListenerHooks(workInProgress);
-        }
         nextChildren = renderWithHooks(
           current,
           workInProgress,
@@ -628,9 +620,6 @@ function updateFunctionComponent(
 
   let nextChildren;
   prepareToReadContext(workInProgress, renderExpirationTime);
-  if (enableFlareAPI) {
-    prepareToReadListenerHooks(workInProgress);
-  }
   if (__DEV__) {
     ReactCurrentOwner.current = workInProgress;
     setCurrentPhase('render');
@@ -649,9 +638,6 @@ function updateFunctionComponent(
     ) {
       // Only double-render components with Hooks
       if (workInProgress.memoizedState !== null) {
-        if (enableFlareAPI) {
-          prepareToReadListenerHooks(workInProgress);
-        }
         nextChildren = renderWithHooks(
           current,
           workInProgress,
@@ -1248,9 +1234,6 @@ function mountIndeterminateComponent(
   const context = getMaskedContext(workInProgress, unmaskedContext);
 
   prepareToReadContext(workInProgress, renderExpirationTime);
-  if (enableFlareAPI) {
-    prepareToReadListenerHooks(workInProgress);
-  }
   let value;
 
   if (__DEV__) {
@@ -1373,9 +1356,6 @@ function mountIndeterminateComponent(
       ) {
         // Only double-render components with Hooks
         if (workInProgress.memoizedState !== null) {
-          if (enableFlareAPI) {
-            prepareToReadListenerHooks(workInProgress);
-          }
           value = renderWithHooks(
             null,
             workInProgress,
diff --git a/packages/react-reconciler/src/ReactFiberCompleteWork.js b/packages/react-reconciler/src/ReactFiberCompleteWork.js
index 7e7973cacce0f..5d635f4b5fb1a 100644
--- a/packages/react-reconciler/src/ReactFiberCompleteWork.js
+++ b/packages/react-reconciler/src/ReactFiberCompleteWork.js
@@ -13,6 +13,7 @@ import type {
   ReactEventResponder,
   ReactEventResponderInstance,
   ReactFundamentalComponentInstance,
+  ReactEventResponderListener,
 } from 'shared/ReactTypes';
 import type {FiberRoot} from './ReactFiberRoot';
 import type {
@@ -133,6 +134,7 @@ import {
 import {createFundamentalStateInstance} from './ReactFiberFundamental';
 import {Never} from './ReactFiberExpirationTime';
 import {resetChildFibers} from './ReactChildFiber';
+import warning from 'shared/warning';
 
 const emptyObject = {};
 const isArray = Array.isArray;
@@ -690,12 +692,12 @@ function completeWork(
         );
 
         if (enableFlareAPI) {
-          const prevResponders = current.memoizedProps.responders;
-          const nextResponders = newProps.responders;
+          const prevListeners = current.memoizedProps.listeners;
+          const nextListeners = newProps.listeners;
           const instance = workInProgress.stateNode;
-          if (prevResponders !== nextResponders) {
-            updateEventResponders(
-              nextResponders,
+          if (prevListeners !== nextListeners) {
+            updateEventListeners(
+              nextListeners,
               instance,
               rootContainerInstance,
               workInProgress,
@@ -749,10 +751,10 @@ function completeWork(
           appendAllChildren(instance, workInProgress, false, false);
 
           if (enableFlareAPI) {
-            const responders = newProps.responders;
-            if (responders != null) {
-              updateEventResponders(
-                responders,
+            const listeners = newProps.listeners;
+            if (listeners != null) {
+              updateEventListeners(
+                listeners,
                 instance,
                 rootContainerInstance,
                 workInProgress,
@@ -1270,9 +1272,8 @@ function mountEventResponder(
   respondersMap.set(responder, responderInstance);
 }
 
-function updateEventResponder(
-  responder: ReactEventResponder<any, any>,
-  props: Object,
+function updateEventListener(
+  listener: ReactEventResponderListener<any, any>,
   fiber: Fiber,
   visistedResponders: Set<ReactEventResponder<any, any>>,
   respondersMap: Map<
@@ -1282,13 +1283,29 @@ function updateEventResponder(
   instance: Instance,
   rootContainerInstance: Container,
 ): void {
+  let responder;
+  let props;
+
+  if (listener) {
+    responder = listener.responder;
+    props = listener.props;
+  }
   invariant(
     responder && responder.$$typeof === REACT_RESPONDER_TYPE,
-    'An invalid value was used as an event responder. Expect one or many event ' +
-      'responders created via React.unstable_createResponer().',
+    'An invalid value was used as an event listener. Expect one or many event ' +
+      'listeners created via React.unstable_useResponer().',
   );
+  const listenerProps = ((props: any): Object);
   if (visistedResponders.has(responder)) {
     // show warning
+    if (__DEV__) {
+      warning(
+        false,
+        'Duplicate event responder "%s" found in event listeners. ' +
+          'Event listeners passed to elements cannot use the same event responder more than once.',
+        responder.displayName,
+      );
+    }
     return;
   }
   visistedResponders.add(responder);
@@ -1298,7 +1315,7 @@ function updateEventResponder(
     // Mount
     mountEventResponder(
       responder,
-      props,
+      listenerProps,
       instance,
       rootContainerInstance,
       fiber,
@@ -1306,25 +1323,24 @@ function updateEventResponder(
     );
   } else {
     // Update
-    responderInstance.props = props;
+    responderInstance.props = listenerProps;
     responderInstance.fiber = fiber;
   }
 }
 
-function updateEventResponders(
-  responders: any,
+function updateEventListeners(
+  listeners: any,
   instance: Instance,
   rootContainerInstance: Container,
   fiber: Fiber,
 ): void {
   const visistedResponders = new Set();
   let dependencies = fiber.dependencies;
-  if (responders != null) {
+  if (listeners != null) {
     if (dependencies === null) {
       dependencies = fiber.dependencies = {
         expirationTime: NoWork,
         firstContext: null,
-        listeners: null,
         responders: new Map(),
       };
     }
@@ -1332,12 +1348,11 @@ function updateEventResponders(
     if (respondersMap === null) {
       respondersMap = new Map();
     }
-    if (isArray(responders)) {
-      for (let i = 0, length = responders.length; i < length; i++) {
-        const {type, props} = responders[i];
-        updateEventResponder(
-          type,
-          props,
+    if (isArray(listeners)) {
+      for (let i = 0, length = listeners.length; i < length; i++) {
+        const listener = listeners[i];
+        updateEventListener(
+          listener,
           fiber,
           visistedResponders,
           respondersMap,
@@ -1346,10 +1361,8 @@ function updateEventResponders(
         );
       }
     } else {
-      const {type, props} = responders;
-      updateEventResponder(
-        type,
-        props,
+      updateEventListener(
+        listeners,
         fiber,
         visistedResponders,
         respondersMap,
diff --git a/packages/react-reconciler/src/ReactFiberEvents.js b/packages/react-reconciler/src/ReactFiberEvents.js
index 1af4301b3c3d8..a3f4404140d9b 100644
--- a/packages/react-reconciler/src/ReactFiberEvents.js
+++ b/packages/react-reconciler/src/ReactFiberEvents.js
@@ -7,63 +7,28 @@
  * @flow
  */
 
-import type {Fiber, Dependencies} from './ReactFiber';
+import type {Fiber} from './ReactFiber';
 import type {
   ReactEventResponder,
   ReactEventResponderInstance,
+  ReactEventResponderListener,
 } from 'shared/ReactTypes';
 import type {Instance} from './ReactFiberHostConfig';
 
-import {NoWork} from './ReactFiberExpirationTime';
-
 import {SuspenseComponent, Fragment} from 'shared/ReactWorkTags';
 
-let currentlyRenderingFiber: null | Fiber = null;
-let currentListenerHookIndex: number = 0;
-
-export function prepareToReadListenerHooks(workInProgress: Fiber): void {
-  currentlyRenderingFiber = workInProgress;
-  currentListenerHookIndex = 0;
-}
-
-function getListenerHooks(): Array<{
-  responder: ReactEventResponder<any, any>,
-  props: Object,
-}> {
-  let listeners;
-  let dependencies: Dependencies | null = ((currentlyRenderingFiber: any): Fiber)
-    .dependencies;
-  if (dependencies === null) {
-    dependencies = ((currentlyRenderingFiber: any): Fiber).dependencies = {
-      expirationTime: NoWork,
-      firstContext: null,
-      listeners: [],
-      responders: null,
-    };
-  }
-  listeners = dependencies.listeners;
-  if (listeners === null) {
-    dependencies.listeners = listeners = [];
-  }
-  return listeners;
-}
-
-export function updateListenerHook(
+export function createResponderListener(
   responder: ReactEventResponder<any, any>,
   props: Object,
-) {
-  const listeners = getListenerHooks();
-  if (listeners.length === currentListenerHookIndex) {
-    listeners.push({
-      responder,
-      props,
-    });
-    currentListenerHookIndex++;
-  } else {
-    const currentListenerHook = listeners[currentListenerHookIndex++];
-    currentListenerHook.responder = responder;
-    currentListenerHook.props = props;
+): ReactEventResponderListener<any, any> {
+  const eventResponderListener = {
+    responder,
+    props,
+  };
+  if (__DEV__) {
+    Object.freeze(eventResponderListener);
   }
+  return eventResponderListener;
 }
 
 export function isFiberSuspenseAndTimedOut(fiber: Fiber): boolean {
diff --git a/packages/react-reconciler/src/ReactFiberHooks.js b/packages/react-reconciler/src/ReactFiberHooks.js
index 127e64e2cd77b..5ffc5f00f28d4 100644
--- a/packages/react-reconciler/src/ReactFiberHooks.js
+++ b/packages/react-reconciler/src/ReactFiberHooks.js
@@ -7,7 +7,11 @@
  * @flow
  */
 
-import type {ReactEventResponder, ReactContext} from 'shared/ReactTypes';
+import type {
+  ReactEventResponder,
+  ReactContext,
+  ReactEventResponderListener,
+} from 'shared/ReactTypes';
 import type {SideEffectTag} from 'shared/ReactSideEffectTags';
 import type {Fiber} from './ReactFiber';
 import type {ExpirationTime} from './ReactFiberExpirationTime';
@@ -19,7 +23,7 @@ import ReactSharedInternals from 'shared/ReactSharedInternals';
 
 import {NoWork} from './ReactFiberExpirationTime';
 import {readContext} from './ReactFiberNewContext';
-import {updateListenerHook} from './ReactFiberEvents';
+import {createResponderListener} from './ReactFiberEvents';
 import {
   Update as UpdateEffect,
   Passive as PassiveEffect,
@@ -85,7 +89,10 @@ export type Dispatcher = {
     deps: Array<mixed> | void | null,
   ): void,
   useDebugValue<T>(value: T, formatterFn: ?(value: T) => mixed): void,
-  useListener<E, C>(responder: ReactEventResponder<E, C>, props: Object): void,
+  useResponder<E, C>(
+    responder: ReactEventResponder<E, C>,
+    props: Object,
+  ): ReactEventResponderListener<E, C>,
 };
 
 type Update<S, A> = {
@@ -117,7 +124,7 @@ export type HookType =
   | 'useMemo'
   | 'useImperativeHandle'
   | 'useDebugValue'
-  | 'useListener';
+  | 'useResponder';
 
 let didWarnAboutMismatchedHooksForComponent;
 if (__DEV__) {
@@ -1262,7 +1269,7 @@ export const ContextOnlyDispatcher: Dispatcher = {
   useRef: throwInvalidHookError,
   useState: throwInvalidHookError,
   useDebugValue: throwInvalidHookError,
-  useListener: throwInvalidHookError,
+  useResponder: throwInvalidHookError,
 };
 
 const HooksDispatcherOnMount: Dispatcher = {
@@ -1278,7 +1285,7 @@ const HooksDispatcherOnMount: Dispatcher = {
   useRef: mountRef,
   useState: mountState,
   useDebugValue: mountDebugValue,
-  useListener: updateListenerHook,
+  useResponder: createResponderListener,
 };
 
 const HooksDispatcherOnUpdate: Dispatcher = {
@@ -1294,7 +1301,7 @@ const HooksDispatcherOnUpdate: Dispatcher = {
   useRef: updateRef,
   useState: updateState,
   useDebugValue: updateDebugValue,
-  useListener: updateListenerHook,
+  useResponder: createResponderListener,
 };
 
 let HooksDispatcherOnMountInDEV: Dispatcher | null = null;
@@ -1424,10 +1431,13 @@ if (__DEV__) {
       mountHookTypesDev();
       return mountDebugValue(value, formatterFn);
     },
-    useListener<E, C>(responder: ReactEventResponder<E, C>, props) {
-      currentHookNameInDev = 'useListener';
+    useResponder<E, C>(
+      responder: ReactEventResponder<E, C>,
+      props,
+    ): ReactEventResponderListener<E, C> {
+      currentHookNameInDev = 'useResponder';
       mountHookTypesDev();
-      updateListenerHook(responder, props);
+      return createResponderListener(responder, props);
     },
   };
 
@@ -1526,10 +1536,13 @@ if (__DEV__) {
       updateHookTypesDev();
       return mountDebugValue(value, formatterFn);
     },
-    useListener<E, C>(responder: ReactEventResponder<E, C>, props) {
-      currentHookNameInDev = 'useListener';
+    useResponder<E, C>(
+      responder: ReactEventResponder<E, C>,
+      props,
+    ): ReactEventResponderListener<E, C> {
+      currentHookNameInDev = 'useResponder';
       updateHookTypesDev();
-      updateListenerHook(responder, props);
+      return createResponderListener(responder, props);
     },
   };
 
@@ -1628,10 +1641,13 @@ if (__DEV__) {
       updateHookTypesDev();
       return updateDebugValue(value, formatterFn);
     },
-    useListener<E, C>(responder: ReactEventResponder<E, C>, props) {
-      currentHookNameInDev = 'useListener';
+    useResponder<E, C>(
+      responder: ReactEventResponder<E, C>,
+      props,
+    ): ReactEventResponderListener<E, C> {
+      currentHookNameInDev = 'useResponder';
       updateHookTypesDev();
-      updateListenerHook(responder, props);
+      return createResponderListener(responder, props);
     },
   };
 
@@ -1741,11 +1757,14 @@ if (__DEV__) {
       mountHookTypesDev();
       return mountDebugValue(value, formatterFn);
     },
-    useListener<E, C>(responder: ReactEventResponder<E, C>, props) {
-      currentHookNameInDev = 'useListener';
+    useResponder<E, C>(
+      responder: ReactEventResponder<E, C>,
+      props,
+    ): ReactEventResponderListener<E, C> {
+      currentHookNameInDev = 'useResponder';
       warnInvalidHookAccess();
       mountHookTypesDev();
-      updateListenerHook(responder, props);
+      return createResponderListener(responder, props);
     },
   };
 
@@ -1855,11 +1874,14 @@ if (__DEV__) {
       updateHookTypesDev();
       return updateDebugValue(value, formatterFn);
     },
-    useListener<E, C>(responder: ReactEventResponder<E, C>, props) {
-      currentHookNameInDev = 'useListener';
+    useResponder<E, C>(
+      responder: ReactEventResponder<E, C>,
+      props,
+    ): ReactEventResponderListener<E, C> {
+      currentHookNameInDev = 'useResponder';
       warnInvalidHookAccess();
       updateHookTypesDev();
-      updateListenerHook(responder, props);
+      return createResponderListener(responder, props);
     },
   };
 }
diff --git a/packages/react-reconciler/src/ReactFiberNewContext.js b/packages/react-reconciler/src/ReactFiberNewContext.js
index c02b482d1de2b..35540c2ca8ca3 100644
--- a/packages/react-reconciler/src/ReactFiberNewContext.js
+++ b/packages/react-reconciler/src/ReactFiberNewContext.js
@@ -377,7 +377,6 @@ export function readContext<T>(
       currentlyRenderingFiber.dependencies = {
         expirationTime: NoWork,
         firstContext: contextItem,
-        listeners: null,
         responders: null,
       };
     } else {
diff --git a/packages/react-test-renderer/src/ReactShallowRenderer.js b/packages/react-test-renderer/src/ReactShallowRenderer.js
index 8f3ee32ce328a..50897342d92e5 100644
--- a/packages/react-test-renderer/src/ReactShallowRenderer.js
+++ b/packages/react-test-renderer/src/ReactShallowRenderer.js
@@ -19,7 +19,10 @@ import warning from 'shared/warning';
 import is from 'shared/objectIs';
 
 import type {Dispatcher as DispatcherType} from 'react-reconciler/src/ReactFiberHooks';
-import type {ReactContext} from 'shared/ReactTypes';
+import type {
+  ReactContext,
+  ReactEventResponderListener,
+} from 'shared/ReactTypes';
 import type {ReactElement} from 'shared/ReactElementType';
 
 type BasicStateAction<S> = (S => S) | S;
@@ -366,6 +369,14 @@ class ReactShallowRenderer {
       return fn;
     };
 
+    const useResponder = (
+      responder,
+      props,
+    ): ReactEventResponderListener<any, any> => ({
+      props: props,
+      responder,
+    });
+
     return {
       readContext,
       useCallback: (identity: any),
@@ -381,7 +392,7 @@ class ReactShallowRenderer {
       useReducer,
       useRef,
       useState,
-      useListener: noOp,
+      useResponder,
     };
   }
 
diff --git a/packages/react-test-renderer/src/ReactTestHostConfig.js b/packages/react-test-renderer/src/ReactTestHostConfig.js
index a392fcfa2ef95..5f5de45dafd51 100644
--- a/packages/react-test-renderer/src/ReactTestHostConfig.js
+++ b/packages/react-test-renderer/src/ReactTestHostConfig.js
@@ -142,11 +142,11 @@ export function createInstance(
 ): Instance {
   let propsToUse = props;
   if (enableFlareAPI) {
-    if (props.responders != null) {
-      // We want to remove the "responders" prop
-      // as we don't want it into the test renderer instance's
-      // props object.
-      const {responders, ...otherProps} = props; // eslint-disable-line
+    if (props.listeners != null) {
+      // We want to remove the "listeners" prop
+      // as we don't want it in the test renderer's
+      // instance props.
+      const {listeners, ...otherProps} = props; // eslint-disable-line
       propsToUse = otherProps;
     }
   }
diff --git a/packages/react/src/React.js b/packages/react/src/React.js
index cb9588bc5ca0b..09f64fe978263 100644
--- a/packages/react/src/React.js
+++ b/packages/react/src/React.js
@@ -39,7 +39,7 @@ import {
   useReducer,
   useRef,
   useState,
-  useListener,
+  useResponder,
 } from './ReactHooks';
 import {withSuspenseConfig} from './ReactBatchConfig';
 import {
@@ -106,7 +106,7 @@ const React = {
 };
 
 if (enableFlareAPI) {
-  React.unstable_useListener = useListener;
+  React.unstable_useResponder = useResponder;
   React.unstable_createResponder = createResponder;
 }
 
diff --git a/packages/react/src/ReactHooks.js b/packages/react/src/ReactHooks.js
index 66ce438930ccf..1439500670b46 100644
--- a/packages/react/src/ReactHooks.js
+++ b/packages/react/src/ReactHooks.js
@@ -7,7 +7,11 @@
  * @flow
  */
 
-import type {ReactContext, ReactEventResponder} from 'shared/ReactTypes';
+import type {
+  ReactContext,
+  ReactEventResponder,
+  ReactEventResponderListener,
+} from 'shared/ReactTypes';
 import invariant from 'shared/invariant';
 import warning from 'shared/warning';
 import {REACT_RESPONDER_TYPE} from 'shared/ReactSymbols';
@@ -139,20 +143,20 @@ export function useDebugValue(value: any, formatterFn: ?(value: any) => any) {
 
 export const emptyObject = {};
 
-export function useListener(
+export function useResponder(
   responder: ReactEventResponder<any, any>,
-  hookProps: ?Object,
-) {
+  listenerProps: ?Object,
+): ?ReactEventResponderListener<any, any> {
   const dispatcher = resolveDispatcher();
   if (__DEV__) {
     if (responder == null || responder.$$typeof !== REACT_RESPONDER_TYPE) {
       warning(
         false,
-        'useListener: invalid first argument. Expected an event responder, but instead got %s',
+        'useResponder: invalid first argument. Expected an event responder, but instead got %s',
         responder,
       );
       return;
     }
   }
-  return dispatcher.useListener(responder, hookProps || emptyObject);
+  return dispatcher.useResponder(responder, listenerProps || emptyObject);
 }
diff --git a/packages/shared/ReactDOMTypes.js b/packages/shared/ReactDOMTypes.js
index f083d7d919a80..746ea6fa5dd69 100644
--- a/packages/shared/ReactDOMTypes.js
+++ b/packages/shared/ReactDOMTypes.js
@@ -52,8 +52,8 @@ export type ReactDOMFundamentalComponentInstance = ReactFundamentalComponentInst
 
 export type ReactDOMResponderContext = {
   dispatchEvent: (
-    eventProp: string,
     eventValue: any,
+    listener: (any) => void,
     eventPriority: EventPriority,
   ) => void,
   isTargetWithinNode: (
diff --git a/packages/shared/ReactTypes.js b/packages/shared/ReactTypes.js
index 74565344365f1..7f72ce6782c09 100644
--- a/packages/shared/ReactTypes.js
+++ b/packages/shared/ReactTypes.js
@@ -88,6 +88,11 @@ export type ReactEventResponderInstance<E, C> = {|
   target: mixed,
 |};
 
+export type ReactEventResponderListener<E, C> = {|
+  props: Object,
+  responder: ReactEventResponder<E, C>,
+|};
+
 export type ReactEventResponder<E, C> = {
   $$typeof: Symbol | number,
   displayName: string,
diff --git a/scripts/error-codes/codes.json b/scripts/error-codes/codes.json
index bfa391debd603..158bd244ee0b6 100644
--- a/scripts/error-codes/codes.json
+++ b/scripts/error-codes/codes.json
@@ -337,5 +337,6 @@
   "336": "The \"%s\" event responder cannot be used via the \"useEvent\" hook.",
   "337": "An invalid event responder was provided to host component",
   "338": "ReactDOMServer does not yet support the fundamental API.",
-  "339": "An invalid value was used as an event responder. Expect one or many event responders created via React.unstable_createResponer()."
+  "339": "An invalid value was used as an event responder. Expect one or many event responders created via React.unstable_createResponer().",
+  "340": "An invalid value was used as an event listener. Expect one or many event listeners created via React.unstable_useResponer()."
 }