diff --git a/packages/react-interactions/accessibility/README.md b/packages/react-interactions/accessibility/README.md
deleted file mode 100644
index 844af1957f14..000000000000
--- a/packages/react-interactions/accessibility/README.md
+++ /dev/null
@@ -1,25 +0,0 @@
-# `react-interactions/accessibility`
-
-*This package is experimental. It is intended for use with the experimental React
-Scope API that is not available in open source builds.*
-
-Scopes allow for querying of the internal React sub-tree to collect handles to
-host nodes. Scopes also have their own separate tree structure that allows
-traversal of scopes of the same type.
-
-The core API is documented below. Documentation for individual Accessibility Components
-can be found [here](./docs).
-
-## React Scopes
-
-Note: React Scopes require the internal React flag `enableScopeAPI`.
-
-## React Scope Interface
-
-Scopes require a `ref` to access the internal interface of a particular scope.
-The internal interface (`ReactScopeInterface`) exposes the following scope API:
-
-### containsNode: (node: HTMLElement) => boolean
-
-Returns `true` or `false` depending on if the given `HTMLElement` is a descendant
-of the scope's sub-tree.
\ No newline at end of file
diff --git a/packages/react-interactions/accessibility/docs/FocusContain.md b/packages/react-interactions/accessibility/docs/FocusContain.md
deleted file mode 100644
index 724cbaacdafa..000000000000
--- a/packages/react-interactions/accessibility/docs/FocusContain.md
+++ /dev/null
@@ -1,27 +0,0 @@
-# FocusContain
-
-`FocusContain` is a component that contains user-focusability to only that
-of the children of the component. This means focus control will not escape
-unless the componoent is disabled (using the `disabled` prop) or unmounted.
-Additionally, `FocusContain` can contain tab focus when passed a `ReactScope`
-using the `tabFocus` prop.
-
-## Usage
-
-```jsx
-import FocusContain from 'react-interactions/accessibility/focus-contain';
-import tabbableScopeQuery from 'react-interactions/accessibility/tabbable-scope-query';
-
-function MyDialog(props) {
-  return (
-    <FocusContain scopeQuery={tabbableScopeQuery} disabled={false}>
-      <div>
-        <h2>{props.title}<h2>
-        <p>{props.text}</p>
-        <Button onPress={...}>Accept</Button>
-        <Button onPress={...}>Close</Button>
-      </div>
-    </FocusContain>
-  )
-}
-```
diff --git a/packages/react-interactions/accessibility/docs/FocusManager.md b/packages/react-interactions/accessibility/docs/FocusManager.md
deleted file mode 100644
index f928ea13d6e9..000000000000
--- a/packages/react-interactions/accessibility/docs/FocusManager.md
+++ /dev/null
@@ -1,63 +0,0 @@
-# FocusManager
-
-`FocusManager` is a module that exports a selection of helpful utility functions to be used
-in conjunction with the `ref` from a React Scope, such as `TabbableScope`.
-
-## Example
-
-```jsx
-import {
-  focusFirst,
-  focusNext,
-  focusPrevious,
-  getNextScope,
-  getPreviousScope,
-} from 'react-interactions/accessibility/focus-manager';
-
-function scopeQuery(type) {
-  return type === 'div';
-}
-
-function KeyboardFocusMover(props) {
-  const scopeRef = useRef(null);
-
-  useEffect(() => {
-    const scope = scopeRef.current;
-
-    if (scope) {
-      // Focus the first tabbable DOM node in my children
-      focusFirst(scopeQuery, scope);
-      // Then focus the next chilkd
-      focusNext(scopeQuery, scope);
-    }
-  });
-  
-  return (
-    <TabbableScope ref={scopeRef}>
-      {props.children}
-    </TabbableScope>
-  );
-}
-```
-
-## FocusManager API
-
-### `focusFirst`
-
-Focus the first node that matches the given scope.
-
-### `focusNext`
-
-Focus the next sequential node that matches the given scope.
-
-### `focusPrevious`
-
-Focus the previous sequential node that matches the given scope.
-
-### `getNextScope`
-
-Focus the first node that matches the next sibling scope from the given scope.
-
-### `getPreviousScope`
-
-Focus the first node that matches the previous sibling scope from the given scope.
diff --git a/packages/react-interactions/accessibility/docs/TabbableScopeQuery.md b/packages/react-interactions/accessibility/docs/TabbableScopeQuery.md
deleted file mode 100644
index 47fc5dff3550..000000000000
--- a/packages/react-interactions/accessibility/docs/TabbableScopeQuery.md
+++ /dev/null
@@ -1,31 +0,0 @@
-# TabbableScopeQuery
-
-`TabbableScopeQuery` is a custom scope implementation that can be used with
-`FocusContain`, `FocusGroup`, `FocusTable` and `FocusManager` modules.
-
-## Usage
-
-```jsx
-import tabbableScopeQuery from 'react-interactions/accessibility/tabbable-scope-query';
-
-function FocusableNodeCollector(props) {
-  const scopeRef = useRef(null);
-
-  useEffect(() => {
-    const scope = scopeRef.current;
-
-    if (scope) {
-      const tabFocusableNodes = scope.DO_NOT_USE_queryAllNodes(tabbableScopeQuery);
-      if (tabFocusableNodes && props.onFocusableNodes) {
-        props.onFocusableNodes(tabFocusableNodes);
-      }
-    }
-  });
-  
-  return (
-    <TabbableScope ref={scopeRef}>
-      {props.children}
-    </TabbableScope>
-  );
-}
-```
diff --git a/packages/react-interactions/accessibility/focus-contain.js b/packages/react-interactions/accessibility/focus-contain.js
deleted file mode 100644
index b1c3e6d2e945..000000000000
--- a/packages/react-interactions/accessibility/focus-contain.js
+++ /dev/null
@@ -1,12 +0,0 @@
-/**
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- *
- * @flow
- */
-
-'use strict';
-
-module.exports = require('./src/FocusContain');
diff --git a/packages/react-interactions/accessibility/focus-group.js b/packages/react-interactions/accessibility/focus-group.js
deleted file mode 100644
index 9bfd7e41b96a..000000000000
--- a/packages/react-interactions/accessibility/focus-group.js
+++ /dev/null
@@ -1,12 +0,0 @@
-/**
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- *
- * @flow
- */
-
-'use strict';
-
-module.exports = require('./src/FocusGroup');
diff --git a/packages/react-interactions/accessibility/focus-manager.js b/packages/react-interactions/accessibility/focus-manager.js
deleted file mode 100644
index 56d396157c22..000000000000
--- a/packages/react-interactions/accessibility/focus-manager.js
+++ /dev/null
@@ -1,12 +0,0 @@
-/**
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- *
- * @flow
- */
-
-'use strict';
-
-module.exports = require('./src/FocusManager');
diff --git a/packages/react-interactions/accessibility/focus-table.js b/packages/react-interactions/accessibility/focus-table.js
deleted file mode 100644
index bdd6c08fe9b4..000000000000
--- a/packages/react-interactions/accessibility/focus-table.js
+++ /dev/null
@@ -1,12 +0,0 @@
-/**
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- *
- * @flow
- */
-
-'use strict';
-
-module.exports = require('./src/FocusTable');
diff --git a/packages/react-interactions/accessibility/src/FocusContain.js b/packages/react-interactions/accessibility/src/FocusContain.js
deleted file mode 100644
index 21c0b3cc894f..000000000000
--- a/packages/react-interactions/accessibility/src/FocusContain.js
+++ /dev/null
@@ -1,88 +0,0 @@
-/**
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- *
- * @flow
- */
-
-import type {KeyboardEvent} from 'react-interactions/events/keyboard';
-
-import React from 'react';
-import {useFocusWithin} from 'react-interactions/events/focus';
-import {useKeyboard} from 'react-interactions/events/keyboard';
-import {
-  focusPrevious,
-  focusNext,
-} from 'react-interactions/accessibility/focus-manager';
-
-type FocusContainProps = {|
-  children: React.Node,
-  disabled?: boolean,
-  scopeQuery: (type: string | Object, props: Object) => boolean,
-|};
-
-const {useLayoutEffect, useRef} = React;
-
-const FocusContainScope = React.unstable_createScope();
-
-export default function FocusContain({
-  children,
-  disabled,
-  scopeQuery,
-}: FocusContainProps): React.Node {
-  const scopeRef = useRef(null);
-  // This ensures tabbing works through the React tree (including Portals and Suspense nodes)
-  const keyboard = useKeyboard({
-    onKeyDown(event: KeyboardEvent): void {
-      if (disabled === true || event.key !== 'Tab') {
-        event.continuePropagation();
-        return;
-      }
-      const scope = scopeRef.current;
-      if (scope !== null) {
-        if (event.shiftKey) {
-          focusPrevious(scopeQuery, scope, event, true);
-        } else {
-          focusNext(scopeQuery, scope, event, true);
-        }
-      }
-    },
-  });
-  const focusWithin = useFocusWithin({
-    onBlurWithin: function(event) {
-      if (disabled === true) {
-        event.continuePropagation();
-        return;
-      }
-      const lastNode = event.target;
-      if (lastNode) {
-        requestAnimationFrame(() => {
-          (lastNode: any).focus();
-        });
-      }
-    },
-  });
-  useLayoutEffect(() => {
-    const scope = scopeRef.current;
-    if (
-      scope !== null &&
-      disabled !== true &&
-      !scope.containsNode(document.activeElement)
-    ) {
-      const fistElem = scope.DO_NOT_USE_queryFirstNode(scopeQuery);
-      if (fistElem !== null) {
-        fistElem.focus();
-      }
-    }
-  }, [disabled]);
-
-  return (
-    <FocusContainScope
-      ref={scopeRef}
-      DEPRECATED_flareListeners={[keyboard, focusWithin]}>
-      {children}
-    </FocusContainScope>
-  );
-}
diff --git a/packages/react-interactions/accessibility/src/FocusGroup.js b/packages/react-interactions/accessibility/src/FocusGroup.js
deleted file mode 100644
index 8ac102fc07d6..000000000000
--- a/packages/react-interactions/accessibility/src/FocusGroup.js
+++ /dev/null
@@ -1,233 +0,0 @@
-/**
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- *
- * @flow
- */
-
-import type {ReactScopeMethods} from 'shared/ReactTypes';
-import type {KeyboardEvent} from 'react-interactions/events/keyboard';
-
-import React from 'react';
-import {useKeyboard} from 'react-interactions/events/keyboard';
-import setElementCanTab from './shared/setElementCanTab';
-
-type FocusItemProps = {
-  children?: React.Node,
-  onKeyDown?: KeyboardEvent => void,
-  ...
-};
-
-type FocusGroupProps = {|
-  children: React.Node,
-  portrait: boolean,
-  wrap?: boolean,
-  tabScopeQuery?: (type: string | Object, props: Object) => boolean,
-  allowModifiers?: boolean,
-|};
-
-const {useRef} = React;
-
-function focusGroupItem(
-  scopeQuery: (type: string | Object, props: Object) => boolean,
-  cell: ReactScopeMethods,
-  event: KeyboardEvent,
-): void {
-  const firstScopedNode = cell.DO_NOT_USE_queryFirstNode(scopeQuery);
-  if (firstScopedNode !== null) {
-    firstScopedNode.focus();
-    event.preventDefault();
-  }
-}
-
-function getPreviousGroupItem(
-  group: ReactScopeMethods,
-  currentItem: ReactScopeMethods,
-): null | ReactScopeMethods {
-  const items = group.DO_NOT_USE_getChildren();
-  if (items !== null) {
-    const currentItemIndex = items.indexOf(currentItem);
-    const wrap = getGroupProps(currentItem).wrap;
-    if (currentItemIndex === 0 && wrap) {
-      return items[items.length - 1] || null;
-    } else if (currentItemIndex > 0) {
-      return items[currentItemIndex - 1] || null;
-    }
-  }
-  return null;
-}
-
-function getNextGroupItem(
-  group: ReactScopeMethods,
-  currentItem: ReactScopeMethods,
-): null | ReactScopeMethods {
-  const items = group.DO_NOT_USE_getChildren();
-  if (items !== null) {
-    const currentItemIndex = items.indexOf(currentItem);
-    const wrap = getGroupProps(currentItem).wrap;
-    const end = currentItemIndex === items.length - 1;
-    if (end && wrap) {
-      return items[0] || null;
-    } else if (currentItemIndex !== -1 && !end) {
-      return items[currentItemIndex + 1] || null;
-    }
-  }
-  return null;
-}
-
-function getGroupProps(currentCell: ReactScopeMethods): Object {
-  const group = currentCell.DO_NOT_USE_getParent();
-  if (group !== null) {
-    const groupProps = group.DO_NOT_USE_getProps();
-    if (groupProps && groupProps.type === 'group') {
-      return groupProps;
-    }
-  }
-  return {};
-}
-
-function hasModifierKey(event: KeyboardEvent): boolean {
-  const {altKey, ctrlKey, metaKey, shiftKey} = event;
-  return (
-    altKey === true || ctrlKey === true || metaKey === true || shiftKey === true
-  );
-}
-
-export function createFocusGroup(
-  scopeQuery: (type: string | Object, props: Object) => boolean,
-): [(FocusGroupProps) => React.Node, (FocusItemProps) => React.Node] {
-  const TableScope = React.unstable_createScope();
-
-  function Group({
-    children,
-    portrait,
-    wrap,
-    tabScopeQuery,
-    allowModifiers,
-  }: FocusGroupProps): React.Node {
-    return (
-      <TableScope
-        type="group"
-        portrait={portrait}
-        wrap={wrap}
-        tabScopeQuery={tabScopeQuery}
-        allowModifiers={allowModifiers}>
-        {children}
-      </TableScope>
-    );
-  }
-
-  function Item({children, onKeyDown}: FocusItemProps): React.Node {
-    const scopeRef = useRef(null);
-    const keyboard = useKeyboard({
-      onKeyDown(event: KeyboardEvent): void {
-        const currentItem = scopeRef.current;
-        if (currentItem !== null) {
-          const group = currentItem.DO_NOT_USE_getParent();
-          const groupProps = group && group.DO_NOT_USE_getProps();
-          if (group !== null && groupProps.type === 'group') {
-            const portrait = groupProps.portrait;
-            const key = event.key;
-
-            if (key === 'Tab') {
-              const tabScopeQuery = getGroupProps(currentItem).tabScopeQuery;
-              if (tabScopeQuery) {
-                const groupScope = currentItem.DO_NOT_USE_getParent();
-                if (groupScope) {
-                  const activeNode = document.activeElement;
-                  const nodes = groupScope.DO_NOT_USE_queryAllNodes(
-                    tabScopeQuery,
-                  );
-                  for (let i = 0; i < nodes.length; i++) {
-                    const node = nodes[i];
-                    if (node !== activeNode) {
-                      setElementCanTab(node, false);
-                    } else {
-                      setElementCanTab(node, true);
-                    }
-                  }
-                  return;
-                }
-              }
-              event.continuePropagation();
-              return;
-            }
-            // Using modifier keys with keyboard arrow events should be no-ops
-            // unless an explicit allowModifiers flag is set on the FocusGroup.
-            if (hasModifierKey(event)) {
-              const allowModifiers = getGroupProps(currentItem).allowModifiers;
-              if (!allowModifiers) {
-                event.continuePropagation();
-                return;
-              }
-            }
-            switch (key) {
-              case 'ArrowUp': {
-                if (portrait) {
-                  const previousGroupItem = getPreviousGroupItem(
-                    group,
-                    currentItem,
-                  );
-                  if (previousGroupItem) {
-                    focusGroupItem(scopeQuery, previousGroupItem, event);
-                    return;
-                  }
-                }
-                break;
-              }
-              case 'ArrowDown': {
-                if (portrait) {
-                  const nextGroupItem = getNextGroupItem(group, currentItem);
-                  if (nextGroupItem) {
-                    focusGroupItem(scopeQuery, nextGroupItem, event);
-                    return;
-                  }
-                }
-                break;
-              }
-              case 'ArrowLeft': {
-                if (!portrait) {
-                  const previousGroupItem = getPreviousGroupItem(
-                    group,
-                    currentItem,
-                  );
-                  if (previousGroupItem) {
-                    focusGroupItem(scopeQuery, previousGroupItem, event);
-                    return;
-                  }
-                }
-                break;
-              }
-              case 'ArrowRight': {
-                if (!portrait) {
-                  const nextGroupItem = getNextGroupItem(group, currentItem);
-                  if (nextGroupItem) {
-                    focusGroupItem(scopeQuery, nextGroupItem, event);
-                    return;
-                  }
-                }
-                break;
-              }
-            }
-          }
-        }
-        if (onKeyDown) {
-          onKeyDown(event);
-        }
-        event.continuePropagation();
-      },
-    });
-    return (
-      <TableScope
-        DEPRECATED_flareListeners={keyboard}
-        ref={scopeRef}
-        type="item">
-        {children}
-      </TableScope>
-    );
-  }
-
-  return [Group, Item];
-}
diff --git a/packages/react-interactions/accessibility/src/FocusManager.js b/packages/react-interactions/accessibility/src/FocusManager.js
deleted file mode 100644
index 1fc4fd37e036..000000000000
--- a/packages/react-interactions/accessibility/src/FocusManager.js
+++ /dev/null
@@ -1,127 +0,0 @@
-/**
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- *
- * @flow
- */
-
-import type {ReactScopeMethods} from 'shared/ReactTypes';
-import type {KeyboardEvent} from 'react-interactions/events/keyboard';
-
-import getTabbableNodes from './shared/getTabbableNodes';
-
-export function focusFirst(
-  scopeQuery: (type: string | Object, props: Object) => boolean,
-  scope: ReactScopeMethods,
-): void {
-  const firstNode = scope.DO_NOT_USE_queryFirstNode(scopeQuery);
-  if (firstNode) {
-    focusElem(firstNode);
-  }
-}
-
-function focusElem(elem: null | HTMLElement): void {
-  if (elem !== null) {
-    elem.focus();
-  }
-}
-
-export function focusNext(
-  scopeQuery: (type: string | Object, props: Object) => boolean,
-  scope: ReactScopeMethods,
-  event?: KeyboardEvent,
-  contain?: boolean,
-): void {
-  const [
-    tabbableNodes,
-    firstTabbableElem,
-    lastTabbableElem,
-    currentIndex,
-    focusedElement,
-  ] = getTabbableNodes(scopeQuery, scope);
-
-  if (focusedElement === null) {
-    if (event) {
-      event.continuePropagation();
-    }
-  } else if (focusedElement === lastTabbableElem) {
-    if (contain === true) {
-      focusElem(firstTabbableElem);
-      if (event) {
-        event.preventDefault();
-      }
-    } else if (event) {
-      event.continuePropagation();
-    }
-  } else if (tabbableNodes) {
-    focusElem(tabbableNodes[currentIndex + 1]);
-    if (event) {
-      event.preventDefault();
-    }
-  }
-}
-
-export function focusPrevious(
-  scopeQuery: (type: string | Object, props: Object) => boolean,
-  scope: ReactScopeMethods,
-  event?: KeyboardEvent,
-  contain?: boolean,
-): void {
-  const [
-    tabbableNodes,
-    firstTabbableElem,
-    lastTabbableElem,
-    currentIndex,
-    focusedElement,
-  ] = getTabbableNodes(scopeQuery, scope);
-
-  if (focusedElement === null) {
-    if (event) {
-      event.continuePropagation();
-    }
-  } else if (focusedElement === firstTabbableElem) {
-    if (contain === true) {
-      focusElem(lastTabbableElem);
-      if (event) {
-        event.preventDefault();
-      }
-    } else if (event) {
-      event.continuePropagation();
-    }
-  } else if (tabbableNodes) {
-    focusElem(tabbableNodes[currentIndex - 1]);
-    if (event) {
-      event.preventDefault();
-    }
-  }
-}
-
-export function getNextScope(
-  scope: ReactScopeMethods,
-): null | ReactScopeMethods {
-  const allScopes = scope.DO_NOT_USE_getChildrenFromRoot();
-  if (allScopes === null) {
-    return null;
-  }
-  const currentScopeIndex = allScopes.indexOf(scope);
-  if (currentScopeIndex === -1 || currentScopeIndex === allScopes.length - 1) {
-    return null;
-  }
-  return allScopes[currentScopeIndex + 1];
-}
-
-export function getPreviousScope(
-  scope: ReactScopeMethods,
-): null | ReactScopeMethods {
-  const allScopes = scope.DO_NOT_USE_getChildrenFromRoot();
-  if (allScopes === null) {
-    return null;
-  }
-  const currentScopeIndex = allScopes.indexOf(scope);
-  if (currentScopeIndex <= 0) {
-    return null;
-  }
-  return allScopes[currentScopeIndex - 1];
-}
diff --git a/packages/react-interactions/accessibility/src/FocusTable.js b/packages/react-interactions/accessibility/src/FocusTable.js
deleted file mode 100644
index bd05855bc752..000000000000
--- a/packages/react-interactions/accessibility/src/FocusTable.js
+++ /dev/null
@@ -1,360 +0,0 @@
-/**
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- *
- * @flow
- */
-
-import type {ReactScopeMethods} from 'shared/ReactTypes';
-import type {KeyboardEvent} from 'react-interactions/events/keyboard';
-
-import React from 'react';
-import {useKeyboard} from 'react-interactions/events/keyboard';
-import setElementCanTab from './shared/setElementCanTab';
-
-type FocusCellProps = {
-  children?: React.Node,
-  onKeyDown?: KeyboardEvent => void,
-  colSpan?: number,
-  ...
-};
-
-type FocusRowProps = {children: React.Node, ...};
-
-type FocusTableProps = {|
-  children: React.Node,
-  onKeyboardOut?: (
-    direction: 'left' | 'right' | 'up' | 'down',
-    event: KeyboardEvent,
-  ) => void,
-  wrapX?: boolean,
-  wrapY?: boolean,
-  tabScopeQuery?: (type: string | Object, props: Object) => boolean,
-  allowModifiers?: boolean,
-|};
-
-const {useRef} = React;
-
-function focusScope(
-  scopeQuery: (type: string | Object, props: Object) => boolean,
-  cell: ReactScopeMethods,
-  event?: KeyboardEvent,
-): void {
-  const firstScopedNode = cell.DO_NOT_USE_queryFirstNode(scopeQuery);
-  if (firstScopedNode !== null) {
-    firstScopedNode.focus();
-    if (event) {
-      event.preventDefault();
-    }
-  }
-}
-
-// This takes into account colSpan
-function focusCellByColumnIndex(
-  scopeQuery: (type: string | Object, props: Object) => boolean,
-  row: ReactScopeMethods,
-  columnIndex: number,
-  event?: KeyboardEvent,
-): void {
-  const cells = row.DO_NOT_USE_getChildren();
-  if (cells !== null) {
-    let colSize = 0;
-    for (let i = 0; i < cells.length; i++) {
-      const cell = cells[i];
-      if (cell) {
-        colSize += cell.DO_NOT_USE_getProps().colSpan || 1;
-        if (colSize > columnIndex) {
-          focusScope(scopeQuery, cell, event);
-          return;
-        }
-      }
-    }
-  }
-}
-
-function getCellIndexes(
-  cells: Array<ReactScopeMethods>,
-  currentCell: ReactScopeMethods,
-): [number, number] {
-  let totalColSpan = 0;
-  for (let i = 0; i < cells.length; i++) {
-    const cell = cells[i];
-    if (cell === currentCell) {
-      return [i, i + totalColSpan];
-    }
-    const colSpan = cell.DO_NOT_USE_getProps().colSpan;
-    if (colSpan) {
-      totalColSpan += colSpan - 1;
-    }
-  }
-  return [-1, -1];
-}
-
-function getRowCells(currentCell: ReactScopeMethods) {
-  const row = currentCell.DO_NOT_USE_getParent();
-  if (row !== null && row.DO_NOT_USE_getProps().type === 'row') {
-    const cells = row.DO_NOT_USE_getChildren();
-    if (cells !== null) {
-      const [rowIndex, rowIndexWithColSpan] = getCellIndexes(
-        cells,
-        currentCell,
-      );
-      return [cells, rowIndex, rowIndexWithColSpan];
-    }
-  }
-  return [null, -1, -1];
-}
-
-function getRows(currentCell: ReactScopeMethods) {
-  const row = currentCell.DO_NOT_USE_getParent();
-  if (row !== null && row.DO_NOT_USE_getProps().type === 'row') {
-    const table = row.DO_NOT_USE_getParent();
-    if (table !== null && table.DO_NOT_USE_getProps().type === 'table') {
-      const rows = table.DO_NOT_USE_getChildren();
-      if (rows !== null) {
-        const columnIndex = rows.indexOf(row);
-        return [rows, columnIndex];
-      }
-    }
-  }
-  return [null, -1, -1];
-}
-
-function triggerNavigateOut(
-  currentCell: ReactScopeMethods,
-  direction: 'left' | 'right' | 'up' | 'down',
-  event,
-): void {
-  const row = currentCell.DO_NOT_USE_getParent();
-  if (row !== null && row.DO_NOT_USE_getProps().type === 'row') {
-    const table = row.DO_NOT_USE_getParent();
-    if (table !== null) {
-      const props = table.DO_NOT_USE_getProps();
-      const onKeyboardOut = props.onKeyboardOut;
-      if (props.type === 'table' && typeof onKeyboardOut === 'function') {
-        onKeyboardOut(direction, event);
-        return;
-      }
-    }
-  }
-  event.continuePropagation();
-}
-
-function getTableProps(currentCell: ReactScopeMethods): Object {
-  const row = currentCell.DO_NOT_USE_getParent();
-  if (row !== null && row.DO_NOT_USE_getProps().type === 'row') {
-    const table = row.DO_NOT_USE_getParent();
-    if (table !== null) {
-      return table.DO_NOT_USE_getProps();
-    }
-  }
-  return {};
-}
-
-function hasModifierKey(event: KeyboardEvent): boolean {
-  const {altKey, ctrlKey, metaKey, shiftKey} = event;
-  return (
-    altKey === true || ctrlKey === true || metaKey === true || shiftKey === true
-  );
-}
-
-export function createFocusTable(
-  scopeQuery: (type: string | Object, props: Object) => boolean,
-): [
-  (FocusTableProps) => React.Node,
-  (FocusRowProps) => React.Node,
-  (FocusCellProps) => React.Node,
-] {
-  const TableScope = React.unstable_createScope();
-
-  function Table({
-    children,
-    onKeyboardOut,
-    wrapX,
-    wrapY,
-    tabScopeQuery,
-    allowModifiers,
-  }: FocusTableProps): React.Node {
-    return (
-      <TableScope
-        type="table"
-        onKeyboardOut={onKeyboardOut}
-        wrapX={wrapX}
-        wrapY={wrapY}
-        tabScopeQuery={tabScopeQuery}
-        allowModifiers={allowModifiers}>
-        {children}
-      </TableScope>
-    );
-  }
-
-  function Row({children}: FocusRowProps): React.Node {
-    return <TableScope type="row">{children}</TableScope>;
-  }
-
-  function Cell({children, onKeyDown, colSpan}: FocusCellProps): React.Node {
-    const scopeRef = useRef(null);
-    const keyboard = useKeyboard({
-      onKeyDown(event: KeyboardEvent): void {
-        const currentCell = scopeRef.current;
-        if (currentCell === null) {
-          event.continuePropagation();
-          return;
-        }
-        const key = event.key;
-        if (key === 'Tab') {
-          const tabScopeQuery = getTableProps(currentCell).tabScopeQuery;
-          if (tabScopeQuery) {
-            const rowScope = currentCell.DO_NOT_USE_getParent();
-            if (rowScope) {
-              const tableScope = rowScope.DO_NOT_USE_getParent();
-              if (tableScope) {
-                const activeNode = document.activeElement;
-                const nodes = tableScope.DO_NOT_USE_queryAllNodes(
-                  tabScopeQuery,
-                );
-                for (let i = 0; i < nodes.length; i++) {
-                  const node = nodes[i];
-                  if (node !== activeNode) {
-                    setElementCanTab(node, false);
-                  } else {
-                    setElementCanTab(node, true);
-                  }
-                }
-                return;
-              }
-            }
-          }
-          event.continuePropagation();
-          return;
-        }
-        // Using modifier keys with keyboard arrow events should be no-ops
-        // unless an explicit allowModifiers flag is set on the FocusTable.
-        if (hasModifierKey(event)) {
-          const allowModifiers = getTableProps(currentCell).allowModifiers;
-          if (!allowModifiers) {
-            event.continuePropagation();
-            return;
-          }
-        }
-        switch (key) {
-          case 'ArrowUp': {
-            const [cells, , cellIndexWithColSpan] = getRowCells(currentCell);
-            if (cells !== null) {
-              const [rows, rowIndex] = getRows(currentCell);
-              if (rows !== null) {
-                if (rowIndex > 0) {
-                  const row = rows[rowIndex - 1];
-                  focusCellByColumnIndex(
-                    scopeQuery,
-                    row,
-                    cellIndexWithColSpan,
-                    event,
-                  );
-                } else if (rowIndex === 0) {
-                  const wrapY = getTableProps(currentCell).wrapY;
-                  if (wrapY) {
-                    const row = rows[rows.length - 1];
-                    focusCellByColumnIndex(
-                      scopeQuery,
-                      row,
-                      cellIndexWithColSpan,
-                      event,
-                    );
-                  } else {
-                    triggerNavigateOut(currentCell, 'up', event);
-                  }
-                }
-              }
-            }
-            return;
-          }
-          case 'ArrowDown': {
-            const [cells, , cellIndexWithColSpan] = getRowCells(currentCell);
-            if (cells !== null) {
-              const [rows, rowIndex] = getRows(currentCell);
-              if (rows !== null) {
-                if (rowIndex !== -1) {
-                  if (rowIndex === rows.length - 1) {
-                    const wrapY = getTableProps(currentCell).wrapY;
-                    if (wrapY) {
-                      const row = rows[0];
-                      focusCellByColumnIndex(
-                        scopeQuery,
-                        row,
-                        cellIndexWithColSpan,
-                        event,
-                      );
-                    } else {
-                      triggerNavigateOut(currentCell, 'down', event);
-                    }
-                  } else {
-                    const row = rows[rowIndex + 1];
-                    focusCellByColumnIndex(
-                      scopeQuery,
-                      row,
-                      cellIndexWithColSpan,
-                      event,
-                    );
-                  }
-                }
-              }
-            }
-            return;
-          }
-          case 'ArrowLeft': {
-            const [cells, rowIndex] = getRowCells(currentCell);
-            if (cells !== null) {
-              if (rowIndex > 0) {
-                focusScope(scopeQuery, cells[rowIndex - 1]);
-                event.preventDefault();
-              } else if (rowIndex === 0) {
-                const wrapX = getTableProps(currentCell).wrapX;
-                if (wrapX) {
-                  focusScope(scopeQuery, cells[cells.length - 1], event);
-                } else {
-                  triggerNavigateOut(currentCell, 'left', event);
-                }
-              }
-            }
-            return;
-          }
-          case 'ArrowRight': {
-            const [cells, rowIndex] = getRowCells(currentCell);
-            if (cells !== null) {
-              if (rowIndex !== -1) {
-                if (rowIndex === cells.length - 1) {
-                  const wrapX = getTableProps(currentCell).wrapX;
-                  if (wrapX) {
-                    focusScope(scopeQuery, cells[0], event);
-                  } else {
-                    triggerNavigateOut(currentCell, 'right', event);
-                  }
-                } else {
-                  focusScope(scopeQuery, cells[rowIndex + 1], event);
-                }
-              }
-            }
-            return;
-          }
-        }
-        if (onKeyDown) {
-          onKeyDown(event);
-        }
-      },
-    });
-    return (
-      <TableScope
-        DEPRECATED_flareListeners={keyboard}
-        ref={scopeRef}
-        type="cell"
-        colSpan={colSpan}>
-        {children}
-      </TableScope>
-    );
-  }
-
-  return [Table, Row, Cell];
-}
diff --git a/packages/react-interactions/accessibility/src/TabbableScopeQuery.js b/packages/react-interactions/accessibility/src/TabbableScopeQuery.js
deleted file mode 100644
index c6ab0d3e5446..000000000000
--- a/packages/react-interactions/accessibility/src/TabbableScopeQuery.js
+++ /dev/null
@@ -1,33 +0,0 @@
-/**
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- *
- * @flow
- */
-
-const tabbableScopeQuery = (type: string, props: Object): boolean => {
-  if (props.tabIndex === -1 || props.disabled) {
-    return false;
-  }
-  if (props.tabIndex === 0 || props.contentEditable === true) {
-    return true;
-  }
-  if (type === 'a' || type === 'area') {
-    return !!props.href && props.rel !== 'ignore';
-  }
-  if (type === 'input') {
-    return props.type !== 'hidden' && props.type !== 'file';
-  }
-  return (
-    type === 'button' ||
-    type === 'textarea' ||
-    type === 'object' ||
-    type === 'select' ||
-    type === 'iframe' ||
-    type === 'embed'
-  );
-};
-
-export default tabbableScopeQuery;
diff --git a/packages/react-interactions/accessibility/src/__tests__/FocusContain-test.internal.js b/packages/react-interactions/accessibility/src/__tests__/FocusContain-test.internal.js
deleted file mode 100644
index b37a8a11672d..000000000000
--- a/packages/react-interactions/accessibility/src/__tests__/FocusContain-test.internal.js
+++ /dev/null
@@ -1,238 +0,0 @@
-/**
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- *
- * @flow
- */
-
-import {createEventTarget} from 'dom-event-testing-library';
-
-let React;
-let ReactFeatureFlags;
-let FocusContain;
-let tabbableScopeQuery;
-
-function tabNext(target) {
-  target.keydown({key: 'Tab'});
-  target.keyup({key: 'Tab'});
-}
-
-function tabPrevious(target) {
-  target.keydown({key: 'Tab', shiftKey: true});
-  target.keyup({key: 'Tab', shiftKey: true});
-}
-
-describe('FocusContain', () => {
-  beforeEach(() => {
-    jest.resetModules();
-    ReactFeatureFlags = require('shared/ReactFeatureFlags');
-    ReactFeatureFlags.enableScopeAPI = true;
-    ReactFeatureFlags.enableDeprecatedFlareAPI = true;
-    FocusContain = require('../FocusContain').default;
-    tabbableScopeQuery = require('../TabbableScopeQuery').default;
-    React = require('react');
-  });
-
-  describe('ReactDOM', () => {
-    let ReactDOM;
-    let container;
-
-    beforeEach(() => {
-      ReactDOM = require('react-dom');
-      container = document.createElement('div');
-      document.body.appendChild(container);
-    });
-
-    afterEach(() => {
-      document.body.removeChild(container);
-      container = null;
-    });
-
-    it('handles tab operations by default', () => {
-      const inputRef = React.createRef();
-      const input2Ref = React.createRef();
-      const buttonRef = React.createRef();
-      const button2Ref = React.createRef();
-      const divRef = React.createRef();
-
-      const Test = () => (
-        <FocusContain scopeQuery={tabbableScopeQuery}>
-          <input ref={inputRef} />
-          <button ref={buttonRef} />
-          <div ref={divRef} tabIndex={0} />
-          <input ref={input2Ref} tabIndex={-1} />
-          <button ref={button2Ref} />
-        </FocusContain>
-      );
-
-      ReactDOM.render(<Test />, container);
-      expect(document.activeElement).toBe(inputRef.current);
-      tabNext(createEventTarget(document.activeElement));
-      expect(document.activeElement).toBe(buttonRef.current);
-      tabNext(createEventTarget(document.activeElement));
-      expect(document.activeElement).toBe(divRef.current);
-      tabNext(createEventTarget(document.activeElement));
-      expect(document.activeElement).toBe(button2Ref.current);
-      tabPrevious(createEventTarget(document.activeElement));
-      expect(document.activeElement).toBe(divRef.current);
-    });
-
-    it('handles focus containment', () => {
-      const inputRef = React.createRef();
-      const input2Ref = React.createRef();
-      const input3Ref = React.createRef();
-      const buttonRef = React.createRef();
-      const button2Ref = React.createRef();
-
-      const Test = () => (
-        <div>
-          <FocusContain scopeQuery={tabbableScopeQuery}>
-            <input ref={inputRef} tabIndex={-1} />
-            <button ref={buttonRef} id={1} />
-            <button ref={button2Ref} id={2} />
-            <input ref={input2Ref} tabIndex={-1} />
-          </FocusContain>
-          <input ref={input3Ref} />
-        </div>
-      );
-
-      ReactDOM.render(<Test />, container);
-      buttonRef.current.focus();
-      tabNext(createEventTarget(document.activeElement));
-      expect(document.activeElement).toBe(button2Ref.current);
-      tabNext(createEventTarget(document.activeElement));
-      expect(document.activeElement).toBe(buttonRef.current);
-      tabNext(createEventTarget(document.activeElement));
-      expect(document.activeElement).toBe(button2Ref.current);
-      tabPrevious(createEventTarget(document.activeElement));
-      expect(document.activeElement).toBe(buttonRef.current);
-      tabPrevious(createEventTarget(document.activeElement));
-      expect(document.activeElement).toBe(button2Ref.current);
-      // Focus should be restored to the contained area
-      const rAF = window.requestAnimationFrame;
-      window.requestAnimationFrame = x => setTimeout(x);
-      input3Ref.current.focus();
-      jest.advanceTimersByTime(1);
-      window.requestAnimationFrame = rAF;
-      expect(document.activeElement).toBe(button2Ref.current);
-    });
-
-    it('works with a disabled nested FocusContain', () => {
-      const inputRef = React.createRef();
-      const input2Ref = React.createRef();
-      const buttonRef = React.createRef();
-      const button2Ref = React.createRef();
-      const button3Ref = React.createRef();
-      const button4Ref = React.createRef();
-
-      const Test = () => (
-        <FocusContain scopeQuery={tabbableScopeQuery}>
-          <input ref={inputRef} tabIndex={-1} />
-          <button ref={buttonRef} id={1} />
-          <FocusContain scopeQuery={tabbableScopeQuery} disabled={true}>
-            <button ref={button2Ref} id={2} />
-            <button ref={button3Ref} id={3} />
-          </FocusContain>
-          <input ref={input2Ref} tabIndex={-1} />
-          <button ref={button4Ref} id={4} />
-        </FocusContain>
-      );
-
-      ReactDOM.render(<Test />, container);
-      expect(document.activeElement).toBe(buttonRef.current);
-      tabNext(createEventTarget(document.activeElement));
-      expect(document.activeElement).toBe(button2Ref.current);
-      tabNext(createEventTarget(document.activeElement));
-      expect(document.activeElement).toBe(button3Ref.current);
-      tabNext(createEventTarget(document.activeElement));
-      expect(document.activeElement).toBe(button4Ref.current);
-      tabPrevious(createEventTarget(document.activeElement));
-      expect(document.activeElement).toBe(button3Ref.current);
-      tabPrevious(createEventTarget(document.activeElement));
-      expect(document.activeElement).toBe(button2Ref.current);
-    });
-
-    it('works with enabled nested FocusContain', () => {
-      const inputRef = React.createRef();
-      const input2Ref = React.createRef();
-      const buttonRef = React.createRef();
-      const button2Ref = React.createRef();
-      const button3Ref = React.createRef();
-      const button4Ref = React.createRef();
-
-      const Test = () => (
-        <FocusContain scopeQuery={tabbableScopeQuery}>
-          <input ref={inputRef} tabIndex={-1} />
-          <button ref={buttonRef} id={1} />
-          <FocusContain scopeQuery={tabbableScopeQuery} disabled={false}>
-            <button ref={button2Ref} id={2} />
-            <button ref={button3Ref} id={3} />
-          </FocusContain>
-          <input ref={input2Ref} tabIndex={-1} />
-          <button ref={button4Ref} id={4} />
-        </FocusContain>
-      );
-
-      ReactDOM.render(<Test />, container);
-      expect(document.activeElement).toBe(button2Ref.current);
-      tabNext(createEventTarget(document.activeElement));
-      expect(document.activeElement).toBe(button3Ref.current);
-      tabNext(createEventTarget(document.activeElement));
-      expect(document.activeElement).toBe(button2Ref.current);
-      tabPrevious(createEventTarget(document.activeElement));
-      expect(document.activeElement).toBe(button3Ref.current);
-      tabPrevious(createEventTarget(document.activeElement));
-      expect(document.activeElement).toBe(button2Ref.current);
-    });
-
-    it('should work as expected with suspense fallbacks', () => {
-      const buttonRef = React.createRef();
-      const button2Ref = React.createRef();
-      const button3Ref = React.createRef();
-      const button4Ref = React.createRef();
-      const button5Ref = React.createRef();
-
-      function SuspendedComponent() {
-        throw new Promise(() => {
-          // Never resolve
-        });
-      }
-
-      function Component() {
-        return (
-          <React.Fragment>
-            <button ref={button5Ref} id={5} />
-            <SuspendedComponent />
-          </React.Fragment>
-        );
-      }
-
-      const Test = () => (
-        <FocusContain scopeQuery={tabbableScopeQuery}>
-          <button ref={buttonRef} id={1} />
-          <button ref={button2Ref} id={2} />
-          <React.Suspense fallback={<button ref={button3Ref} id={3} />}>
-            <Component />
-          </React.Suspense>
-          <button ref={button4Ref} id={4} />
-        </FocusContain>
-      );
-
-      ReactDOM.render(<Test />, container);
-      buttonRef.current.focus();
-      expect(document.activeElement).toBe(buttonRef.current);
-      tabNext(createEventTarget(document.activeElement));
-      expect(document.activeElement).toBe(button2Ref.current);
-      tabNext(createEventTarget(document.activeElement));
-      expect(document.activeElement).toBe(button3Ref.current);
-      tabNext(createEventTarget(document.activeElement));
-      expect(document.activeElement).toBe(button4Ref.current);
-      tabPrevious(createEventTarget(document.activeElement));
-      expect(document.activeElement).toBe(button3Ref.current);
-      tabPrevious(createEventTarget(document.activeElement));
-      expect(document.activeElement).toBe(button2Ref.current);
-    });
-  });
-});
diff --git a/packages/react-interactions/accessibility/src/__tests__/FocusGroup-test.internal.js b/packages/react-interactions/accessibility/src/__tests__/FocusGroup-test.internal.js
deleted file mode 100644
index f70f36009eb5..000000000000
--- a/packages/react-interactions/accessibility/src/__tests__/FocusGroup-test.internal.js
+++ /dev/null
@@ -1,256 +0,0 @@
-/**
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- *
- * @flow
- */
-
-import {createEventTarget} from 'dom-event-testing-library';
-import {emulateBrowserTab} from '../shared/emulateBrowserTab';
-
-let React;
-let ReactFeatureFlags;
-let createFocusGroup;
-let tabbableScopeQuery;
-
-describe('FocusGroup', () => {
-  beforeEach(() => {
-    jest.resetModules();
-    ReactFeatureFlags = require('shared/ReactFeatureFlags');
-    ReactFeatureFlags.enableScopeAPI = true;
-    ReactFeatureFlags.enableDeprecatedFlareAPI = true;
-    createFocusGroup = require('../FocusGroup').createFocusGroup;
-    tabbableScopeQuery = require('../TabbableScopeQuery').default;
-    React = require('react');
-  });
-
-  describe('ReactDOM', () => {
-    let ReactDOM;
-    let container;
-
-    beforeEach(() => {
-      ReactDOM = require('react-dom');
-      container = document.createElement('div');
-      document.body.appendChild(container);
-    });
-
-    afterEach(() => {
-      document.body.removeChild(container);
-      container = null;
-    });
-
-    function createFocusGroupComponent() {
-      const [FocusGroup, FocusItem] = createFocusGroup(tabbableScopeQuery);
-
-      return ({portrait, wrap, allowModifiers}) => (
-        <FocusGroup
-          portrait={portrait}
-          wrap={wrap}
-          allowModifiers={allowModifiers}>
-          <ul>
-            <FocusItem>
-              <li tabIndex={0}>Item 1</li>
-            </FocusItem>
-            <FocusItem>
-              <li tabIndex={0}>Item 2</li>
-            </FocusItem>
-            <FocusItem>
-              <li tabIndex={0}>Item 3</li>
-            </FocusItem>
-          </ul>
-        </FocusGroup>
-      );
-    }
-
-    it('handles keyboard arrow operations (portrait)', () => {
-      const Test = createFocusGroupComponent();
-
-      ReactDOM.render(<Test portrait={true} />, container);
-      const groupItems = document.querySelectorAll('li');
-      const firstGroupItem = createEventTarget(groupItems[0]);
-      firstGroupItem.focus();
-      firstGroupItem.keydown({
-        key: 'ArrowDown',
-      });
-      expect(document.activeElement.textContent).toBe('Item 2');
-
-      const secondGroupItem = createEventTarget(document.activeElement);
-      secondGroupItem.keydown({
-        key: 'ArrowDown',
-      });
-      expect(document.activeElement.textContent).toBe('Item 3');
-
-      const thirdGroupItem = createEventTarget(document.activeElement);
-      thirdGroupItem.keydown({
-        key: 'ArrowDown',
-      });
-      expect(document.activeElement.textContent).toBe('Item 3');
-      thirdGroupItem.keydown({
-        key: 'ArrowRight',
-      });
-      expect(document.activeElement.textContent).toBe('Item 3');
-      thirdGroupItem.keydown({
-        key: 'ArrowLeft',
-      });
-      expect(document.activeElement.textContent).toBe('Item 3');
-      // Should be a no-op due to modifier
-      thirdGroupItem.keydown({
-        key: 'ArrowUp',
-        altKey: true,
-      });
-      expect(document.activeElement.textContent).toBe('Item 3');
-    });
-
-    it('handles keyboard arrow operations (landscape)', () => {
-      const Test = createFocusGroupComponent();
-
-      ReactDOM.render(<Test portrait={false} />, container);
-      const GroupItems = document.querySelectorAll('li');
-      const firstGroupItem = createEventTarget(GroupItems[0]);
-      firstGroupItem.focus();
-      firstGroupItem.keydown({
-        key: 'ArrowRight',
-      });
-      expect(document.activeElement.textContent).toBe('Item 2');
-
-      const secondGroupItem = createEventTarget(document.activeElement);
-      secondGroupItem.keydown({
-        key: 'ArrowRight',
-      });
-      expect(document.activeElement.textContent).toBe('Item 3');
-
-      const thirdGroupItem = createEventTarget(document.activeElement);
-      thirdGroupItem.keydown({
-        key: 'ArrowRight',
-      });
-      expect(document.activeElement.textContent).toBe('Item 3');
-      thirdGroupItem.keydown({
-        key: 'ArrowUp',
-      });
-      expect(document.activeElement.textContent).toBe('Item 3');
-      thirdGroupItem.keydown({
-        key: 'ArrowDown',
-      });
-      expect(document.activeElement.textContent).toBe('Item 3');
-    });
-
-    it('handles keyboard arrow operations (portrait) with wrapping enabled', () => {
-      const Test = createFocusGroupComponent();
-
-      ReactDOM.render(<Test portrait={true} wrap={true} />, container);
-      const GroupItems = document.querySelectorAll('li');
-      let firstGroupItem = createEventTarget(GroupItems[0]);
-      firstGroupItem.focus();
-      firstGroupItem.keydown({
-        key: 'ArrowDown',
-      });
-      expect(document.activeElement.textContent).toBe('Item 2');
-
-      const secondGroupItem = createEventTarget(document.activeElement);
-      secondGroupItem.keydown({
-        key: 'ArrowDown',
-      });
-      expect(document.activeElement.textContent).toBe('Item 3');
-
-      const thirdGroupItem = createEventTarget(document.activeElement);
-      thirdGroupItem.keydown({
-        key: 'ArrowDown',
-      });
-      expect(document.activeElement.textContent).toBe('Item 1');
-
-      firstGroupItem = createEventTarget(document.activeElement);
-      firstGroupItem.keydown({
-        key: 'ArrowUp',
-      });
-      expect(document.activeElement.textContent).toBe('Item 3');
-    });
-
-    it('handles keyboard arrow operations (portrait) with allowModifiers', () => {
-      const Test = createFocusGroupComponent();
-
-      ReactDOM.render(
-        <Test portrait={true} allowModifiers={true} />,
-        container,
-      );
-      const GroupItems = document.querySelectorAll('li');
-      let firstGroupItem = createEventTarget(GroupItems[0]);
-      firstGroupItem.focus();
-      firstGroupItem.keydown({
-        key: 'ArrowDown',
-        altKey: true,
-      });
-      expect(document.activeElement.textContent).toBe('Item 2');
-    });
-
-    it('handles keyboard arrow operations mixed with tabbing', () => {
-      const [FocusGroup, FocusItem] = createFocusGroup(tabbableScopeQuery);
-      const beforeRef = React.createRef();
-      const afterRef = React.createRef();
-
-      function Test() {
-        return (
-          <>
-            <input placeholder="Before" ref={beforeRef} />
-            <FocusGroup tabScopeQuery={tabbableScopeQuery} portrait={true}>
-              <ul>
-                <FocusItem>
-                  <li>
-                    <input placeholder="A" />
-                  </li>
-                </FocusItem>
-                <FocusItem>
-                  <li>
-                    <input placeholder="B" />
-                  </li>
-                </FocusItem>
-                <FocusItem>
-                  <li>
-                    <input placeholder="C" />
-                  </li>
-                </FocusItem>
-                <FocusItem>
-                  <li>
-                    <input placeholder="D" />
-                  </li>
-                </FocusItem>
-                <FocusItem>
-                  <li>
-                    <input placeholder="E" />
-                  </li>
-                </FocusItem>
-                <FocusItem>
-                  <li>
-                    <input placeholder="F" />
-                  </li>
-                </FocusItem>
-              </ul>
-            </FocusGroup>
-            <input placeholder="After" ref={afterRef} />
-          </>
-        );
-      }
-
-      ReactDOM.render(<Test />, container);
-      beforeRef.current.focus();
-
-      expect(document.activeElement.placeholder).toBe('Before');
-      emulateBrowserTab();
-      expect(document.activeElement.placeholder).toBe('A');
-      emulateBrowserTab();
-      expect(document.activeElement.placeholder).toBe('After');
-      emulateBrowserTab(true);
-      expect(document.activeElement.placeholder).toBe('A');
-      const a = createEventTarget(document.activeElement);
-      a.keydown({
-        key: 'ArrowDown',
-      });
-      expect(document.activeElement.placeholder).toBe('B');
-      emulateBrowserTab();
-      expect(document.activeElement.placeholder).toBe('After');
-      emulateBrowserTab(true);
-      expect(document.activeElement.placeholder).toBe('B');
-    });
-  });
-});
diff --git a/packages/react-interactions/accessibility/src/__tests__/FocusManager-test.internal.js b/packages/react-interactions/accessibility/src/__tests__/FocusManager-test.internal.js
deleted file mode 100644
index 445c421c4df7..000000000000
--- a/packages/react-interactions/accessibility/src/__tests__/FocusManager-test.internal.js
+++ /dev/null
@@ -1,86 +0,0 @@
-/**
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- *
- * @flow
- */
-
-let React;
-let ReactFeatureFlags;
-let FocusManager;
-let tabbableScopeQuery;
-
-describe('FocusManager', () => {
-  beforeEach(() => {
-    jest.resetModules();
-    ReactFeatureFlags = require('shared/ReactFeatureFlags');
-    ReactFeatureFlags.enableScopeAPI = true;
-    ReactFeatureFlags.enableDeprecatedFlareAPI = true;
-    FocusManager = require('../FocusManager');
-    tabbableScopeQuery = require('../TabbableScopeQuery').default;
-    React = require('react');
-  });
-
-  describe('ReactDOM', () => {
-    let ReactDOM;
-    let container;
-
-    beforeEach(() => {
-      ReactDOM = require('react-dom');
-      container = document.createElement('div');
-      document.body.appendChild(container);
-    });
-
-    afterEach(() => {
-      document.body.removeChild(container);
-      container = null;
-    });
-
-    it('allows for imperative tab focus control with a scope', () => {
-      const firstFocusControllerRef = React.createRef();
-      const secondFocusControllerRef = React.createRef();
-      const buttonRef = React.createRef();
-      const button2Ref = React.createRef();
-      const divRef = React.createRef();
-      const TestScope = React.unstable_createScope();
-
-      const Test = () => (
-        <div>
-          <TestScope ref={firstFocusControllerRef}>
-            <input tabIndex={-1} />
-            <button ref={buttonRef} />
-            <button ref={button2Ref} />
-            <input tabIndex={-1} />
-          </TestScope>
-          <TestScope ref={secondFocusControllerRef}>
-            <input tabIndex={-1} />
-            <div ref={divRef} tabIndex={0} />
-          </TestScope>
-        </div>
-      );
-
-      ReactDOM.render(<Test />, container);
-      const firstFocusController = firstFocusControllerRef.current;
-      const secondFocusController = secondFocusControllerRef.current;
-
-      FocusManager.focusFirst(tabbableScopeQuery, firstFocusController);
-      expect(document.activeElement).toBe(buttonRef.current);
-      FocusManager.focusNext(tabbableScopeQuery, firstFocusController);
-      expect(document.activeElement).toBe(button2Ref.current);
-      FocusManager.focusPrevious(tabbableScopeQuery, firstFocusController);
-      expect(document.activeElement).toBe(buttonRef.current);
-
-      const nextController = FocusManager.getNextScope(firstFocusController);
-      expect(nextController).toBe(secondFocusController);
-      FocusManager.focusFirst(tabbableScopeQuery, nextController);
-      expect(document.activeElement).toBe(divRef.current);
-
-      const previousController = FocusManager.getPreviousScope(nextController);
-      expect(previousController).toBe(firstFocusController);
-      FocusManager.focusFirst(tabbableScopeQuery, previousController);
-      expect(document.activeElement).toBe(buttonRef.current);
-    });
-  });
-});
diff --git a/packages/react-interactions/accessibility/src/__tests__/FocusTable-test.internal.js b/packages/react-interactions/accessibility/src/__tests__/FocusTable-test.internal.js
deleted file mode 100644
index 7a0167ead78f..000000000000
--- a/packages/react-interactions/accessibility/src/__tests__/FocusTable-test.internal.js
+++ /dev/null
@@ -1,573 +0,0 @@
-/**
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- *
- * @flow
- */
-
-import {createEventTarget} from 'dom-event-testing-library';
-import {emulateBrowserTab} from '../shared/emulateBrowserTab';
-
-let React;
-let ReactFeatureFlags;
-let createFocusTable;
-let tabbableScopeQuery;
-
-describe('FocusTable', () => {
-  beforeEach(() => {
-    jest.resetModules();
-    ReactFeatureFlags = require('shared/ReactFeatureFlags');
-    ReactFeatureFlags.enableScopeAPI = true;
-    ReactFeatureFlags.enableDeprecatedFlareAPI = true;
-    createFocusTable = require('../FocusTable').createFocusTable;
-    tabbableScopeQuery = require('../TabbableScopeQuery').default;
-    React = require('react');
-  });
-
-  describe('ReactDOM', () => {
-    let ReactDOM;
-    let container;
-
-    beforeEach(() => {
-      ReactDOM = require('react-dom');
-      container = document.createElement('div');
-      document.body.appendChild(container);
-    });
-
-    afterEach(() => {
-      document.body.removeChild(container);
-      container = null;
-    });
-
-    function createFocusTableComponent() {
-      const [FocusTable, FocusTableRow, FocusTableCell] = createFocusTable(
-        tabbableScopeQuery,
-      );
-
-      return ({onKeyboardOut, wrapX, wrapY, allowModifiers}) => (
-        <FocusTable
-          onKeyboardOut={onKeyboardOut}
-          wrapX={wrapX}
-          wrapY={wrapY}
-          allowModifiers={allowModifiers}>
-          <table>
-            <tbody>
-              <FocusTableRow>
-                <tr>
-                  <FocusTableCell>
-                    <td>
-                      <button>A1</button>
-                    </td>
-                  </FocusTableCell>
-                  <FocusTableCell>
-                    <td>
-                      <button>A2</button>
-                    </td>
-                  </FocusTableCell>
-                  <FocusTableCell>
-                    <td>
-                      <button>A3</button>
-                    </td>
-                  </FocusTableCell>
-                </tr>
-              </FocusTableRow>
-              <FocusTableRow>
-                <tr>
-                  <FocusTableCell>
-                    <td>
-                      <button>B1</button>
-                    </td>
-                  </FocusTableCell>
-                  <FocusTableCell>
-                    <td>
-                      <button>B2</button>
-                    </td>
-                  </FocusTableCell>
-                  <FocusTableCell>
-                    <td>
-                      <button>B3</button>
-                    </td>
-                  </FocusTableCell>
-                </tr>
-              </FocusTableRow>
-              <FocusTableRow>
-                <tr>
-                  <FocusTableCell>
-                    <td>
-                      <button>C1</button>
-                    </td>
-                  </FocusTableCell>
-                  <FocusTableCell>
-                    <td>
-                      <button>C2</button>
-                    </td>
-                  </FocusTableCell>
-                  <FocusTableCell>
-                    <td>
-                      <button>C3</button>
-                    </td>
-                  </FocusTableCell>
-                </tr>
-              </FocusTableRow>
-            </tbody>
-          </table>
-        </FocusTable>
-      );
-    }
-
-    it('handles keyboard arrow operations with allowModifiers', () => {
-      const Test = createFocusTableComponent();
-
-      ReactDOM.render(<Test allowModifiers={true} />, container);
-      const buttons = document.querySelectorAll('button');
-      const a1 = createEventTarget(buttons[0]);
-      a1.focus();
-      a1.keydown({
-        key: 'ArrowRight',
-        altKey: true,
-      });
-      expect(document.activeElement.textContent).toBe('A2');
-    });
-
-    it('handles keyboard arrow operations', () => {
-      const Test = createFocusTableComponent();
-
-      ReactDOM.render(<Test />, container);
-      const buttons = document.querySelectorAll('button');
-      const a1 = createEventTarget(buttons[0]);
-      a1.focus();
-      a1.keydown({
-        key: 'ArrowRight',
-      });
-      expect(document.activeElement.textContent).toBe('A2');
-
-      const a2 = createEventTarget(document.activeElement);
-      a2.keydown({
-        key: 'ArrowDown',
-      });
-      expect(document.activeElement.textContent).toBe('B2');
-
-      let b2 = createEventTarget(document.activeElement);
-      b2.keydown({
-        key: 'ArrowLeft',
-      });
-      expect(document.activeElement.textContent).toBe('B1');
-
-      const b1 = createEventTarget(document.activeElement);
-      b1.keydown({
-        key: 'ArrowDown',
-      });
-      expect(document.activeElement.textContent).toBe('C1');
-
-      const c1 = createEventTarget(document.activeElement);
-      c1.keydown({
-        key: 'ArrowDown',
-      });
-      expect(document.activeElement.textContent).toBe('C1');
-      c1.keydown({
-        key: 'ArrowUp',
-      });
-      expect(document.activeElement.textContent).toBe('B1');
-      // Should be a no-op due to modifier
-      b2 = createEventTarget(document.activeElement);
-      b2.keydown({
-        key: 'ArrowUp',
-        altKey: true,
-      });
-      b2 = createEventTarget(document.activeElement);
-      expect(document.activeElement.textContent).toBe('B1');
-    });
-
-    it('handles keyboard arrow operations between nested tables', () => {
-      const leftSidebarRef = React.createRef();
-      const [
-        MainFocusTable,
-        MainFocusTableRow,
-        MainFocusTableCell,
-      ] = createFocusTable(tabbableScopeQuery);
-      const SubFocusTable = createFocusTableComponent();
-      const onKeyboardOut = jest.fn((direction, event) =>
-        event.continuePropagation(),
-      );
-
-      function Test() {
-        return (
-          <MainFocusTable>
-            <MainFocusTableRow>
-              <div>
-                <h1>Title</h1>
-                <aside ref={leftSidebarRef}>
-                  <h2>Left Sidebar</h2>
-                  <MainFocusTableCell>
-                    <SubFocusTable onKeyboardOut={onKeyboardOut} />
-                  </MainFocusTableCell>
-                </aside>
-                <section>
-                  <h2>Content</h2>
-                  <MainFocusTableCell>
-                    <SubFocusTable onKeyboardOut={onKeyboardOut} />
-                  </MainFocusTableCell>
-                </section>
-                <aside>
-                  <h2>Right Sidebar</h2>
-                  <MainFocusTableCell>
-                    <SubFocusTable onKeyboardOut={onKeyboardOut} />
-                  </MainFocusTableCell>
-                </aside>
-              </div>
-            </MainFocusTableRow>
-          </MainFocusTable>
-        );
-      }
-
-      ReactDOM.render(<Test />, container);
-      const buttons = document.querySelectorAll('button');
-      let a1 = createEventTarget(buttons[0]);
-      a1.focus();
-      a1.keydown({
-        key: 'ArrowRight',
-      });
-      expect(document.activeElement.textContent).toBe('A2');
-
-      let a2 = createEventTarget(document.activeElement);
-      a2.keydown({
-        key: 'ArrowRight',
-      });
-      expect(document.activeElement.textContent).toBe('A3');
-
-      let a3 = createEventTarget(document.activeElement);
-      a3.keydown({
-        key: 'ArrowRight',
-      });
-      expect(onKeyboardOut).toHaveBeenCalledTimes(1);
-      expect(document.activeElement.textContent).toBe('A1');
-
-      a1 = createEventTarget(document.activeElement);
-      a1.keydown({
-        key: 'ArrowRight',
-      });
-      expect(document.activeElement.textContent).toBe('A2');
-
-      a2 = createEventTarget(document.activeElement);
-      a2.keydown({
-        key: 'ArrowRight',
-      });
-      expect(document.activeElement.textContent).toBe('A3');
-
-      a3 = createEventTarget(document.activeElement);
-      a3.keydown({
-        key: 'ArrowRight',
-      });
-      expect(onKeyboardOut).toHaveBeenCalledTimes(2);
-      expect(document.activeElement.textContent).toBe('A1');
-
-      a1 = createEventTarget(document.activeElement);
-      a1.keydown({
-        key: 'ArrowRight',
-      });
-      expect(document.activeElement.textContent).toBe('A2');
-
-      a2 = createEventTarget(document.activeElement);
-      a2.keydown({
-        key: 'ArrowRight',
-      });
-      expect(document.activeElement.textContent).toBe('A3');
-
-      a3 = createEventTarget(document.activeElement);
-      a3.keydown({
-        key: 'ArrowRight',
-      });
-      expect(document.activeElement.textContent).toBe('A3');
-    });
-
-    it('handles nested tables correctly', () => {
-      const customScopeQuery = (type, props) => {
-        return type === 'input';
-      };
-      const [FocusTable, FocusRow, FocusCell] = createFocusTable(
-        customScopeQuery,
-      );
-      const firstRef = React.createRef();
-
-      function Test() {
-        return (
-          <FocusTable>
-            <div>
-              <FocusRow>
-                <FocusCell>
-                  <FocusTable>
-                    <FocusRow>
-                      <FocusCell>
-                        <input
-                          placeholder="Nested A1"
-                          tabIndex={0}
-                          ref={firstRef}
-                        />
-                      </FocusCell>
-                      <FocusCell>
-                        <input placeholder="Nested B1" tabIndex={0} />
-                      </FocusCell>
-                    </FocusRow>
-                  </FocusTable>
-                </FocusCell>
-                <FocusCell>
-                  <input placeholder="B1" tabIndex={-1} />
-                </FocusCell>
-                <FocusCell>
-                  <input placeholder="C1" tabIndex={-1} />
-                </FocusCell>
-              </FocusRow>
-            </div>
-            <div>
-              <FocusRow>
-                <FocusCell>
-                  <input placeholder="A2" tabIndex={-1} />
-                </FocusCell>
-                <FocusCell>
-                  <input placeholder="B2" tabIndex={-1} />
-                </FocusCell>
-                <FocusCell>
-                  <input placeholder="C1" tabIndex={-1} />
-                </FocusCell>
-              </FocusRow>
-            </div>
-          </FocusTable>
-        );
-      }
-
-      ReactDOM.render(<Test />, container);
-      firstRef.current.focus();
-
-      const nestedA1 = createEventTarget(document.activeElement);
-      nestedA1.keydown({
-        key: 'ArrowRight',
-      });
-      expect(document.activeElement.placeholder).toBe('Nested B1');
-
-      const nestedB1 = createEventTarget(document.activeElement);
-      nestedB1.keydown({
-        key: 'ArrowRight',
-      });
-      expect(document.activeElement.placeholder).toBe('B1');
-    });
-
-    it('handles keyboard arrow operations with X wrapping enabled', () => {
-      const Test = createFocusTableComponent();
-
-      ReactDOM.render(<Test wrapX={true} />, container);
-      const buttons = document.querySelectorAll('button');
-      let a1 = createEventTarget(buttons[0]);
-      a1.focus();
-      a1.keydown({
-        key: 'ArrowRight',
-      });
-      expect(document.activeElement.textContent).toBe('A2');
-
-      const a2 = createEventTarget(document.activeElement);
-      a2.keydown({
-        key: 'ArrowRight',
-      });
-      expect(document.activeElement.textContent).toBe('A3');
-
-      const a3 = createEventTarget(document.activeElement);
-      a3.keydown({
-        key: 'ArrowRight',
-      });
-      expect(document.activeElement.textContent).toBe('A1');
-
-      a1 = createEventTarget(document.activeElement);
-      a1.keydown({
-        key: 'ArrowLeft',
-      });
-      expect(document.activeElement.textContent).toBe('A3');
-    });
-
-    it('handles keyboard arrow operations with Y wrapping enabled', () => {
-      const Test = createFocusTableComponent();
-
-      ReactDOM.render(<Test wrapY={true} />, container);
-      const buttons = document.querySelectorAll('button');
-      let a1 = createEventTarget(buttons[0]);
-      a1.focus();
-      a1.keydown({
-        key: 'ArrowDown',
-      });
-      expect(document.activeElement.textContent).toBe('B1');
-
-      const a2 = createEventTarget(document.activeElement);
-      a2.keydown({
-        key: 'ArrowDown',
-      });
-      expect(document.activeElement.textContent).toBe('C1');
-
-      const a3 = createEventTarget(document.activeElement);
-      a3.keydown({
-        key: 'ArrowDown',
-      });
-      expect(document.activeElement.textContent).toBe('A1');
-
-      a1 = createEventTarget(document.activeElement);
-      a1.keydown({
-        key: 'ArrowUp',
-      });
-      expect(document.activeElement.textContent).toBe('C1');
-    });
-
-    it('handles keyboard arrow operations mixed with tabbing', () => {
-      const [FocusTable, FocusRow, FocusCell] = createFocusTable(
-        tabbableScopeQuery,
-      );
-      const beforeRef = React.createRef();
-      const afterRef = React.createRef();
-
-      function Test() {
-        return (
-          <>
-            <input placeholder="Before" ref={beforeRef} />
-            <FocusTable tabScopeQuery={tabbableScopeQuery}>
-              <div>
-                <FocusRow>
-                  <FocusCell>
-                    <input placeholder="A1" />
-                  </FocusCell>
-                  <FocusCell>
-                    <input placeholder="B1" />
-                  </FocusCell>
-                  <FocusCell>
-                    <input placeholder="C1" />
-                  </FocusCell>
-                </FocusRow>
-              </div>
-              <div>
-                <FocusRow>
-                  <FocusCell>
-                    <input placeholder="A2" />
-                  </FocusCell>
-                  <FocusCell>
-                    <input placeholder="B2" />
-                  </FocusCell>
-                  <FocusCell>
-                    <input placeholder="C1" />
-                  </FocusCell>
-                </FocusRow>
-              </div>
-            </FocusTable>
-            <input placeholder="After" ref={afterRef} />
-          </>
-        );
-      }
-
-      ReactDOM.render(<Test />, container);
-      beforeRef.current.focus();
-
-      expect(document.activeElement.placeholder).toBe('Before');
-      emulateBrowserTab();
-      expect(document.activeElement.placeholder).toBe('A1');
-      emulateBrowserTab();
-      expect(document.activeElement.placeholder).toBe('After');
-      emulateBrowserTab(true);
-      expect(document.activeElement.placeholder).toBe('A1');
-      const a1 = createEventTarget(document.activeElement);
-      a1.keydown({
-        key: 'ArrowRight',
-      });
-      expect(document.activeElement.placeholder).toBe('B1');
-      emulateBrowserTab();
-      expect(document.activeElement.placeholder).toBe('After');
-      emulateBrowserTab(true);
-      expect(document.activeElement.placeholder).toBe('B1');
-    });
-
-    it('handles keyboard arrow operations with colSpan', () => {
-      const firstRef = React.createRef();
-      const [FocusTable, FocusRow, FocusCell] = createFocusTable(
-        tabbableScopeQuery,
-      );
-
-      function Test() {
-        return (
-          <>
-            <FocusTable tabScopeQuery={tabbableScopeQuery}>
-              <div>
-                <FocusRow>
-                  <FocusCell>
-                    <input placeholder="A1" ref={firstRef} />
-                  </FocusCell>
-                  <FocusCell colSpan={2}>
-                    <input placeholder="B1" />
-                  </FocusCell>
-                  <FocusCell>
-                    <input placeholder="C1" />
-                  </FocusCell>
-                </FocusRow>
-              </div>
-              <div>
-                <FocusRow>
-                  <FocusCell>
-                    <input placeholder="A2" />
-                  </FocusCell>
-                  <FocusCell>
-                    <input placeholder="B2" />
-                  </FocusCell>
-                  <FocusCell>
-                    <input placeholder="C2" />
-                  </FocusCell>
-                  <FocusCell>
-                    <input placeholder="D2" />
-                  </FocusCell>
-                </FocusRow>
-              </div>
-            </FocusTable>
-          </>
-        );
-      }
-
-      ReactDOM.render(<Test />, container);
-      firstRef.current.focus();
-
-      expect(document.activeElement.placeholder).toBe('A1');
-      const a1 = createEventTarget(document.activeElement);
-      a1.keydown({
-        key: 'ArrowRight',
-      });
-      expect(document.activeElement.placeholder).toBe('B1');
-      let b1 = createEventTarget(document.activeElement);
-      b1.keydown({
-        key: 'ArrowRight',
-      });
-      expect(document.activeElement.placeholder).toBe('C1');
-      let c1 = createEventTarget(document.activeElement);
-      c1.keydown({
-        key: 'ArrowDown',
-      });
-      expect(document.activeElement.placeholder).toBe('D2');
-      let d2 = createEventTarget(document.activeElement);
-      d2.keydown({
-        key: 'ArrowUp',
-      });
-      expect(document.activeElement.placeholder).toBe('C1');
-      c1 = createEventTarget(document.activeElement);
-      c1.keydown({
-        key: 'ArrowLeft',
-      });
-      expect(document.activeElement.placeholder).toBe('B1');
-      b1 = createEventTarget(document.activeElement);
-      b1.keydown({
-        key: 'ArrowDown',
-      });
-      expect(document.activeElement.placeholder).toBe('B2');
-      const b2 = createEventTarget(document.activeElement);
-      b2.keydown({
-        key: 'ArrowRight',
-      });
-      expect(document.activeElement.placeholder).toBe('C2');
-      const c2 = createEventTarget(document.activeElement);
-      c2.keydown({
-        key: 'ArrowUp',
-      });
-      expect(document.activeElement.placeholder).toBe('B1');
-    });
-  });
-});
diff --git a/packages/react-interactions/accessibility/src/__tests__/TabbableScopeQuery-test.internal.js b/packages/react-interactions/accessibility/src/__tests__/TabbableScopeQuery-test.internal.js
deleted file mode 100644
index a3cd9b2ee6a1..000000000000
--- a/packages/react-interactions/accessibility/src/__tests__/TabbableScopeQuery-test.internal.js
+++ /dev/null
@@ -1,75 +0,0 @@
-/**
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- *
- * @flow
- */
-
-let React;
-let ReactFeatureFlags;
-let tabbableScopeQuery;
-
-describe('TabbableScopeQuery', () => {
-  beforeEach(() => {
-    jest.resetModules();
-    ReactFeatureFlags = require('shared/ReactFeatureFlags');
-    ReactFeatureFlags.enableScopeAPI = true;
-    tabbableScopeQuery = require('../TabbableScopeQuery').default;
-    React = require('react');
-  });
-
-  describe('ReactDOM', () => {
-    let ReactDOM;
-    let container;
-
-    beforeEach(() => {
-      ReactDOM = require('react-dom');
-      container = document.createElement('div');
-      document.body.appendChild(container);
-    });
-
-    afterEach(() => {
-      document.body.removeChild(container);
-      container = null;
-    });
-
-    it('DO_NOT_USE_queryAllNodes() works as intended', () => {
-      const scopeRef = React.createRef();
-      const nodeRefA = React.createRef();
-      const nodeRefB = React.createRef();
-      const nodeRefC = React.createRef();
-      const nodeRefD = React.createRef();
-
-      const TestScope = React.unstable_createScope();
-
-      function Test() {
-        return (
-          <TestScope ref={scopeRef}>
-            <input ref={nodeRefA} />
-            <textarea ref={nodeRefB} />
-            <div tabIndex={0} ref={nodeRefC}>
-              <input tabIndex={-1} />
-              <div tabIndex={0} ref={nodeRefD} />
-            </div>
-            <input disabled={true} />
-            <div tabIndex={-1} />
-          </TestScope>
-        );
-      }
-
-      ReactDOM.render(<Test />, container);
-      let nodes = scopeRef.current.DO_NOT_USE_queryAllNodes(tabbableScopeQuery);
-      expect(nodes).toEqual([
-        nodeRefA.current,
-        nodeRefB.current,
-        nodeRefC.current,
-        nodeRefD.current,
-      ]);
-      expect(nodes.length).toBe(4);
-      ReactDOM.render(null, container);
-      expect(scopeRef.current).toBe(null);
-    });
-  });
-});
diff --git a/packages/react-interactions/accessibility/src/shared/emulateBrowserTab.js b/packages/react-interactions/accessibility/src/shared/emulateBrowserTab.js
deleted file mode 100644
index 35a1b9b83e65..000000000000
--- a/packages/react-interactions/accessibility/src/shared/emulateBrowserTab.js
+++ /dev/null
@@ -1,38 +0,0 @@
-/**
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- *
- * @emails react-core
- */
-
-'use strict';
-
-import {createEventTarget} from 'dom-event-testing-library';
-
-// This function is used by the a11y modules for testing
-export function emulateBrowserTab(backwards: boolean): void {
-  const activeElement = document.activeElement;
-  const focusedElem = createEventTarget(activeElement);
-  let defaultPrevented = false;
-  focusedElem.keydown({
-    key: 'Tab',
-    shiftKey: backwards,
-    preventDefault() {
-      defaultPrevented = true;
-    },
-  });
-  if (!defaultPrevented) {
-    // This is not a full spec compliant version, but should be suffice for this test
-    const focusableElems = Array.from(
-      document.querySelectorAll(
-        'input, button, select, textarea, a[href], [tabindex], [contenteditable], iframe, object, embed',
-      ),
-    ).filter(elem => elem.tabIndex > -1 && !elem.disabled);
-    const idx = focusableElems.indexOf(activeElement);
-    if (idx !== -1) {
-      focusableElems[backwards ? idx - 1 : idx + 1].focus();
-    }
-  }
-}
diff --git a/packages/react-interactions/accessibility/src/shared/getTabbableNodes.js b/packages/react-interactions/accessibility/src/shared/getTabbableNodes.js
deleted file mode 100644
index 7af8612e5f96..000000000000
--- a/packages/react-interactions/accessibility/src/shared/getTabbableNodes.js
+++ /dev/null
@@ -1,40 +0,0 @@
-/**
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- *
- * @flow
- */
-
-import type {ReactScopeMethods} from 'shared/ReactTypes';
-
-export default function getTabbableNodes(
-  scopeQuery: (type: string | Object, props: Object) => boolean,
-  scope: ReactScopeMethods,
-): [
-  null | Array<HTMLElement>,
-  null | HTMLElement,
-  null | HTMLElement,
-  number,
-  null | HTMLElement,
-] {
-  const tabbableNodes = scope.DO_NOT_USE_queryAllNodes(scopeQuery);
-  if (tabbableNodes === null || tabbableNodes.length === 0) {
-    return [null, null, null, 0, null];
-  }
-  const firstTabbableElem = tabbableNodes[0];
-  const lastTabbableElem = tabbableNodes[tabbableNodes.length - 1];
-  const currentIndex = tabbableNodes.indexOf(document.activeElement);
-  let focusedElement = null;
-  if (currentIndex !== -1) {
-    focusedElement = tabbableNodes[currentIndex];
-  }
-  return [
-    tabbableNodes,
-    firstTabbableElem,
-    lastTabbableElem,
-    currentIndex,
-    focusedElement,
-  ];
-}
diff --git a/packages/react-interactions/accessibility/src/shared/setElementCanTab.js b/packages/react-interactions/accessibility/src/shared/setElementCanTab.js
deleted file mode 100644
index d473b8f81e36..000000000000
--- a/packages/react-interactions/accessibility/src/shared/setElementCanTab.js
+++ /dev/null
@@ -1,50 +0,0 @@
-/**
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- *
- * @flow
- */
-
-const tabIndexDesc = Object.getOwnPropertyDescriptor(
-  HTMLElement.prototype,
-  'tabIndex',
-);
-const tabIndexSetter = (tabIndexDesc: any).set;
-
-export default function setElementCanTab(
-  elem: HTMLElement,
-  canTab: boolean,
-): void {
-  let tabIndexState = (elem: any)._tabIndexState;
-  if (!tabIndexState) {
-    tabIndexState = {
-      value: elem.tabIndex,
-      canTab,
-    };
-    (elem: any)._tabIndexState = tabIndexState;
-    if (!canTab) {
-      elem.tabIndex = -1;
-    }
-    // We track the tabIndex value so we can restore the correct
-    // tabIndex after we're done with it.
-    // $FlowFixMe: Flow comoplains that we are missing value?
-    Object.defineProperty(elem, 'tabIndex', {
-      enumerable: false,
-      configurable: true,
-      get() {
-        return tabIndexState.canTab ? tabIndexState.value : -1;
-      },
-      set(val) {
-        if (tabIndexState.canTab) {
-          tabIndexSetter.call(elem, val);
-        }
-        tabIndexState.value = val;
-      },
-    });
-  } else if (tabIndexState.canTab !== canTab) {
-    tabIndexSetter.call(elem, canTab ? tabIndexState.value : -1);
-    tabIndexState.canTab = canTab;
-  }
-}
diff --git a/packages/react-interactions/accessibility/tabbable-scope-query.js b/packages/react-interactions/accessibility/tabbable-scope-query.js
deleted file mode 100644
index 4582a9ba2cbb..000000000000
--- a/packages/react-interactions/accessibility/tabbable-scope-query.js
+++ /dev/null
@@ -1,12 +0,0 @@
-/**
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- *
- * @flow
- */
-
-'use strict';
-
-module.exports = require('./src/TabbableScopeQuery');
diff --git a/packages/react-reconciler/src/ReactFiberScope.js b/packages/react-reconciler/src/ReactFiberScope.js
index a593ef22af41..ef78a1398452 100644
--- a/packages/react-reconciler/src/ReactFiberScope.js
+++ b/packages/react-reconciler/src/ReactFiberScope.js
@@ -13,6 +13,7 @@ import type {
   ReactScopeInstance,
   ReactScopeMethods,
   ReactContext,
+  ReactScopeQuery,
 } from 'shared/ReactTypes';
 
 import {getPublicInstance, getInstanceFromNode} from './ReactFiberHostConfig';
@@ -37,7 +38,7 @@ const emptyObject = {};
 
 function collectScopedNodes(
   node: Fiber,
-  fn: (type: string | Object, props: Object, instance: Object) => boolean,
+  fn: ReactScopeQuery,
   scopedNodes: Array<any>,
 ): void {
   if (enableScopeAPI) {
@@ -64,7 +65,7 @@ function collectScopedNodes(
 
 function collectFirstScopedNode(
   node: Fiber,
-  fn: (type: string | Object, props: Object, instance: Object) => boolean,
+  fn: ReactScopeQuery,
 ): null | Object {
   if (enableScopeAPI) {
     if (node.tag === HostComponent) {
@@ -88,7 +89,7 @@ function collectFirstScopedNode(
 
 function collectScopedNodesFromChildren(
   startingChild: Fiber,
-  fn: (type: string | Object, props: Object, instance: Object) => boolean,
+  fn: ReactScopeQuery,
   scopedNodes: Array<any>,
 ): void {
   let child = startingChild;
@@ -100,7 +101,7 @@ function collectScopedNodesFromChildren(
 
 function collectFirstScopedNodeFromChildren(
   startingChild: Fiber,
-  fn: (type: string | Object, props: Object, instance: Object) => boolean,
+  fn: ReactScopeQuery,
 ): Object | null {
   let child = startingChild;
   while (child !== null) {
@@ -113,37 +114,6 @@ function collectFirstScopedNodeFromChildren(
   return null;
 }
 
-function collectNearestScopeMethods(
-  node: Fiber,
-  scope: ReactScope,
-  childrenScopes: Array<ReactScopeMethods>,
-): void {
-  if (isValidScopeNode(node, scope)) {
-    childrenScopes.push(node.stateNode.methods);
-  } else {
-    let child = node.child;
-
-    if (isFiberSuspenseAndTimedOut(node)) {
-      child = getSuspenseFallbackChild(node);
-    }
-    if (child !== null) {
-      collectNearestChildScopeMethods(child, scope, childrenScopes);
-    }
-  }
-}
-
-function collectNearestChildScopeMethods(
-  startingChild: Fiber | null,
-  scope: ReactScope,
-  childrenScopes: Array<ReactScopeMethods>,
-): void {
-  let child = startingChild;
-  while (child !== null) {
-    collectNearestScopeMethods(child, scope, childrenScopes);
-    child = child.sibling;
-  }
-}
-
 function collectNearestContextValues<T>(
   node: Fiber,
   context: ReactContext<T>,
@@ -176,62 +146,12 @@ function collectNearestChildContextValues<T>(
   }
 }
 
-function isValidScopeNode(node, scope) {
-  return (
-    node.tag === ScopeComponent &&
-    node.type === scope &&
-    node.stateNode !== null
-  );
-}
-
 export function createScopeMethods(
   scope: ReactScope,
   instance: ReactScopeInstance,
 ): ReactScopeMethods {
   return {
-    DO_NOT_USE_getChildren(): null | Array<ReactScopeMethods> {
-      const currentFiber = ((instance.fiber: any): Fiber);
-      const child = currentFiber.child;
-      const childrenScopes = [];
-      if (child !== null) {
-        collectNearestChildScopeMethods(child, scope, childrenScopes);
-      }
-      return childrenScopes.length === 0 ? null : childrenScopes;
-    },
-    DO_NOT_USE_getChildrenFromRoot(): null | Array<ReactScopeMethods> {
-      const currentFiber = ((instance.fiber: any): Fiber);
-      let node = currentFiber;
-      while (node !== null) {
-        const parent = node.return;
-        if (parent === null) {
-          break;
-        }
-        node = parent;
-        if (node.tag === ScopeComponent && node.type === scope) {
-          break;
-        }
-      }
-      const childrenScopes = [];
-      collectNearestChildScopeMethods(node.child, scope, childrenScopes);
-      return childrenScopes.length === 0 ? null : childrenScopes;
-    },
-    DO_NOT_USE_getParent(): null | ReactScopeMethods {
-      let node = ((instance.fiber: any): Fiber).return;
-      while (node !== null) {
-        if (node.tag === ScopeComponent && node.type === scope) {
-          return node.stateNode.methods;
-        }
-        node = node.return;
-      }
-      return null;
-    },
-    DO_NOT_USE_getProps(): Object {
-      const currentFiber = ((instance.fiber: any): Fiber);
-      return currentFiber.memoizedProps;
-    },
-    DO_NOT_USE_queryAllNodes(
-      fn: (type: string | Object, props: Object, instance: Object) => boolean,
-    ): null | Array<Object> {
+    DO_NOT_USE_queryAllNodes(fn: ReactScopeQuery): null | Array<Object> {
       const currentFiber = ((instance.fiber: any): Fiber);
       const child = currentFiber.child;
       const scopedNodes = [];
@@ -240,9 +160,7 @@ export function createScopeMethods(
       }
       return scopedNodes.length === 0 ? null : scopedNodes;
     },
-    DO_NOT_USE_queryFirstNode(
-      fn: (type: string | Object, props: Object, instance: Object) => boolean,
-    ): null | Object {
+    DO_NOT_USE_queryFirstNode(fn: ReactScopeQuery): null | Object {
       const currentFiber = ((instance.fiber: any): Fiber);
       const child = currentFiber.child;
       if (child !== null) {
diff --git a/packages/react-reconciler/src/__tests__/ReactScope-test.internal.js b/packages/react-reconciler/src/__tests__/ReactScope-test.internal.js
index bbba67c75762..8144a11be827 100644
--- a/packages/react-reconciler/src/__tests__/ReactScope-test.internal.js
+++ b/packages/react-reconciler/src/__tests__/ReactScope-test.internal.js
@@ -201,106 +201,6 @@ describe('ReactScope', () => {
       expect(scopeRef.current.containsNode(emRef.current)).toBe(false);
     });
 
-    it('mixed DO_NOT_USE_getParent() and queryAllNodes() works as intended', () => {
-      const testScopeQuery = (type, props) => true;
-      const TestScope = React.unstable_createScope();
-      const TestScope2 = React.unstable_createScope();
-      const refA = React.createRef();
-      const refB = React.createRef();
-      const refC = React.createRef();
-      const refD = React.createRef();
-      const spanA = React.createRef();
-      const spanB = React.createRef();
-      const divA = React.createRef();
-      const divB = React.createRef();
-
-      function Test() {
-        return (
-          <div>
-            <TestScope ref={refA}>
-              <span ref={spanA}>
-                <TestScope2 ref={refB}>
-                  <div ref={divA}>
-                    <TestScope ref={refC}>
-                      <span ref={spanB}>
-                        <TestScope2 ref={refD}>
-                          <div ref={divB}>>Hello world</div>
-                        </TestScope2>
-                      </span>
-                    </TestScope>
-                  </div>
-                </TestScope2>
-              </span>
-            </TestScope>
-          </div>
-        );
-      }
-
-      ReactDOM.render(<Test />, container);
-      const dParent = refD.current.DO_NOT_USE_getParent();
-      expect(dParent).not.toBe(null);
-      expect(dParent.DO_NOT_USE_queryAllNodes(testScopeQuery)).toEqual([
-        divA.current,
-        spanB.current,
-        divB.current,
-      ]);
-      const cParent = refC.current.DO_NOT_USE_getParent();
-      expect(cParent).not.toBe(null);
-      expect(cParent.DO_NOT_USE_queryAllNodes(testScopeQuery)).toEqual([
-        spanA.current,
-        divA.current,
-        spanB.current,
-        divB.current,
-      ]);
-      expect(refB.current.DO_NOT_USE_getParent()).toBe(null);
-      expect(refA.current.DO_NOT_USE_getParent()).toBe(null);
-    });
-
-    it('DO_NOT_USE_getChildren() works as intended', () => {
-      const TestScope = React.unstable_createScope();
-      const TestScope2 = React.unstable_createScope();
-      const refA = React.createRef();
-      const refB = React.createRef();
-      const refC = React.createRef();
-      const refD = React.createRef();
-      const spanA = React.createRef();
-      const spanB = React.createRef();
-      const divA = React.createRef();
-      const divB = React.createRef();
-
-      function Test() {
-        return (
-          <div>
-            <TestScope ref={refA}>
-              <span ref={spanA}>
-                <TestScope2 ref={refB}>
-                  <div ref={divA}>
-                    <TestScope ref={refC}>
-                      <span ref={spanB}>
-                        <TestScope2 ref={refD}>
-                          <div ref={divB}>>Hello world</div>
-                        </TestScope2>
-                      </span>
-                    </TestScope>
-                  </div>
-                </TestScope2>
-              </span>
-            </TestScope>
-          </div>
-        );
-      }
-
-      ReactDOM.render(<Test />, container);
-      const dChildren = refD.current.DO_NOT_USE_getChildren();
-      expect(dChildren).toBe(null);
-      const cChildren = refC.current.DO_NOT_USE_getChildren();
-      expect(cChildren).toBe(null);
-      const bChildren = refB.current.DO_NOT_USE_getChildren();
-      expect(bChildren).toEqual([refD.current]);
-      const aChildren = refA.current.DO_NOT_USE_getChildren();
-      expect(aChildren).toEqual([refC.current]);
-    });
-
     it('scopes support server-side rendering and hydration', () => {
       const TestScope = React.unstable_createScope();
       const ReactDOMServer = require('react-dom/server');
@@ -534,113 +434,5 @@ describe('ReactScope', () => {
       renderer.update(<Test toggle={true} />);
       expect(scopeRef.current.containsNode(emRef.current)).toBe(false);
     });
-
-    it('mixed DO_NOT_USE_getParent() and DO_NOT_USE_queryAllNodes() works as intended', () => {
-      const testScopeQuery = (type, props) => true;
-      const TestScope = React.unstable_createScope();
-      const TestScope2 = React.unstable_createScope();
-      const refA = React.createRef();
-      const refB = React.createRef();
-      const refC = React.createRef();
-      const refD = React.createRef();
-      const spanA = React.createRef();
-      const spanB = React.createRef();
-      const divA = React.createRef();
-      const divB = React.createRef();
-
-      function Test() {
-        return (
-          <div>
-            <TestScope ref={refA}>
-              <span ref={spanA}>
-                <TestScope2 ref={refB}>
-                  <div ref={divA}>
-                    <TestScope ref={refC}>
-                      <span ref={spanB}>
-                        <TestScope2 ref={refD}>
-                          <div ref={divB}>>Hello world</div>
-                        </TestScope2>
-                      </span>
-                    </TestScope>
-                  </div>
-                </TestScope2>
-              </span>
-            </TestScope>
-          </div>
-        );
-      }
-
-      ReactTestRenderer.create(<Test />, {
-        createNodeMock: element => {
-          return element;
-        },
-      });
-      const dParent = refD.current.DO_NOT_USE_getParent();
-      expect(dParent).not.toBe(null);
-      expect(dParent.DO_NOT_USE_queryAllNodes(testScopeQuery)).toEqual([
-        divA.current,
-        spanB.current,
-        divB.current,
-      ]);
-      const cParent = refC.current.DO_NOT_USE_getParent();
-      expect(cParent).not.toBe(null);
-      expect(cParent.DO_NOT_USE_queryAllNodes(testScopeQuery)).toEqual([
-        spanA.current,
-        divA.current,
-        spanB.current,
-        divB.current,
-      ]);
-      expect(refB.current.DO_NOT_USE_getParent()).toBe(null);
-      expect(refA.current.DO_NOT_USE_getParent()).toBe(null);
-    });
-
-    it('DO_NOT_USE_getChildren() works as intended', () => {
-      const TestScope = React.unstable_createScope();
-      const TestScope2 = React.unstable_createScope();
-      const refA = React.createRef();
-      const refB = React.createRef();
-      const refC = React.createRef();
-      const refD = React.createRef();
-      const spanA = React.createRef();
-      const spanB = React.createRef();
-      const divA = React.createRef();
-      const divB = React.createRef();
-
-      function Test() {
-        return (
-          <div>
-            <TestScope ref={refA}>
-              <span ref={spanA}>
-                <TestScope2 ref={refB}>
-                  <div ref={divA}>
-                    <TestScope ref={refC}>
-                      <span ref={spanB}>
-                        <TestScope2 ref={refD}>
-                          <div ref={divB}>>Hello world</div>
-                        </TestScope2>
-                      </span>
-                    </TestScope>
-                  </div>
-                </TestScope2>
-              </span>
-            </TestScope>
-          </div>
-        );
-      }
-
-      ReactTestRenderer.create(<Test />, {
-        createNodeMock: element => {
-          return element;
-        },
-      });
-      const dChildren = refD.current.DO_NOT_USE_getChildren();
-      expect(dChildren).toBe(null);
-      const cChildren = refC.current.DO_NOT_USE_getChildren();
-      expect(cChildren).toBe(null);
-      const bChildren = refB.current.DO_NOT_USE_getChildren();
-      expect(bChildren).toEqual([refD.current]);
-      const aChildren = refA.current.DO_NOT_USE_getChildren();
-      expect(aChildren).toEqual([refC.current]);
-    });
   });
 });
diff --git a/packages/shared/ReactTypes.js b/packages/shared/ReactTypes.js
index 18508fb3fcb1..74c255577dbd 100644
--- a/packages/shared/ReactTypes.js
+++ b/packages/shared/ReactTypes.js
@@ -170,17 +170,15 @@ export type ReactScope = {|
   $$typeof: Symbol | number,
 |};
 
+export type ReactScopeQuery = (
+  type: string,
+  props: {[string]: mixed, ...},
+  instance: mixed,
+) => boolean;
+
 export type ReactScopeMethods = {|
-  DO_NOT_USE_getChildren(): null | Array<ReactScopeMethods>,
-  DO_NOT_USE_getChildrenFromRoot(): null | Array<ReactScopeMethods>,
-  DO_NOT_USE_getParent(): null | ReactScopeMethods,
-  DO_NOT_USE_getProps(): Object,
-  DO_NOT_USE_queryAllNodes(
-    (type: string | Object, props: Object, instance: Object) => boolean,
-  ): null | Array<Object>,
-  DO_NOT_USE_queryFirstNode(
-    (type: string | Object, props: Object, instance: Object) => boolean,
-  ): null | Object,
+  DO_NOT_USE_queryAllNodes(ReactScopeQuery): null | Array<Object>,
+  DO_NOT_USE_queryFirstNode(ReactScopeQuery): null | Object,
   containsNode(Object): boolean,
   getChildContextValues: <T>(context: ReactContext<T>) => Array<T>,
 |};
