diff --git a/axe.d.ts b/axe.d.ts
index b1fc54ce1d..f3e54bd34d 100644
--- a/axe.d.ts
+++ b/axe.d.ts
@@ -45,23 +45,48 @@ declare namespace axe {
     | 'embedded'
     | 'interactive';
 
+  // Array of length 2 or greater
+  type MultiArray<T> = [T, T, ...T[]];
+
+  // Selectors within a frame
   type BaseSelector = string;
-  type CrossTreeSelector = BaseSelector | BaseSelector[];
-  type CrossFrameSelector = CrossTreeSelector[];
 
-  type ContextObject = {
-    include?: Node | BaseSelector | Array<Node | BaseSelector | BaseSelector[]>;
-    exclude?: Node | BaseSelector | Array<Node | BaseSelector | BaseSelector[]>;
-  };
+  type ShadowDomSelector = MultiArray<BaseSelector>;
+  type CrossTreeSelector = BaseSelector | ShadowDomSelector;
+  type LabelledShadowDomSelector = { fromShadowDom: ShadowDomSelector };
 
-  type SerialContextObject = {
-    include?: BaseSelector | Array<BaseSelector | BaseSelector[]>;
-    exclude?: BaseSelector | Array<BaseSelector | BaseSelector[]>;
-  };
+  // Cross-frame selectors
+  type FramesSelector = Array<CrossTreeSelector | LabelledShadowDomSelector>;
+  type UnlabelledFrameSelector = CrossTreeSelector[];
+  type LabelledFramesSelector = { fromFrames: MultiArray<FramesSelector[0]> };
+  /**
+   * @deprecated Use UnlabelledFrameSelector instead
+   */
+  type CrossFrameSelector = UnlabelledFrameSelector;
 
-  type RunCallback = (error: Error, results: AxeResults) => void;
+  // Context options
+  type Selector =
+    | Node
+    | BaseSelector
+    | LabelledShadowDomSelector
+    | LabelledFramesSelector;
+  type SelectorList = Array<Selector | FramesSelector> | NodeList;
+  type ContextObject =
+    | {
+        include: Selector | SelectorList;
+        exclude?: Selector | SelectorList;
+      }
+    | {
+        exclude: Selector | SelectorList;
+      };
+  type ElementContext = Selector | SelectorList | ContextObject;
+
+  interface SerialContextObject {
+    include: UnlabelledFrameSelector[];
+    exclude: UnlabelledFrameSelector[];
+  }
 
-  type ElementContext = Node | NodeList | string | ContextObject;
+  type RunCallback = (error: Error, results: AxeResults) => void;
 
   interface TestEngine {
     name: string;
@@ -255,9 +280,9 @@ declare namespace axe {
   interface SerialDqElement {
     source: string;
     nodeIndexes: number[];
-    selector: CrossFrameSelector;
+    selector: UnlabelledFrameSelector;
     xpath: string[];
-    ancestry: CrossFrameSelector;
+    ancestry: UnlabelledFrameSelector;
   }
   interface PartialRuleResult {
     id: string;
@@ -273,7 +298,7 @@ declare namespace axe {
   }
   type PartialResults = Array<PartialResult | null>;
   interface FrameContext {
-    frameSelector: CrossTreeSelector;
+    frameSelector: UnlabelledFrameSelector;
     frameContext: SerialContextObject;
   }
   interface Utils {
@@ -282,6 +307,7 @@ declare namespace axe {
       options?: RunOptions
     ) => FrameContext[];
     shadowSelect: (selector: CrossTreeSelector) => Element | null;
+    shadowSelectAll: (selector: CrossTreeSelector) => Element[];
   }
   interface EnvironmentData {
     testEngine: TestEngine;
diff --git a/doc/API.md b/doc/API.md
index b6c92977fd..60b040ba0e 100644
--- a/doc/API.md
+++ b/doc/API.md
@@ -321,57 +321,28 @@ By default, `axe.run` will test the entire document. The context object is an op
    - Example: To limit analysis to the `<div id="content">` element: `document.getElementById("content")`
 1. A NodeList such as returned by `document.querySelectorAll`.
 1. A [CSS selector](./developer-guide.md#supported-css-selectors) that selects the portion(s) of the document that must be analyzed.
-1. An include-exclude object (see below)
+1. An object with `exclude` and/or `include` properties
+1. An object with a `fromFrames` property
+1. An object with a `fromShadowDom` property
 
-###### Include-Exclude Object
-
-The include exclude object is a JSON object with two attributes: include and exclude. Either include or exclude is required. If only `exclude` is specified; include will default to the entire `document`.
-
-- A node, or
-- An array of Nodes or an array of arrays of [CSS selectors](./developer-guide.md#supported-css-selectors)
-  - If the nested array contains a single string, that string is the CSS selector
-  - If the nested array contains multiple strings
-    - The last string is the final CSS selector
-    - All other's are the nested structure of iframes inside the document
-
-In most cases, the component arrays will contain only one CSS selector. Multiple CSS selectors are only required if you want to include or exclude regions of a page that are inside iframes (or iframes within iframes within iframes). In this case, the first n-1 selectors are selectors that select the iframe(s) and the nth selector, selects the region(s) within the iframe.
+Read [context.md](context.md) for details about the context object.
 
 ###### Context Parameter Examples
 
-1. Include the first item in the `$fixture` NodeList but exclude its first child
-
-```js
-axe.run(
-  {
-    include: $fixture[0],
-    exclude: $fixture[0].firstChild
-  },
-  (err, results) => {
-    // ...
-  }
-);
-```
-
-2. Include the element with the ID of `fix` but exclude any `div`s within it
+1. Test the `#navBar` and all other `nav` elements and its content.
 
 ```js
-axe.run(
-  {
-    include: [['#fix']],
-    exclude: [['#fix div']]
-  },
-  (err, results) => {
-    // ...
-  }
-);
+axe.run([`#navBar`, `nav`], (err, results) => {
+  // ...
+});
 ```
 
-3. Include the whole document except any structures whose parent contains the class `exclude1` or `exclude2`
+2. Test everything except `.ad-banner` elements.
 
 ```js
 axe.run(
   {
-    exclude: [['.exclude1'], ['.exclude2']]
+    exclude: '.ad-banner'
   },
   (err, results) => {
     // ...
@@ -379,12 +350,12 @@ axe.run(
 );
 ```
 
-4. Include the element with the ID of `fix`, within the iframe with id `frame`
+3. Test the `form` element inside the `#payment` iframe.
 
 ```js
 axe.run(
   {
-    include: [['#frame', '#fix']]
+    fromFrames: ['iframe#payment', 'form']
   },
   (err, results) => {
     // ...
@@ -392,12 +363,14 @@ axe.run(
 );
 ```
 
-5. Include the element with the ID of `fix`, within the iframe with id `frame2`, within the iframe with id `frame1`
+4. Exclude all `.commentBody` elements in each `.commentsShadowHost` shadow DOM tree.
 
 ```js
 axe.run(
   {
-    include: [['#frame1', '#frame2', '#fix']]
+    exclude: {
+      fromShadowDom: ['.commentsShadowHost', '.commentBody']
+    }
   },
   (err, results) => {
     // ...
@@ -405,22 +378,7 @@ axe.run(
 );
 ```
 
-6. Include the following:
-
-- The element with the ID of `fix`, within the iframe with id `frame2`, within the iframe with id `frame1`
-- The element with id `header`
-- All links
-
-```js
-axe.run(
-  {
-    include: [['#header'], ['a'], ['#frame1', '#frame2', '#fix']]
-  },
-  (err, results) => {
-    // ...
-  }
-);
-```
+More details on how to use the context object are described in [context.md](context.md).
 
 ##### Options Parameter
 
diff --git a/doc/context.md b/doc/context.md
new file mode 100644
index 0000000000..bfe7f3c2b3
--- /dev/null
+++ b/doc/context.md
@@ -0,0 +1,280 @@
+# Axe Testing Context
+
+Axe-core's `context` argument is a powerful tool for controlling precisely which elements are tested and which are ignored. The context lets you do many things, including:
+
+1. [Test specific elements](#test-specific-elements)
+1. [Test DOM nodes](#test-dom-nodes)
+1. [Exclude elements from test](#exclude-elements-from-test)
+1. [Select from prior tests](#select-from-prior-tests)
+1. [Limit frame testing](#limit-frame-testing)
+1. [Limit shadow DOM testing](#limit-shadow-dom-testing)
+1. [Combine shadow DOM and frame context](#combine-shadow-dom-and-frame-context)
+1. [Implicit frame and shadow DOM selection](#implicit-frame-and-shadow-dom-selection)
+
+## Test Specific Elements
+
+When passed a CSS selector or array of CSS selectors, axe will test only the elements that match those selectors, along with any content inside those elements:
+
+```js
+// Test every <nav> and <main> element, and everything inside them:
+await axe.run('nav, main');
+// Test every <nav> element, every element with the sideBar class,
+// and the element with the #header ID, along with all their content:
+await axe.run(['nav', '.sideBar', '#header']);
+```
+
+**Tip**: Sometimes pages are worked on by multiple teams. If you mark your team's sections up with a unique class, axe can use that class to only test the sections your team works on.
+
+Axe-core is commonly used through browser driver APIs such as Selenium, Puppeteer, and Playwright. Most of these APIs do not pass a context object in directly. Instead, the following is achieved through the `.include()` method. Visit the docs of your API for more information. For most cases, this will look like the following:
+
+```js
+const axe = new AxeBuilder({ page });
+// Test every <nav> and <main> element, and everything inside them:
+axe.include('nav, main');
+```
+
+## Test DOM Nodes
+
+Axe can accept native DOM elements for testing. These must be attached to the DOM tree first. Testing DOM elements is useful in test environments such as Karma and Jest. The following example shows axe testing DOM elements:
+
+```js
+// Test a single DOM node
+const img = document.createElement('img');
+document.body.appendChild(img);
+await axe.run(img);
+
+// Test a Node list:
+const nodes = document.querySelector('main, header');
+await axe.run(nodes);
+
+// Test an array of nodes:
+const navbar = document.getElementById('navbar');
+const cookiePopup = document.getElementById('cookie-popup');
+await axe.run([navbar, cookiePopup]);
+```
+
+### Component Frameworks
+
+Because axe requires a DOM to test, components such as those created for React, Vue and Angular must be rendered before they are tested. The following example shows how to render the `<MyApp>` React component before testing it with axe:
+
+```jsx
+const appRoot = document.getElementById('app');
+ReactDOM.createRoot(appRoot).render(MyApp);
+await axe.run(appRoot);
+```
+
+**Important**: Component testing libraries like [Enzyme](https://enzymejs.github.io/enzyme/) include both a `render` and `shallow` method. Because axe requires a complete render, attached to the DOM tree, it is unable to test components built with `shallow` methods.
+
+## Exclude Elements from Test
+
+There are often areas of a page that as a developer you have no control over. You can tell axe to skip such elements in the test by using an object with the `exclude` property. The `exclude` property accepts all the same properties used before, including CSS selectors and DOM nodes:
+
+```js
+// Test everything except the ad banners:
+await axe.run({ exclude: '.ad-banner' });
+
+// Test everything except these DOM nodes:
+const youtubeVids = document.querySelector('iframe[src^="youtube.com"]');
+await axe.run({ exclude: youtubeVids });
+```
+
+When using an axe API such as axe-core/playwright, you must use the AxeBuilder's `.exclude` method to exclude elements from the test. See the docs of your API for details:
+
+```js
+const axe = new AxeBuilder({ page });
+// Test everything except the ad banner and YouTube frames:
+axe.exclude('.ad-banner, iframe[src^="youtube.com"]');
+```
+
+### The `include` Property
+
+When axe is passed a CSS selector or an array of DOM nodes, this is treated as an implicit `include`. All examples from [Test specific elements](#test-specific-elements) and [Test DOM nodes](#test-dom-nodes) use this implicit `include`. All of these could be rewritten using an object with the `include` property. The following examples function identically:
+
+```js
+await axe.run('main'); // is the same as:
+await axe.run({ include: 'main' });
+```
+
+When axe isn't passed an `include` (explicit or not), it uses `document` instead:
+
+```js
+await axe.run({ exclude: '.ad-banner' }); // is the same as:
+await axe.run({
+  include: document,
+  exclude: '.ad-banner'
+});
+```
+
+### Combine `exclude` with `include`
+
+To test specific sections of the page while skipping parts within that section, you can pass an object with `include` and `exclude` properties. `include` tells axe what elements to test, and `exclude` tells axe to skip certain included sections. The following shows how to test the `main` and `footer` elements in a page, except for any `.ad-banner` element:
+
+```js
+await axe.run({
+  include: ['main', 'footer'],
+  exclude: '.ad-banner'
+});
+```
+
+**Note**: When an element is both included and excluded, the selector that matches the nearest ancestor takes priority. I.e. if a node's grandparent is included, but the parent is excluded, then the node is excluded. If the node's grandparent is excluded, but its parent is included, the node is included.
+
+## Select From Prior Tests
+
+It is possible to `include` or `exclude` nodes from prior tests. This lets you either skip those issues, or repeat a test while you are working on a solution. This can be done using the `target` property from an axe result:
+
+```js
+// Grab the target property from all color-contrast violations:
+const violation = priorResult.violations.find(
+  ({ id }) => id === 'color-contrast'
+);
+const targets = violation.nodes.map(issue => issue.target);
+// Run axe, only testing the prior color-contrast violations
+await axe.run(targets);
+
+// Or, to exclude those nodes from the test:
+await axe.run({ exclude: targets });
+```
+
+**Important**: It is not possible to pass a single `target` property to axe. This must be wrapped in an array. This is because axe-core's `target` property is itself an array. See [Implicit Frame And Shadow DOM Selection](#implicit-frame-and-shadow-dom-selection) for details.
+
+## Limit Frame Testing
+
+Including or excluding specific sections within a frame can be done with a `fromFrames` selector object. This property takes an array of selectors: the first to select the frame element(s) and the last to select the element(s) to include or exclude. The following shows how to test all `form` elements a `#paymentFrame` frame or iframe:
+
+```js
+// Test each <form> inside each #paymentFrame frame or iframe:
+axe.run({ fromFrames: ['#paymentFrame', 'form'] });
+```
+
+To select elements in nested frames, axe will need a selector for each level of nesting. Because axe tests frames recursively, this can be any number of levels deep. The following shows how to test the `form`, inside an `#inner`, inside an `#outer` iframe:
+
+```js
+// Test <form> inside, #inner, inside #outer:
+axe.run({ fromFrames: ['iframe#outer', 'iframe#inner', 'form'] });
+```
+
+The `fromFrames` object can be used as part of an `exclude` or `include` property. It can be by itself or as part of an array along with other selectors. The following example shows how to exclude all `.ad-banner` elements on the top window, as well as any that are part of the first level of iframes:
+
+```js
+// Skip any .ad-banner, as well as any .ad-banner inside iframes:
+axe.run({
+  exclude: [
+    '.ad-banner',
+    {
+      fromFrames: ['iframe', '.ad-banner']
+    }
+  ]
+});
+```
+
+The `fromFrames` selector object can be used on both the `include` and `exclude` property. The following shows how to test the `form` inside the `#payment` iframe, except for the `.ad-banner` in that `form`:
+
+```js
+axe.run({
+  include: {
+    fromFrames: ['iframe#payment', 'form']
+  },
+  exclude: {
+    fromFrames: ['iframe#payment', 'form > .ad-banner']
+  }
+});
+```
+
+**Note**: The `fromFrames` property cannot be used on the same object as `include` and `exclude`.
+
+## Limit Shadow DOM Testing
+
+Including or excluding specific sections of a [shadow DOM](https://developer.mozilla.org/en-US/docs/Web/Web_Components/Using_shadow_DOM) tree can be done with a `fromShadowDom` selector object. This works similar to the [`fromFrames` selector](#limit-frame-testing). The `fromShadowDom` property takes an array of strings: the first to select the shadow DOM host element(s) and the last to select the element(s) to include or exclude. The following example shows how to test the `#search` form inside the shadow DOM tree attached to the `.app-header` element:
+
+```js
+// Test each search form inside each <app-header> shadow DOM tree.
+axe.run({ fromShadowDom: ['.app-header', 'form#search'] });
+```
+
+To select elements in nested shadow DOM trees, axe will need a selector for each level of nesting. The following shows how to test the `#search` element inside the `.header` element's Shadow DOM tree, inside the `app-root` custom element's shadow DOM tree:
+
+```js
+// Test #search, inside each .header, inside each <app-root>
+axe.run({ fromShadowDom: ['app-root', '.header', '#search'] });
+```
+
+The `fromShadowDom` selector object can also be used as part of an `exclude` or `include` property. It can be by itself, or part of an array along with other selectors. The following example shows how to exclude all `.comment` elements inside the `<blog-comments>` custom element, as well as excluding the `footer` element:
+
+```js
+// Skip footer, as well as any .comment element inside the shadow DOM tree of <blog-comments>
+axe.run({
+  exclude: [
+    'footer',
+    {
+      fromShadowDom: ['blog-comments', '.comment']
+    }
+  ]
+});
+```
+
+The `fromShadowDom` selector object can be used on both the `include` and `exclude` property. The following shows how to test the `<app-footer>` custom component, inside the shadow DOM of the `#root` element, but to exclude any `.ad-banner` inside the `<app-footer>`'s shadow DOM tree:
+
+```js
+axe.run({
+  include: {
+    fromShadowDom: ['#root', 'app-footer']
+  },
+  exclude: {
+    fromShadowDom: ['#root', 'app-footer', '.ad-banner']
+  }
+});
+```
+
+**Note**: The `fromShadowDom` property cannot be used on the same object as `include` and `exclude`.
+
+### Slotted Elements
+
+Axe uses the flattened DOM tree to determine whether an element is included or excluded. Because of this when a shadow DOM node is selected, all descendants inserted through the [`<slot />` element](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/Slot) are also selected.
+
+## Combine Shadow DOM and Frame Context
+
+To select frames inside shadow DOM trees or shadow DOM trees inside frames, it is possible to use [`fromShadowDom`](#limit-shadow-dom-testing) as a selector in the [`fromFrames`](#limit-frame-testing) selector object. The following example shows how to test the `main` element, inside each `iframe` that is part of the shadow DOM tree of `#appRoot`:
+
+```js
+await axe.run({
+  fromFrames: [
+    {
+      fromShadowDom: ['#appRoot', 'iframe']
+    },
+    'main'
+  ]
+});
+```
+
+These selectors can also be used on `include` or `exclude`. The following shows how to exclude the `footer`, as well as any `.commentBody` elements in the `#userComments` shadow DOM tree, inside the `#blog-comments` iframe:
+
+```js
+await axe.run({
+  exclude: [
+    'footer',
+    {
+      fromFrames: [
+        'iframe#blog-comments',
+        {
+          fromShadowDom: ['#userComments', '.commentBody']
+        }
+      ]
+    }
+  ]
+});
+```
+
+**Note**: Even though the iframe is inside the shadow DOM tree, the `fromShadowDom` selector object must be part of the `fromFrames` selector. Doing the reverse does not work and will cause an error.
+
+## Implicit Frame and Shadow DOM Selection
+
+In earlier versions of axe, using nested arrays was the only way to include or exclude elements inside iframes. These are still supported in axe and is how axe works internally. This nested array syntax is used in the `target` property. For example, the following is a possible selector for a `.commentBody` element, in the shadow DOM tree of `#userComments`, inside the `#blog-comments` iframe:
+
+```js
+result = await axe.run();
+result.violations[0].nodes[0].target; // ['#blog-comments', ['#userComments', '.commentBody']]
+```
+
+To pass a `target` property into axe, it must be wrapped in another array. This creates three nested arrays: the outer array to allow multiple selectors, the middle array to select into frames, and the inner array, which is optional, to select elements inside shadow DOM trees.
+
+While this syntax continues to be supported, it is recommended to avoid it and to use the [fromFrames](#limit-frame-testing) and [fromShadowDom](#limit-shadow-dom-testing) object selectors instead since these are clearer and don't need to be wrapped in otherwise empty arrays.
diff --git a/lib/core/base/context/normalize-context.js b/lib/core/base/context/normalize-context.js
index b4eaa779a9..ac1dc6265d 100644
--- a/lib/core/base/context/normalize-context.js
+++ b/lib/core/base/context/normalize-context.js
@@ -1,52 +1,181 @@
+import { assert as utilsAssert } from '../../utils';
+
 /**
  * Normalize the input of "context" so that many different methods of input are accepted
  * @private
- * @param  {Mixed} context  The configuration object passed to `Context`
- * @return {Object}         Normalized context spec to include both `include` and `exclude` arrays
+ * @param  {Mixed} contextSpec The configuration object passed to `Context`
+ * @return {Object}            Normalized context spec to include both `include` and `exclude` arrays
  */
-export function normalizeContext(context) {
-  // typeof NodeList.length in PhantomJS === function
-  if (
-    (context && typeof context === 'object') ||
-    context instanceof window.NodeList
-  ) {
-    if (context instanceof window.Node) {
-      return {
-        include: [context],
-        exclude: []
-      };
-    }
+export function normalizeContext(contextSpec) {
+  if (isContextObject(contextSpec)) {
+    // Assert include / exclude isn't mixed with fromFrames / fromShadowDom
+    const msg =
+      ' must be used inside include or exclude. It should not be on the same object.';
+    assert(!objectHasOwn(contextSpec, 'fromFrames'), 'fromFrames' + msg);
+    assert(!objectHasOwn(contextSpec, 'fromShadowDom'), 'fromShadowDom' + msg);
+  } else if (isContextProp(contextSpec)) {
+    // Wrap in include
+    contextSpec = { include: contextSpec, exclude: [] };
+  } else {
+    // Spec is unknown
+    return { include: [document], exclude: [] };
+  }
 
-    if (
-      context.hasOwnProperty('include') ||
-      context.hasOwnProperty('exclude')
-    ) {
-      return {
-        include:
-          context.include && +context.include.length
-            ? context.include
-            : [document],
-        exclude: context.exclude || []
-      };
-    }
+  const include = normalizeContextList(contextSpec.include);
+  if (include.length === 0) {
+    include.push(document); // Include defaults to [document] if empty
+  }
+  const exclude = normalizeContextList(contextSpec.exclude);
+  return { include, exclude };
+}
+
+/**
+ * Determine if some value can be parsed as a context
+ * @private
+ * @param  {Mixed} contextSpec The configuration object passed to `Context`
+ * @return {boolea}
+ */
+export function isContextSpec(contextSpec) {
+  return isContextObject(contextSpec) || isContextProp(contextSpec);
+}
 
-    if (context.length === +context.length) {
-      return {
-        include: context,
-        exclude: []
-      };
+function normalizeContextList(selectorList = []) {
+  const normalizedList = [];
+  if (!isArrayLike(selectorList)) {
+    selectorList = [selectorList];
+  }
+  // Use .length to handle jQuery-like objects
+  for (let i = 0; i < selectorList.length; i++) {
+    const normalizedSelector = normalizeContextSelector(selectorList[i]);
+    if (normalizedSelector) {
+      normalizedList.push(normalizedSelector);
     }
   }
+  return normalizedList;
+}
+
+function normalizeContextSelector(selector) {
+  if (selector instanceof window.Node) {
+    return selector; // Nodes must not be wrapped in an array
+  }
+  if (typeof selector === 'string') {
+    return [selector]; // Convert to frame selector
+  }
 
-  if (typeof context === 'string') {
-    return {
-      include: [[context]],
-      exclude: []
-    };
+  if (isLabelledFramesSelector(selector)) {
+    assertLabelledFrameSelector(selector);
+    selector = selector.fromFrames;
+  } else if (isLabelledShadowDomSelector(selector)) {
+    selector = [selector];
+  }
+  return normalizeFrameSelectors(selector);
+}
+
+function normalizeFrameSelectors(frameSelectors) {
+  if (!Array.isArray(frameSelectors)) {
+    return; // Invalid. Skip this selector
+  }
+  const normalizedSelectors = [];
+  for (let selector of frameSelectors) {
+    if (isLabelledShadowDomSelector(selector)) {
+      assertLabelledShadowDomSelector(selector);
+      selector = selector.fromShadowDom;
+    }
+    if (typeof selector !== 'string' && !isShadowSelector(selector)) {
+      return; // Invalid. Skip this selector
+    }
+    normalizedSelectors.push(selector);
   }
+  return normalizedSelectors;
+}
+
+function isContextObject(contextSpec) {
+  return ['include', 'exclude'].some(
+    prop => objectHasOwn(contextSpec, prop) && isContextProp(contextSpec[prop])
+  );
+}
+
+function isContextProp(contextList) {
+  return (
+    typeof contextList === 'string' ||
+    contextList instanceof window.Node ||
+    isLabelledFramesSelector(contextList) ||
+    isLabelledShadowDomSelector(contextList) ||
+    isArrayLike(contextList)
+  );
+}
 
-  return {
-    include: [document],
-    exclude: []
-  };
+function isLabelledFramesSelector(selector) {
+  return objectHasOwn(selector, 'fromFrames');
+}
+
+function isLabelledShadowDomSelector(selector) {
+  return objectHasOwn(selector, 'fromShadowDom');
+}
+
+function assertLabelledFrameSelector(selector) {
+  assert(
+    Array.isArray(selector.fromFrames),
+    'fromFrames property must be an array'
+  );
+  assert(
+    selector.fromFrames.every(
+      selector => !objectHasOwn(selector, 'fromFrames')
+    ),
+    'Invalid context; fromFrames selector must be appended, rather than nested'
+  );
+  assert(
+    !objectHasOwn(selector, 'fromShadowDom'),
+    'fromFrames and fromShadowDom cannot be used on the same object'
+  );
+}
+
+function assertLabelledShadowDomSelector(selector) {
+  assert(
+    Array.isArray(selector.fromShadowDom),
+    'fromShadowDom property must be an array'
+  );
+  assert(
+    selector.fromShadowDom.every(
+      selector => !objectHasOwn(selector, 'fromFrames')
+    ),
+    'shadow selector must be inside fromFrame instead'
+  );
+  assert(
+    selector.fromShadowDom.every(
+      selector => !objectHasOwn(selector, 'fromShadowDom')
+    ),
+    'fromShadowDom selector must be appended, rather than nested'
+  );
+}
+
+function isShadowSelector(selector) {
+  return (
+    Array.isArray(selector) && selector.every(str => typeof str === 'string')
+  );
+}
+
+function isArrayLike(arr) {
+  return (
+    arr &&
+    typeof arr === 'object' &&
+    typeof arr.length === 'number' &&
+    arr instanceof window.Node === false // Avoid DOM weirdness
+  );
+}
+
+// Wrapper to ensure the correct message
+function assert(bool, str) {
+  utilsAssert(
+    bool,
+    `Invalid context; ${str}\nSee: https://github.com/dequelabs/axe-core/blob/master/doc/context.md`
+  );
+}
+
+// Wrapper to prevent throwing for non-objects & null
+function objectHasOwn(obj, prop) {
+  if (!obj || typeof obj !== 'object') {
+    return false;
+  }
+  return Object.prototype.hasOwnProperty.call(obj, prop);
 }
diff --git a/lib/core/base/context/parse-selector-array.js b/lib/core/base/context/parse-selector-array.js
index 1d4e183eff..4435664f41 100644
--- a/lib/core/base/context/parse-selector-array.js
+++ b/lib/core/base/context/parse-selector-array.js
@@ -1,5 +1,5 @@
 import { createFrameContext } from './create-frame-context';
-import { getNodeFromTree } from '../../utils';
+import { getNodeFromTree, shadowSelectAll } from '../../utils';
 
 /**
  * Finds frames in context, converts selectors to Element references and pushes unique frames
@@ -12,13 +12,6 @@ export function parseSelectorArray(context, type) {
   const result = [];
   for (let i = 0, l = context[type].length; i < l; i++) {
     const item = context[type][i];
-    // selector
-    if (typeof item === 'string') {
-      const nodeList = Array.from(document.querySelectorAll(item));
-      result.push(...nodeList.map(node => getNodeFromTree(node)));
-      break;
-    }
-
     // Handle nodes
     if (item instanceof window.Node) {
       if (item.documentElement instanceof window.Node) {
@@ -26,15 +19,13 @@ export function parseSelectorArray(context, type) {
       } else {
         result.push(getNodeFromTree(item));
       }
-      continue;
-    }
 
-    // Handle Iframe selection
-    if (item && item.length) {
+      // Handle Iframe selection
+    } else if (item && item.length) {
       if (item.length > 1) {
         pushUniqueFrameSelector(context, type, item);
       } else {
-        const nodeList = Array.from(document.querySelectorAll(item[0]));
+        const nodeList = shadowSelectAll(item[0]);
         result.push(...nodeList.map(node => getNodeFromTree(node)));
       }
     }
@@ -56,22 +47,13 @@ function pushUniqueFrameSelector(context, type, selectorArray) {
   context.frames = context.frames || [];
 
   const frameSelector = selectorArray.shift();
-  const frames = document.querySelectorAll(frameSelector);
-
-  Array.from(frames).forEach(frame => {
-    context.frames.forEach(contextFrame => {
-      if (contextFrame.node === frame) {
-        contextFrame[type].push(selectorArray);
-      }
-    });
-
-    if (!context.frames.find(result => result.node === frame)) {
-      const result = createFrameContext(frame, context);
-      if (selectorArray) {
-        result[type].push(selectorArray);
-      }
-
-      context.frames.push(result);
+  const frames = shadowSelectAll(frameSelector);
+  frames.forEach(frame => {
+    let frameContext = context.frames.find(result => result.node === frame);
+    if (!frameContext) {
+      frameContext = createFrameContext(frame, context);
+      context.frames.push(frameContext);
     }
+    frameContext[type].push(selectorArray);
   });
 }
diff --git a/lib/core/public/run-virtual-rule.js b/lib/core/public/run-virtual-rule.js
index d474dcb112..189720f198 100644
--- a/lib/core/public/run-virtual-rule.js
+++ b/lib/core/public/run-virtual-rule.js
@@ -16,7 +16,7 @@ import {
  * @param {Object} options  (optional) Set of options passed into rules or checks
  * @return {Object} axe results for the rule run
  */
-function runVirtualRule(ruleId, vNode, options = {}) {
+export default function runVirtualRule(ruleId, vNode, options = {}) {
   // TODO: es-modules axe._audit
   // TODO: es-modules axe._selectorData
   options.reporter = options.reporter || axe._audit.reporter || 'v1';
@@ -37,10 +37,15 @@ function runVirtualRule(ruleId, vNode, options = {}) {
   // can avoid this call by forcing the rule to not exclude hidden
   // elements
   rule = Object.create(rule, { excludeHidden: { value: false } });
-
   const context = {
     initiator: true,
-    include: [vNode]
+    include: [vNode],
+    exclude: [],
+    frames: [],
+    page: false,
+    focusable: true,
+    size: {},
+    flatTree: []
   };
 
   const rawResults = rule.runSync(context, options);
@@ -60,5 +65,3 @@ function runVirtualRule(ruleId, vNode, options = {}) {
     toolOptions: options
   };
 }
-
-export default runVirtualRule;
diff --git a/lib/core/public/run.js b/lib/core/public/run.js
index 0f85843391..b5bdbd40e9 100644
--- a/lib/core/public/run.js
+++ b/lib/core/public/run.js
@@ -1,5 +1,5 @@
 import { getReporter } from './reporter';
-import normalizeRunArgs from './run/normalize-run-params';
+import normalizeRunParams from './run/normalize-run-params';
 import { setupGlobals, resetGlobals } from './run/globals-setup';
 import { assert } from '../utils';
 
@@ -18,7 +18,7 @@ const noop = () => {};
  */
 export default function run(...args) {
   setupGlobals(args[0]);
-  const { context, options, callback = noop } = normalizeRunArgs(args);
+  const { context, options, callback = noop } = normalizeRunParams(args);
   const { thenable, resolve, reject } = getPromiseHandlers(callback);
   try {
     assert(axe._audit, 'No audit configured');
diff --git a/lib/core/public/run/normalize-run-params.js b/lib/core/public/run/normalize-run-params.js
index 95b059a814..96c4b18f4e 100644
--- a/lib/core/public/run/normalize-run-params.js
+++ b/lib/core/public/run/normalize-run-params.js
@@ -1,4 +1,5 @@
 import { clone } from '../../utils';
+import { isContextSpec } from '../../base/context/normalize-context';
 
 /**
  * Normalize the optional params of axe.run()
@@ -11,7 +12,7 @@ export default function normalizeRunParams([context, options, callback]) {
   const typeErr = new TypeError('axe.run arguments are invalid');
 
   // Determine the context
-  if (!isContext(context)) {
+  if (!isContextSpec(context)) {
     if (callback !== undefined) {
       // Either context is invalid or there are too many params
       throw typeErr;
@@ -42,24 +43,3 @@ export default function normalizeRunParams([context, options, callback]) {
   options.reporter = options.reporter ?? axe._audit?.reporter ?? 'v1';
   return { context, options, callback };
 }
-
-export function isContext(potential) {
-  switch (true) {
-    case typeof potential === 'string':
-    case Array.isArray(potential):
-    case window.Node && potential instanceof window.Node:
-    case window.NodeList && potential instanceof window.NodeList:
-      return true;
-
-    case typeof potential !== 'object':
-      return false;
-
-    case potential.include !== undefined:
-    case potential.exclude !== undefined:
-    case typeof potential.length === 'number':
-      return true;
-
-    default:
-      return false;
-  }
-}
diff --git a/lib/core/utils/contains.js b/lib/core/utils/contains.js
index 90efa09680..dfea001e1f 100644
--- a/lib/core/utils/contains.js
+++ b/lib/core/utils/contains.js
@@ -7,33 +7,25 @@
  * @return {Boolean}           Whether `vNode` contains `otherVNode`
  */
 export default function contains(vNode, otherVNode) {
-  /*eslint no-bitwise: 0*/
-  if (vNode.shadowId || otherVNode.shadowId) {
-    do {
-      if (vNode.shadowId === otherVNode.shadowId) {
-        return true;
-      }
-      otherVNode = otherVNode.parent;
-    } while (otherVNode);
-    return false;
+  // Native light DOM method
+  if (
+    !vNode.shadowId &&
+    !otherVNode.shadowId &&
+    vNode.actualNode &&
+    typeof vNode.actualNode.contains === 'function'
+  ) {
+    return vNode.actualNode.contains(otherVNode.actualNode);
   }
 
-  if (!vNode.actualNode) {
-    // fallback for virtualNode only contexts
-    // @see https://github.com/Financial-Times/polyfill-service/pull/183/files
-    do {
-      if (otherVNode === vNode) {
-        return true;
-      }
-      otherVNode = otherVNode.parent;
-    } while (otherVNode);
-  }
+  // Alternative method for shadow DOM / virtual tree tests
+  do {
+    if (vNode === otherVNode) {
+      return true;
+    } else if (otherVNode.nodeIndex < vNode.nodeIndex) {
+      return false;
+    }
+    otherVNode = otherVNode.parent;
+  } while (otherVNode);
 
-  if (typeof vNode.actualNode.contains !== 'function') {
-    const position = vNode.actualNode.compareDocumentPosition(
-      otherVNode.actualNode
-    );
-    return !!(position & 16);
-  }
-  return vNode.actualNode.contains(otherVNode.actualNode);
+  return false;
 }
diff --git a/lib/core/utils/is-node-in-context.js b/lib/core/utils/is-node-in-context.js
index c7af4489ba..cb8dbcb35c 100644
--- a/lib/core/utils/is-node-in-context.js
+++ b/lib/core/utils/is-node-in-context.js
@@ -1,20 +1,5 @@
 import contains from './contains';
 
-/**
- * Get the deepest node in a given collection
- * @private
- * @param  {Array} collection Array of nodes to test
- * @return {Node}             The deepest node
- */
-function getDeepest(collection) {
-  return collection.sort((a, b) => {
-    if (contains(a, b)) {
-      return 1;
-    }
-    return -1;
-  })[0];
-}
-
 /**
  * Determines if a node is included or excluded in a given context
  * @private
@@ -22,25 +7,32 @@ function getDeepest(collection) {
  * @param  {Object}  context "Resolved" context object, @see resolveContext
  * @return {Boolean}         [description]
  */
-function isNodeInContext(node, context) {
-  const include =
-    context.include &&
-    getDeepest(
-      context.include.filter(candidate => {
-        return contains(candidate, node);
-      })
-    );
-  const exclude =
-    context.exclude &&
-    getDeepest(
-      context.exclude.filter(candidate => {
-        return contains(candidate, node);
-      })
-    );
-  if ((!exclude && include) || (exclude && contains(exclude, include))) {
+export default function isNodeInContext(node, { include = [], exclude = [] }) {
+  const filterInclude = include.filter(candidate => contains(candidate, node));
+  if (filterInclude.length === 0) {
+    return false;
+  }
+  const filterExcluded = exclude.filter(candidate => contains(candidate, node));
+  if (filterExcluded.length === 0) {
     return true;
   }
-  return false;
+  const deepestInclude = getDeepest(filterInclude);
+  const deepestExclude = getDeepest(filterExcluded);
+  return contains(deepestExclude, deepestInclude);
 }
 
-export default isNodeInContext;
+/**
+ * Get the deepest node in a given collection
+ * @private
+ * @param  {Array} collection Array of nodes to test
+ * @return {Node}             The deepest node
+ */
+function getDeepest(collection) {
+  let deepest;
+  for (const node of collection) {
+    if (!deepest || !contains(node, deepest)) {
+      deepest = node;
+    }
+  }
+  return deepest;
+}
diff --git a/lib/core/utils/select.js b/lib/core/utils/select.js
index 671ea31c22..3be91565ff 100644
--- a/lib/core/utils/select.js
+++ b/lib/core/utils/select.js
@@ -2,55 +2,13 @@ import contains from './contains';
 import querySelectorAllFilter from './query-selector-all-filter';
 import isNodeInContext from './is-node-in-context';
 
-/**
- * Pushes unique nodes that are in context to an array
- * @private
- * @param  {Array} result  The array to push to
- * @param  {Array} nodes   The list of nodes to push
- * @param  {Object} context The "resolved" context object, @see resolveContext
- */
-function pushNode(result, nodes) {
-  let temp;
-
-  if (result.length === 0) {
-    return nodes;
-  }
-  if (result.length < nodes.length) {
-    // switch so the comparison is shortest
-    temp = result;
-    result = nodes;
-    nodes = temp;
-  }
-  for (let i = 0, l = nodes.length; i < l; i++) {
-    if (!result.includes(nodes[i])) {
-      result.push(nodes[i]);
-    }
-  }
-  return result;
-}
-
-/**
- * reduces the includes list to only the outermost includes
- * @private
- * @param {Array} the array of include nodes
- * @return {Array} the modified array of nodes
- */
-function getOuterIncludes(includes) {
-  return includes.reduce((res, el) => {
-    if (!res.length || !contains(res[res.length - 1], el)) {
-      res.push(el);
-    }
-    return res;
-  }, []);
-}
-
 /**
  * Selects elements which match `selector` that are included and excluded via the `Context` object
  * @param  {String} selector  CSS selector of the HTMLElements to select
  * @param  {Context} context  The "resolved" context object, @see Context
  * @return {Array}            Matching virtual DOM nodes sorted by DOM order
  */
-function select(selector, context) {
+export default function select(selector, context) {
   let result = [];
   let candidate;
   if (axe._selectCache) {
@@ -69,7 +27,7 @@ function select(selector, context) {
   for (let i = 0; i < outerIncludes.length; i++) {
     candidate = outerIncludes[i];
     const nodes = querySelectorAllFilter(candidate, selector, isInContext);
-    result = pushNode(result, nodes);
+    result = mergeArrayUniques(result, nodes);
   }
   if (axe._selectCache) {
     axe._selectCache.push({
@@ -80,7 +38,20 @@ function select(selector, context) {
   return result;
 }
 
-export default select;
+/**
+ * reduces the includes list to only the outermost includes
+ * @private
+ * @param {Array} the array of include nodes
+ * @return {Array} the modified array of nodes
+ */
+function getOuterIncludes(includes) {
+  return includes.reduce((res, el) => {
+    if (!res.length || !contains(res[res.length - 1], el)) {
+      res.push(el);
+    }
+    return res;
+  }, []);
+}
 
 /**
  * Return a filter method to test if a node is in context; or
@@ -97,3 +68,27 @@ function getContextFilter(context) {
   }
   return node => isNodeInContext(node, context);
 }
+
+/**
+ * Merge the unique items from Array 1 into 2, or from 2 into 1 (whichever is longest)
+ * @private
+ * @param  {Array} Arr1
+ * @param  {Array} Arr2
+ */
+function mergeArrayUniques(arr1, arr2) {
+  if (arr1.length === 0) {
+    return arr2;
+  }
+  if (arr1.length < arr2.length) {
+    // switch so the comparison is shortest
+    const temp = arr1;
+    arr1 = arr2;
+    arr2 = temp;
+  }
+  for (let i = 0, l = arr2.length; i < l; i++) {
+    if (!arr1.includes(arr2[i])) {
+      arr1.push(arr2[i]);
+    }
+  }
+  return arr1;
+}
diff --git a/test/core/base/context.js b/test/core/base/context.js
index 9098ba8a31..3a28ad0baa 100644
--- a/test/core/base/context.js
+++ b/test/core/base/context.js
@@ -1,11 +1,17 @@
-/*eslint no-unused-vars:0*/
+/*eslint no-new:0*/
 describe('Context', () => {
   const { Context } = axe._thisWillBeDeletedDoNotUse.base;
+  const { createNestedShadowDom } = axe.testUtils;
   const fixture = document.getElementById('fixture');
 
   function $id(id) {
     return document.getElementById(id);
   }
+  const selectors = elms =>
+    elms.map(elm => {
+      const domNode = elm?.actualNode || elm;
+      return domNode.id ? `#${domNode.id}` : domNode.nodeName.toLowerCase();
+    });
 
   it('should not mutate exclude in input', () => {
     fixture.innerHTML = '<div id="foo"></div>';
@@ -32,11 +38,11 @@ describe('Context', () => {
     };
     const context = new Context(spec);
     assert.notStrictEqual(spec.include, context.include);
-    spec.include.forEach(function (_, index) {
+    spec.include.forEach((_, index) => {
       assert.notStrictEqual(spec.include[index], context.include[index]);
     });
     assert.notStrictEqual(spec.exclude, context.exclude);
-    spec.exclude.forEach(function (_, index) {
+    spec.exclude.forEach((_, index) => {
       assert.notStrictEqual(spec.exclude[index], context.exclude[index]);
     });
     assert.notStrictEqual(spec.size, context.size);
@@ -50,45 +56,70 @@ describe('Context', () => {
   });
 
   describe('include', () => {
-    it('should accept a single selector', () => {
+    it('accepts a single selector', () => {
       fixture.innerHTML = '<div id="foo"></div>';
       const result = new Context('#foo');
-
-      assert.deepEqual([result.include[0].actualNode], [$id('foo')]);
+      assert.deepEqual(selectors(result.include), ['#foo']);
+      assert.isEmpty(result.exclude);
     });
 
-    it('should accept multiple selectors', () => {
+    it('accepts frame selectors', () => {
       fixture.innerHTML = '<div id="foo"><div id="bar"></div></div>';
       const result = new Context([['#foo'], ['#bar']]);
+      assert.deepEqual(selectors(result.include), ['#foo', '#bar']);
+      assert.isEmpty(result.exclude);
+    });
 
-      assert.deepEqual(
-        [result.include[0].actualNode, result.include[1].actualNode],
-        [$id('foo'), $id('bar')]
-      );
+    it('accepts an array of strings as selectors', () => {
+      fixture.innerHTML = '<div id="foo"><div id="bar"></div></div>';
+      const context = new Context(['#foo', '#bar']);
+      assert.deepEqual(selectors(context.include), ['#foo', '#bar']);
+      assert.isEmpty(context.exclude);
     });
 
-    it('should accept a node reference', () => {
+    it('accepts a node reference', () => {
       const div = document.createElement('div');
       fixture.appendChild(div);
-
       const result = new Context(div);
-
       assert.deepEqual([result.include[0].actualNode], [div]);
     });
 
-    it('should accept a node reference consisting of nested divs', () => {
+    it('does not match shadow DOM nodes with light DOM selection', () => {
+      createNestedShadowDom(
+        fixture,
+        `<p id="p1">Light DOM</p>
+        <article id="shadowHost">
+          <p id="p2">Slotted light DOM</p>
+        </article>`,
+        `<section id="shadowHost"> <slot /> </section>
+        <p id="p3">Shadow DOM</p>`
+      );
+      const result = new Context([[['p']]]);
+      assert.deepEqual(selectors(result.include), ['#p1', '#p2']);
+    });
+
+    it('accepts shadow DOM selectors', () => {
+      createNestedShadowDom(
+        fixture,
+        '<article id="shadowHost"></article>',
+        '<div><section id="shadowHost"></section></div>',
+        '<h1 id="target">Hello world</h1>'
+      );
+      const result = new Context([[['#fixture > article', 'section', 'h1']]]);
+      assert.equal(result.include[0].props.id, 'target');
+    });
+
+    it('accepts a node reference consisting of nested divs', () => {
       const div1 = document.createElement('div');
       const div2 = document.createElement('div');
-
       div1.appendChild(div2);
       fixture.appendChild(div1);
 
       const result = new Context(div1);
-
       assert.deepEqual([result.include[0].actualNode], [div1]);
     });
 
-    it('should accept a node reference consisting of a form with nested controls', () => {
+    it('accepts a node reference consisting of a form with nested controls', () => {
       const form = document.createElement('form');
       const input = document.createElement('input');
 
@@ -96,78 +127,48 @@ describe('Context', () => {
       fixture.appendChild(form);
 
       const result = new Context(form);
-
-      assert.deepEqual([result.include[0].actualNode], [form]);
+      assert.deepEqual(result.include[0].actualNode, form);
     });
 
-    it('should accept an array of node references', () => {
+    it('accepts an array of node references', () => {
       fixture.innerHTML = '<div id="foo"><div id="bar"></div></div>';
-
       const result = new Context([$id('foo'), $id('bar')]);
-
       assert.deepEqual(
         [result.include[0].actualNode, result.include[1].actualNode],
         [$id('foo'), $id('bar')]
       );
     });
 
-    it('should remove any non-matched reference', () => {
+    it('removes any non-matched reference', () => {
       fixture.innerHTML = '<div id="foo"><div id="bar"></div></div>';
-
       const result = new Context([['#foo'], ['#baz'], ['#bar']]);
-
-      assert.deepEqual(
-        result.include.map(function (n) {
-          return n.actualNode;
-        }),
-        [$id('foo'), $id('bar')]
-      );
+      assert.deepEqual(selectors(result.include), ['#foo', '#bar']);
     });
 
-    it('should sort the include nodes in document order', () => {
+    it('sorts the include nodes in document order', () => {
       fixture.innerHTML =
         '<div id="foo"><div id="bar"></div></div><div id="baz"></div>';
-
       const result = new Context([['#foo'], ['#baz'], ['#bar']]);
-
-      assert.deepEqual(
-        result.include.map(function (n) {
-          return n.actualNode;
-        }),
-        [$id('foo'), $id('bar'), $id('baz')]
-      );
+      assert.deepEqual(selectors(result.include), ['#foo', '#bar', '#baz']);
     });
 
-    it('should remove any null reference', () => {
+    it('removes any null reference', () => {
       fixture.innerHTML = '<div id="foo"><div id="bar"></div></div>';
-
       const result = new Context([$id('foo'), $id('bar'), null]);
-
-      assert.deepEqual(
-        result.include.map(function (n) {
-          return n.actualNode;
-        }),
-        [$id('foo'), $id('bar')]
-      );
+      assert.deepEqual(selectors(result.include), ['#foo', '#bar']);
     });
 
-    it('should accept mixed', () => {
+    it('accepts an array of mixed selectors and nodes', () => {
       fixture.innerHTML = '<div id="foo"><div id="bar"></div></div>';
       const div = document.createElement('div');
       div.id = 'baz';
       fixture.appendChild(div);
 
-      const result = new Context([['#foo'], ['#bar'], div]);
-
-      assert.deepEqual(
-        result.include.map(function (n) {
-          return n.actualNode;
-        }),
-        [$id('foo'), $id('bar'), $id('baz')]
-      );
+      const result = new Context([['#foo'], '#bar', div]);
+      assert.deepEqual(selectors(result.include), ['#foo', '#bar', '#baz']);
     });
 
-    it('should support jQuery-like objects', () => {
+    it('accepts jQuery-like objects', () => {
       fixture.innerHTML =
         '<div id="foo"></div><div id="bar"></div><div id="baz"></div>';
       const $test = {
@@ -178,13 +179,7 @@ describe('Context', () => {
       };
 
       const result = new Context($test);
-
-      assert.deepEqual(
-        result.include.map(function (n) {
-          return n.actualNode;
-        }),
-        [$id('foo'), $id('bar'), $id('baz')]
-      );
+      assert.deepEqual(selectors(result.include), ['#foo', '#bar', '#baz']);
     });
 
     describe('throwing errors', () => {
@@ -201,7 +196,7 @@ describe('Context', () => {
         fixture.innerHTML = '<div id="foo"></div>';
         assert.throws(
           () => {
-            const ctxt = new Context('#notAnElement');
+            new Context('#notAnElement');
           },
           Error,
           'No elements found for include in page Context'
@@ -216,7 +211,7 @@ describe('Context', () => {
         fixture.innerHTML = '<div id="foo"></div>';
         assert.throws(
           () => {
-            const ctxt = new Context('#notAnElement');
+            new Context('#notAnElement');
           },
           Error,
           'No elements found for include in frame Context'
@@ -224,15 +219,15 @@ describe('Context', () => {
       });
     });
 
-    it('should create a flatTree property', () => {
+    it('creates a flatTree property', () => {
       const context = new Context({ include: [document] });
       assert.isArray(context.flatTree);
       assert.isAtLeast(context.flatTree.length, 1);
     });
   });
 
-  describe('object definition', function () {
-    it('should assign include/exclude', function () {
+  describe('object definition', () => {
+    it('should assign include/exclude', () => {
       const context = new Context({
         include: [['#fixture']],
         exclude: [['#mocha']]
@@ -252,7 +247,7 @@ describe('Context', () => {
       assert.isAtLeast(context.flatTree.length, 1);
     });
 
-    it('should disregard bad input, non-matching selectors', function () {
+    it('should disregard bad input, non-matching selectors', () => {
       const flatTree = axe.utils.getFlattenedTree(document);
       const context = new Context({
         include: [['#fixture'], ['#monkeys']],
@@ -276,21 +271,21 @@ describe('Context', () => {
       );
     });
 
-    it('should disregard bad input (null)', function () {
+    it('should disregard bad input (null)', () => {
       const result = new Context();
 
       assert.lengthOf(result.include, 1);
       assert.equal(result.include[0].actualNode, document.documentElement);
 
-      assert.lengthOf(result.exclude, 0);
+      assert.isEmpty(result.exclude);
 
       assert.isTrue(result.initiator);
       assert.isTrue(result.page);
 
-      assert.lengthOf(result.frames, 0);
+      assert.isEmpty(result.frames);
     });
 
-    it('should default include to document', function () {
+    it('should default include to document', () => {
       const result = new Context({ exclude: [['#fixture']] });
       assert.lengthOf(result.include, 1);
       assert.equal(result.include[0].actualNode, document.documentElement);
@@ -301,34 +296,50 @@ describe('Context', () => {
       assert.isTrue(result.initiator);
       assert.isTrue(result.page);
 
-      assert.lengthOf(result.frames, 0);
+      assert.isEmpty(result.frames);
     });
 
-    it('should default empty include to document', function () {
+    it('should default empty include to document', () => {
       const result = new Context({ include: [], exclude: [] });
       assert.lengthOf(result.include, 1);
       assert.equal(result.include[0].actualNode, document.documentElement);
     });
+
+    it('throws when it has a fromFrames prop', () => {
+      assert.throws(() => {
+        new Context({
+          include: [],
+          fromFrames: ['frame', '#fixture']
+        });
+      });
+    });
+
+    it('throws when it has a fromShadowDom prop', () => {
+      assert.throws(() => {
+        new Context({
+          include: [],
+          fromShadowDom: ['frame', '#fixture']
+        });
+      });
+    });
   });
 
-  describe('initiator', function () {
-    it('should not be clobbered', function () {
+  describe('initiator', () => {
+    it('should not be clobbered', () => {
       const result = new Context({
         initiator: false
       });
       assert.lengthOf(result.include, 1);
       assert.equal(result.include[0].actualNode, document.documentElement);
 
-      assert.lengthOf(result.exclude, 0);
-
+      assert.isEmpty(result.exclude);
       assert.isFalse(result.initiator);
       assert.isTrue(result.page);
-
-      assert.lengthOf(result.frames, 0);
+      assert.isEmpty(result.frames);
     });
 
     // document.hasOwnProperty is undefined in Firefox content scripts
-    it('should not throw given really weird circumstances when hasOwnProperty is deleted from a document node?', function () {
+    it('should not throw given really weird circumstances when hasOwnProperty is deleted from a document node?', () => {
       const spec = document.implementation.createHTMLDocument('ie is dumb');
       spec.hasOwnProperty = undefined;
 
@@ -337,29 +348,29 @@ describe('Context', () => {
       assert.lengthOf(result.include, 1);
       assert.equal(result.include[0].actualNode, spec.documentElement);
 
-      assert.lengthOf(result.exclude, 0);
+      assert.isEmpty(result.exclude);
 
       assert.isTrue(result.initiator);
       assert.isFalse(result.page);
 
-      assert.lengthOf(result.frames, 0);
+      assert.isEmpty(result.frames);
     });
   });
 
-  describe('page', function () {
-    it('takes the page argument as default', function () {
+  describe('page', () => {
+    it('takes the page argument as default', () => {
       assert.isTrue(new Context({ page: true }).page);
       assert.isFalse(new Context({ page: false }).page);
     });
 
-    it('is true if the document element is included', function () {
+    it('is true if the document element is included', () => {
       assert.isTrue(new Context(document).page);
       assert.isTrue(new Context(document.documentElement).page);
       assert.isTrue(new Context('html').page);
       assert.isTrue(new Context(':root').page);
     });
 
-    it('is true, with exclude used', function () {
+    it('is true, with exclude used', () => {
       // What matters is that the documentElement is included
       // not that parts within that are excluded
       assert.isTrue(
@@ -370,7 +381,7 @@ describe('Context', () => {
       );
     });
 
-    it('is false if the context does not include documentElement', function () {
+    it('is false if the context does not include documentElement', () => {
       assert.isFalse(new Context(fixture).page);
       assert.isFalse(new Context('#fixture').page);
       assert.isFalse(new Context([['#fixture']]).page);
@@ -378,20 +389,20 @@ describe('Context', () => {
     });
   });
 
-  describe('focusable', function () {
-    it('should default to true', function () {
+  describe('focusable', () => {
+    it('should default to true', () => {
       const result = new Context();
       assert.isTrue(result.focusable);
     });
 
-    it('should use passed in value', function () {
+    it('should use passed in value', () => {
       const result = new Context({
         focusable: false
       });
       assert.isFalse(result.focusable);
     });
 
-    it('should reject bad values', function () {
+    it('should reject bad values', () => {
       const result = new Context({
         focusable: 'hello'
       });
@@ -399,13 +410,13 @@ describe('Context', () => {
     });
   });
 
-  describe('size', function () {
-    it('should default to empty object', function () {
+  describe('size', () => {
+    it('should default to empty object', () => {
       const result = new Context();
       assert.deepEqual(result.size, {});
     });
 
-    it('should use passed in value', function () {
+    it('should use passed in value', () => {
       const result = new Context({
         size: {
           width: 10,
@@ -418,7 +429,7 @@ describe('Context', () => {
       });
     });
 
-    it('should reject bad values', function () {
+    it('should reject bad values', () => {
       const result = new Context({
         size: 'hello'
       });
@@ -426,10 +437,10 @@ describe('Context', () => {
     });
   });
 
-  describe('frames', function () {
+  describe('frames', () => {
     function iframeReady(src, context, id, cb, done) {
       const iframe = document.createElement('iframe');
-      iframe.addEventListener('load', function () {
+      iframe.addEventListener('load', () => {
         try {
           cb(iframe);
           done();
@@ -448,7 +459,7 @@ describe('Context', () => {
         '../mock/frames/context.html',
         $id('outer'),
         'target',
-        function () {
+        () => {
           const result = new Context('#target');
           assert.lengthOf(result.frames, 1);
           assert.deepEqual(result.frames[0].node, $id('target'));
@@ -463,7 +474,7 @@ describe('Context', () => {
         '../mock/frames/context.html',
         $id('outer'),
         'target',
-        function () {
+        () => {
           const result = new Context('#outer');
           assert.lengthOf(result.frames, 1);
           assert.deepEqual(result.frames[0].node, $id('target'));
@@ -478,7 +489,7 @@ describe('Context', () => {
         '../mock/frames/context.html',
         $id('outer'),
         'target',
-        function () {
+        () => {
           const result = new Context([['#target', '#foo']]);
           assert.lengthOf(result.frames, 1);
 
@@ -496,7 +507,7 @@ describe('Context', () => {
         '../mock/frames/context.html',
         $id('outer'),
         'target',
-        function () {
+        () => {
           const result = new Context({
             exclude: [['#target', '#foo']]
           });
@@ -515,7 +526,7 @@ describe('Context', () => {
         '../mock/frames/context.html',
         $id('fixture'),
         'target',
-        function () {
+        () => {
           const result = new Context();
           assert.isTrue(result.initiator);
           assert.lengthOf(result.frames, 1);
@@ -525,13 +536,62 @@ describe('Context', () => {
       );
     });
 
-    describe('.page', function () {
+    it('finds frames inside shadow DOM trees', () => {
+      createNestedShadowDom(
+        fixture,
+        '<article id="shadowHost"></article>',
+        '<iframe id="target" srcdoc="<h1>My iframe page</h1>"></iframe>'
+      );
+      const result = new Context();
+      assert.equal(result.frames[0].node.id, 'target');
+    });
+
+    it('accepts frames inside shadow DOM selectors', () => {
+      createNestedShadowDom(
+        fixture,
+        '<article id="shadowHost"></article>',
+        '<div><section id="shadowHost"></section></div>',
+        '<iframe id="target" srcdoc="<h1>My iframe page</h1>"></iframe>'
+      );
+      const result = new Context([
+        [['#fixture > article', 'section', 'iframe'], ['h1']]
+      ]);
+      assert.equal(result.frames[0].node.id, 'target');
+    });
+
+    it('skips frames excluded with shadow DOM selectors', () => {
+      createNestedShadowDom(
+        fixture,
+        '<article id="shadowHost"></article>',
+        '<div><section id="shadowHost"></section></div>',
+        '<iframe id="target" srcdoc="<h1>My iframe page</h1>"></iframe>'
+      );
+      const result = new Context({
+        exclude: [[['#fixture > article', 'section', 'iframe']]]
+      });
+      assert.isEmpty(result.frames);
+    });
+
+    it('skips frames in excluded shadow trees', () => {
+      createNestedShadowDom(
+        fixture,
+        '<article id="shadowHost"></article>',
+        '<div><section id="shadowHost"></section></div>',
+        '<iframe id="target" srcdoc="<h1>My iframe page</h1>"></iframe>'
+      );
+      const result = new Context({
+        exclude: [[['#fixture > article', 'section']]]
+      });
+      assert.isEmpty(result.frames);
+    });
+
+    describe('.page', () => {
       it('is true if context includes the document element', function (done) {
         iframeReady(
           '../mock/frames/context.html',
           $id('fixture'),
           'target',
-          function () {
+          () => {
             const result = new Context({
               exclude: [['#mocha']]
             });
@@ -547,7 +607,7 @@ describe('Context', () => {
           '../mock/frames/context.html',
           $id('fixture'),
           'target',
-          function () {
+          () => {
             const result = new Context({
               include: [['#fixture']]
             });
@@ -559,7 +619,7 @@ describe('Context', () => {
       });
     });
 
-    describe('.focusable', function () {
+    describe('.focusable', () => {
       it('is true if tabindex is 0', function (done) {
         iframeReady(
           '../mock/frames/context.html',
@@ -595,7 +655,7 @@ describe('Context', () => {
           '../mock/frames/context.html',
           $id('fixture'),
           'target',
-          function () {
+          () => {
             const result = new Context({
               include: [['#fixture']],
               focusable: false
@@ -608,7 +668,7 @@ describe('Context', () => {
       });
     });
 
-    describe('.size', function () {
+    describe('.size', () => {
       it('sets width and height of the frame', function (done) {
         iframeReady(
           '../mock/frames/context.html',
@@ -649,7 +709,7 @@ describe('Context', () => {
         '../mock/frames/context.html',
         $id('outer'),
         'target',
-        function () {
+        () => {
           const result = new Context([
             ['#target', '#foo'],
             ['#target', '#bar']
@@ -670,7 +730,7 @@ describe('Context', () => {
         '../mock/frames/context.html',
         $id('outer'),
         'target',
-        function () {
+        () => {
           const result = new Context([$id('target'), $id('target')]);
           assert.lengthOf(result.frames, 1);
           assert.deepEqual(result.frames[0].node, $id('target'));
@@ -685,7 +745,7 @@ describe('Context', () => {
         '../mock/frames/context.html',
         $id('outer'),
         'target',
-        function () {
+        () => {
           const frame = $id('target');
           frame.setAttribute('hidden', 'hidden');
 
@@ -702,13 +762,298 @@ describe('Context', () => {
         '../mock/frames/context.html',
         $id('outer'),
         'target',
-        function () {
+        () => {
           assert.throws(function () {
-            const ctxt = new Context(['#notAFrame', '#foo']);
+            new Context(['#notAFrame', '#foo']);
           });
         },
         done
       );
     });
   });
+
+  describe('with labelled fame selectors', () => {
+    it('accepts a single labelled selector', () => {
+      fixture.innerHTML = '<div id="foo"></div>';
+      const result = new Context({
+        fromFrames: ['#foo']
+      });
+      assert.deepEqual(selectors(result.include), ['#foo']);
+      assert.isEmpty(result.exclude);
+    });
+
+    it('accepts multiple labelled selectors', () => {
+      fixture.innerHTML = '<div id="foo"></div><div id="bar"></div>';
+      const result = new Context([
+        { fromFrames: ['#foo'] },
+        { fromFrames: ['#bar'] }
+      ]);
+      assert.deepEqual(selectors(result.include), ['#foo', '#bar']);
+      assert.isEmpty(result.exclude);
+    });
+
+    it('accepts labelled selectors on include & exclude', () => {
+      fixture.innerHTML = '<div id="foo"></div><div id="bar"></div>';
+      const result = new Context({
+        include: [{ fromFrames: ['#foo'] }],
+        exclude: { fromFrames: ['#bar'] }
+      });
+      assert.deepEqual(selectors(result.include), ['#foo']);
+      assert.deepEqual(selectors(result.exclude), ['#bar']);
+    });
+
+    it('throws when not passed an array', () => {
+      assert.throws(() => {
+        new Context({ fromFrames: '#fixture' });
+      });
+    });
+
+    it('throws when fromShadowDom is on the same object', () => {
+      assert.throws(() => {
+        new Context({
+          fromFrames: ['#fixture'],
+          fromShadowDom: ['#fixture']
+        });
+      });
+    });
+
+    it('throws when labelled frames are nested', () => {
+      assert.throws(() => {
+        new Context({
+          fromFrames: ['#fixture', { fromFrames: ['#fixture'] }]
+        });
+      });
+    });
+
+    describe('when the selector has length > 1', () => {
+      it('sets the frame, rather than include / exclude', () => {
+        fixture.innerHTML = `<iframe id="foo" srcdoc="
+          <h1>Hello world</h1> <img>
+        "></iframe>`;
+        const result = new Context({
+          include: { fromFrames: ['#foo', 'h1'] },
+          exclude: { fromFrames: ['iframe', 'img'] }
+        });
+        assert.isEmpty(result.include);
+        assert.isEmpty(result.exclude);
+        assert.lengthOf(result.frames, 1);
+      });
+
+      it('creates a context for the frame', () => {
+        fixture.innerHTML = `<iframe id="foo" srcdoc="
+          <h1>Hello world</h1> <img>
+        "></iframe>`;
+        const result = new Context({
+          include: { fromFrames: ['#foo', 'h1'] },
+          exclude: { fromFrames: ['iframe', 'img'] }
+        });
+        const frameContext = result.frames[0];
+        assert.lengthOf(result.frames, 1);
+        assert.deepEqual(frameContext.include, [['h1']]);
+        assert.deepEqual(frameContext.exclude, [['img']]);
+      });
+    });
+  });
+
+  describe('with labelled shadow DOM selectors', () => {
+    it('accepts a single labelled selector', () => {
+      createNestedShadowDom(
+        fixture,
+        '<article id="shadowHost"></article>',
+        '<div><section id="shadowHost"></section></div>',
+        '<h1 id="foo">Heading</h1>'
+      );
+      const result = new Context({
+        fromShadowDom: ['#fixture > article', 'section', 'h1']
+      });
+      assert.deepEqual(selectors(result.include), ['#foo']);
+      assert.isEmpty(result.exclude);
+      assert.isEmpty(result.frames);
+    });
+
+    it('accepts multiple labelled selectors', () => {
+      createNestedShadowDom(
+        fixture,
+        '<article id="shadowHost"></article>',
+        '<div><section id="shadowHost"></section></div>',
+        '<div id="foo"></div><div id="bar"></div>'
+      );
+      const result = new Context([
+        { fromShadowDom: ['#fixture > article', 'section', '#foo'] },
+        { fromShadowDom: ['#fixture > article', 'section', '#bar'] }
+      ]);
+      assert.deepEqual(selectors(result.include), ['#foo', '#bar']);
+      assert.isEmpty(result.exclude);
+      assert.isEmpty(result.frames);
+    });
+
+    it('accepts labelled selectors on include & exclude', () => {
+      createNestedShadowDom(
+        fixture,
+        '<article id="shadowHost"></article>',
+        '<h1 id="foo"></h1><h2 id="bar"></h2>'
+      );
+      const result = new Context({
+        include: [{ fromShadowDom: ['#fixture > article', 'h1'] }],
+        exclude: { fromShadowDom: ['#fixture > article', 'h2'] }
+      });
+      assert.deepEqual(selectors(result.include), ['#foo']);
+      assert.deepEqual(selectors(result.exclude), ['#bar']);
+    });
+
+    it('throws when fromShadowDom does not contain an array', () => {
+      fixture.innerHTML = '<h1>Hello World</h1>';
+      assert.throws(() => {
+        new Context({ fromShadowDom: 'h1' });
+      });
+    });
+
+    it('throws when containing a labelled frame selector', () => {
+      createNestedShadowDom(
+        fixture,
+        '<article id="shadowHost"></article>',
+        `<iframe id="foo" srcdoc="
+          <h1>Hello World</h1>
+        "></iframe>`
+      );
+      assert.throws(() => {
+        new Context({
+          fromShadowDom: [
+            '#fixture > article',
+            { fromFrames: ['iframe', 'h1'] }
+          ]
+        });
+      });
+    });
+
+    it('throws when containing another labelled shadow dom selector', () => {
+      createNestedShadowDom(
+        fixture,
+        '<article id="shadowHost"></article>',
+        '<div><section id="shadowHost"></section></div>',
+        '<h1 id="foo">Heading</h1>'
+      );
+      assert.throws(() => {
+        new Context({
+          fromShadowDom: [
+            '#fixture > article',
+            { fromShadowDom: ['section', 'h1'] }
+          ]
+        });
+      });
+    });
+
+    describe('nested in a frame selector', () => {
+      it('works for unlabelled frame selectors', () => {
+        createNestedShadowDom(
+          fixture,
+          '<article id="shadowHost"></article>',
+          `<iframe id="foo" srcdoc="
+            <h1>Hello World</h1>
+          "></iframe>`
+        );
+        const result = new Context([
+          [
+            {
+              fromShadowDom: ['#fixture > article', 'iframe']
+            },
+            ['h1']
+          ]
+        ]);
+
+        const frameNodes = result.frames.map(({ node }) => node);
+        assert.deepEqual(selectors(frameNodes), ['#foo']);
+      });
+
+      it('works for labelled frame selectors', () => {
+        createNestedShadowDom(
+          fixture,
+          '<article id="shadowHost"></article>',
+          `<iframe id="foo" srcdoc="
+            <h1>Hello World</h1>
+          "></iframe>`
+        );
+        const result = new Context({
+          fromFrames: [
+            {
+              fromShadowDom: ['#fixture > article', 'iframe']
+            },
+            ['h1']
+          ]
+        });
+        const frameNodes = result.frames.map(({ node }) => node);
+        assert.deepEqual(selectors(frameNodes), ['#foo']);
+      });
+    });
+  });
+
+  describe('ignores bad values', () => {
+    it('passed directly into include', () => {
+      const result = new Context([null, fixture, false, {}]);
+      assert.deepEqual(selectors(result.include), ['#fixture']);
+      assert.isEmpty(result.exclude);
+    });
+
+    it('in unlabelled frame selectors', () => {
+      fixture.innerHTML = '<article id="foo"></article>';
+      const result = new Context([
+        [null],
+        ['#fixture > article'],
+        [fixture],
+        [false],
+        [{}]
+      ]);
+      assert.deepEqual(selectors(result.include), ['#foo']);
+      assert.isEmpty(result.exclude);
+    });
+
+    it('in labelled frame selectors', () => {
+      fixture.innerHTML = '<article id="foo"></article>';
+      const result = new Context([
+        { fromFrames: [null] },
+        { fromFrames: ['#fixture > article'] },
+        { fromFrames: [fixture] },
+        { fromFrames: [false] },
+        { fromFrames: [{}] }
+      ]);
+      assert.deepEqual(selectors(result.include), ['#foo']);
+      assert.isEmpty(result.exclude);
+    });
+
+    it('in unlabelled shadow DOM selectors', () => {
+      createNestedShadowDom(
+        fixture,
+        '<article id="shadowHost"></article>',
+        '<h1 id="foo"></h1><h2 id="bar"></h2>'
+      );
+      const result = new Context([
+        [['#fixture > article', null]],
+        [['#fixture > article', 'h1']], // Valid
+        [['#fixture > article', ['h2']]],
+        [['#fixture > article', fixture]],
+        [['#fixture > article', false]],
+        [['#fixture > article', {}]]
+      ]);
+      assert.deepEqual(selectors(result.include), ['#foo']);
+      assert.isEmpty(result.exclude);
+    });
+
+    it('in labelled shadow DOM selectors', () => {
+      createNestedShadowDom(
+        fixture,
+        '<article id="shadowHost"></article>',
+        '<h1 id="foo"></h1><h2 id="bar"></h2>'
+      );
+      const result = new Context([
+        { fromShadowDom: ['#fixture > article', null] },
+        { fromShadowDom: ['#fixture > article', 'h1'] }, // valid
+        { fromShadowDom: ['#fixture > article', ['h1']] },
+        { fromShadowDom: ['#fixture > article', fixture] },
+        { fromShadowDom: ['#fixture > article', false] },
+        { fromShadowDom: ['#fixture > article', {}] }
+      ]);
+      assert.deepEqual(selectors(result.include), ['#foo']);
+      assert.isEmpty(result.exclude);
+    });
+  });
 });
diff --git a/test/core/public/run-virtual-rule.js b/test/core/public/run-virtual-rule.js
index bc69eb0489..8ceda376a7 100644
--- a/test/core/public/run-virtual-rule.js
+++ b/test/core/public/run-virtual-rule.js
@@ -89,25 +89,51 @@ describe('axe.runVirtualRule', function () {
     assert.isTrue(called);
   });
 
-  it('should pass a virtual context to rule.runSync', function () {
-    var node = new axe.SerialVirtualNode({ nodeName: 'div' });
-    axe._audit.rules = [
-      {
-        id: 'aria-roles',
-        runSync: function (context) {
-          assert.equal(typeof context, 'object');
-          assert.isTrue(Array.isArray(context.include));
-          assert.equal(context.include[0], node);
-
-          return {
-            id: 'aria-roles',
-            nodes: []
-          };
+  describe('context', () => {
+    const { Context } = axe._thisWillBeDeletedDoNotUse.base;
+    it('passes context with vNode included to rule.runSync', function () {
+      var node = new axe.SerialVirtualNode({ nodeName: 'div' });
+      axe._audit.rules = [
+        {
+          id: 'aria-roles',
+          runSync: function (context) {
+            assert.equal(typeof context, 'object');
+            assert.isTrue(Array.isArray(context.include));
+            assert.equal(context.include[0], node);
+
+            return {
+              id: 'aria-roles',
+              nodes: []
+            };
+          }
         }
-      }
-    ];
+      ];
+
+      axe.runVirtualRule('aria-roles', node);
+    });
 
-    axe.runVirtualRule('aria-roles', node);
+    it('has all properties a normal context has', () => {
+      const contextProps = Object.entries(new Context())
+        .filter(arg => typeof arg[1] !== 'function')
+        .map(([key]) => key)
+        .sort();
+
+      var node = new axe.SerialVirtualNode({ nodeName: 'div' });
+      axe._audit.rules = [
+        {
+          id: 'aria-roles',
+          runSync: function (context) {
+            const virtualContextProps = Object.keys(context).sort();
+            assert.deepEqual(virtualContextProps, contextProps);
+            return {
+              id: 'aria-roles',
+              nodes: []
+            };
+          }
+        }
+      ];
+      axe.runVirtualRule('aria-roles', node);
+    });
   });
 
   it('should pass through options to rule.runSync', function () {
diff --git a/test/core/public/run.js b/test/core/public/run.js
index fd46491e52..39cdd9d433 100644
--- a/test/core/public/run.js
+++ b/test/core/public/run.js
@@ -80,22 +80,46 @@ describe('axe.run', function () {
     });
   });
 
-  it('treats objects with include or exclude as the context object', function (done) {
-    axe._runRules = function (ctxt) {
-      assert.deepEqual(ctxt, { include: '#BoggyB' });
-      done();
-    };
+  describe('identifies context objects', () => {
+    it('based on the include property', done => {
+      axe._runRules = ctxt => {
+        assert.deepEqual(ctxt, { include: '#BoggyB' });
+        done();
+      };
+      axe.run({ include: '#BoggyB' }, noop);
+    });
 
-    axe.run({ include: '#BoggyB' }, noop);
-  });
+    it('based on the exclude property', done => {
+      axe._runRules = ctxt => {
+        assert.deepEqual(ctxt, { exclude: '#BoggyB' });
+        done();
+      };
+      axe.run({ exclude: '#BoggyB' }, noop);
+    });
 
-  it('treats objects with neither include or exclude as the option object', function (done) {
-    axe._runRules = function (ctxt, opt) {
-      assert.deepEqual(opt.HHG, 'hallelujah');
-      done();
-    };
+    it('based on the fromFrames property', done => {
+      axe._runRules = ctxt => {
+        assert.deepEqual(ctxt, { fromFrames: ['#myFrame'] });
+        done();
+      };
+      axe.run({ fromFrames: ['#myFrame'] }, noop);
+    });
 
-    axe.run({ HHG: 'hallelujah' }, noop);
+    it('based on the fromShadowDom property', done => {
+      axe._runRules = ctxt => {
+        assert.deepEqual(ctxt, { fromShadowDom: ['#myFrame'] });
+        done();
+      };
+      axe.run({ fromShadowDom: ['#myFrame'] }, noop);
+    });
+
+    it('ignores objects with none of those properties', done => {
+      axe._runRules = (ctxt, opt) => {
+        assert.deepEqual(opt.HHG, 'hallelujah');
+        done();
+      };
+      axe.run({ HHG: 'hallelujah' }, noop);
+    });
   });
 
   it('does not fail if no callback is specified', function (done) {
diff --git a/test/core/utils/contains.js b/test/core/utils/contains.js
index a9d52f80b4..b3ff650fb6 100644
--- a/test/core/utils/contains.js
+++ b/test/core/utils/contains.js
@@ -1,134 +1,146 @@
-describe('axe.utils.contains', function () {
-  'use strict';
+describe('axe.utils.contains', () => {
+  const fixture = document.getElementById('fixture');
+  const { fixtureSetup, createNestedShadowDom } = axe.testUtils;
+
+  it('is true when the first node is an ancestor', () => {
+    const tree = fixtureSetup(`<section> <img> </section>`);
+    const node1 = axe.utils.querySelectorAll(tree, 'section')[0];
+    const node2 = axe.utils.querySelectorAll(tree, 'img')[0];
+    assert.isTrue(axe.utils.contains(node1, node2));
+  });
 
-  var fixture = document.getElementById('fixture');
-  var shadowSupported = axe.testUtils.shadowSupport.v1;
+  it('is false when the first node is a descendant', () => {
+    const tree = fixtureSetup(`<section> <img> </section>`);
+    const node1 = axe.utils.querySelectorAll(tree, 'img')[0];
+    const node2 = axe.utils.querySelectorAll(tree, 'section')[0];
+    assert.isFalse(axe.utils.contains(node1, node2));
+  });
+
+  it('is false when the nodes are siblings', () => {
+    const tree = fixtureSetup(`<section></section> <img>`);
+    const node1 = axe.utils.querySelectorAll(tree, 'img')[0];
+    const node2 = axe.utils.querySelectorAll(tree, 'section')[0];
+    assert.isFalse(axe.utils.contains(node1, node2));
+    assert.isFalse(axe.utils.contains(node2, node1));
+  });
 
-  afterEach(function () {
-    fixture.innerHTML = '';
+  it('is true when the passed the same node', () => {
+    const tree = fixtureSetup(`<img>`);
+    const node = axe.utils.querySelectorAll(tree, 'img')[0];
+    assert.isTrue(axe.utils.contains(node, node));
   });
 
-  it('should first check contains', function () {
-    var success = false,
-      node2 = { actualNode: 'not really a node but it doesnt matter' },
-      node1 = {
+  it('is false when the nodes are cousins', () => {
+    const tree = fixtureSetup(`<section> <input> </section> <img>`);
+    const node1 = axe.utils.querySelectorAll(tree, 'input')[0];
+    const node2 = axe.utils.querySelectorAll(tree, 'img')[0];
+    assert.isFalse(axe.utils.contains(node1, node2));
+    assert.isFalse(axe.utils.contains(node2, node1));
+  });
+
+  describe('using fallbacks', () => {
+    it('should first check DOMNode.contains', () => {
+      let success = false;
+      const node2 = { actualNode: 'not really a node but it doesnt matter' };
+      const node1 = {
         actualNode: {
           contains: function (n2) {
             success = true;
             assert.deepEqual(n2, node2.actualNode);
           },
-          compareDocumentPosition: function () {
+          compareDocumentPosition: () => {
             success = false;
             assert.ok(false, 'should not be called');
           }
         }
       };
 
-    axe.utils.contains(node1, node2);
-    assert.isTrue(success);
-  });
-
-  it('should fallback to compareDocumentPosition', function () {
-    var success = false,
-      node2 = { actualNode: 'not really a node but it doesnt matter' },
-      node1 = {
-        actualNode: {
-          compareDocumentPosition: function (n2) {
-            success = true;
-            assert.deepEqual(n2, node2.actualNode);
-          }
-        }
-      };
-
-    axe.utils.contains(node1, node2);
-    assert.isTrue(success);
-  });
+      axe.utils.contains(node1, node2);
+      assert.isTrue(success);
+    });
 
-  it('should compareDocumentPosition against bitwise & 16', function () {
-    var node2 = { actualNode: 'not really a node but it doesnt matter' },
-      node1 = {
-        actualNode: {
-          compareDocumentPosition: function () {
-            return 20;
-          }
-        }
+    it('should fallback to parent lookup', () => {
+      const node1 = {};
+      const node2 = {
+        parent: node1
       };
-
-    assert.isTrue(axe.utils.contains(node1, node2));
-  });
-
-  it('should fallback to parent lookup', function () {
-    var node1 = {};
-    var node2 = {
-      parent: node1
-    };
-
-    assert.isTrue(axe.utils.contains(node1, node2));
+      assert.isTrue(axe.utils.contains(node1, node2));
+    });
   });
 
-  (shadowSupported ? it : xit)(
-    'should work when the child is inside shadow DOM',
-    function () {
-      var tree, node1, node2;
-
-      function createContentContains() {
-        var group = document.createElement('div');
-        group.innerHTML =
-          '<label id="mylabel">Label</label><input aria-labelledby="mylabel" type="text" />';
-        return group;
-      }
-
-      function makeShadowTreeContains(node) {
-        var root = node.attachShadow({ mode: 'open' });
-        var div = document.createElement('div');
-        div.className = 'parent';
-        root.appendChild(div);
-        div.appendChild(createContentContains());
-      }
-      // shadow DOM v1 - note: v0 is compatible with this code, so no need
-      // to specifically test this
-      fixture.innerHTML = '<div></div>';
-      makeShadowTreeContains(fixture.firstChild);
-      tree = axe.utils.getFlattenedTree(fixture.firstChild);
-      node1 = axe.utils.querySelectorAll(tree, '.parent')[0];
-      node2 = axe.utils.querySelectorAll(tree, 'input')[0];
+  describe('with shadow DOM', () => {
+    it('works when nodes are in the same tree', () => {
+      createNestedShadowDom(
+        fixture,
+        `<div id="shadowHost"></div>`,
+        `<section> <img> </section>`
+      );
+      const tree = axe.setup(fixture);
+      const node1 = axe.utils.querySelectorAll(tree, 'section')[0];
+      const node2 = axe.utils.querySelectorAll(tree, 'img')[0];
       assert.isTrue(axe.utils.contains(node1, node2));
-    }
-  );
-
-  (shadowSupported ? it : xit)(
-    'should work with slotted elements inside shadow DOM',
-    function () {
-      var tree, node1, node2;
-
-      function createContentSlotted() {
-        var group = document.createElement('div');
-        group.innerHTML = '<div id="target">Stuff<slot></slot></div>';
-        return group;
-      }
-      function makeShadowTree(node) {
-        var root = node.attachShadow({ mode: 'open' });
-        var div = document.createElement('div');
-        var a = document.createElement('a');
-        div.appendChild(a);
-        root.appendChild(div);
-        div.appendChild(createContentSlotted());
-      }
-      fixture.innerHTML = '<div></div>';
-      makeShadowTree(fixture.firstChild);
-      tree = axe.utils.getFlattenedTree(fixture.firstChild)[0].children;
-      node1 = axe.utils.querySelectorAll(tree, '#target')[0];
-      node2 = axe.utils.querySelectorAll(tree, 'a')[0];
+      assert.isFalse(axe.utils.contains(node2, node1));
+    });
+
+    it('works when the nodes are in nested trees', () => {
+      createNestedShadowDom(
+        fixture,
+        `<section id="shadowHost"></section>`,
+        `<div> <img> </div>`
+      );
+      const tree = axe.setup(fixture);
+      const node1 = axe.utils.querySelectorAll(tree, 'section')[0];
+      const node2 = axe.utils.querySelectorAll(tree, 'img')[0];
       assert.isTrue(axe.utils.contains(node1, node2));
-    }
-  );
-
-  it('should work', function () {
-    fixture.innerHTML = '<div id="outer"><div id="inner"></div></div>';
-    var inner = axe.utils.getFlattenedTree(document.getElementById('inner'))[0];
-    var outer = axe.utils.getFlattenedTree(document.getElementById('outer'))[0];
+      assert.isFalse(axe.utils.contains(node2, node1));
+    });
+
+    it('works when the nodes are in nested multiple layers deep', () => {
+      createNestedShadowDom(
+        fixture,
+        `<main id="shadowHost"></main>`,
+        '<article> <div id="shadowHost"></div> </article>',
+        '<section> <div id="shadowHost"></div> </section>',
+        `<div> <img> </div>`
+      );
+      const tree = axe.setup(fixture);
+      const node1 = axe.utils.querySelectorAll(tree, 'main')[0];
+      const node2 = axe.utils.querySelectorAll(tree, 'img')[0];
+      assert.isTrue(axe.utils.contains(node1, node2));
+      assert.isFalse(axe.utils.contains(node2, node1));
+    });
+
+    it('is false when the nodes are in adjacent trees', () => {
+      createNestedShadowDom(
+        fixture,
+        '<div id="firstHost" class="shadowHost"></div>',
+        `<img>`
+      );
+      createNestedShadowDom(
+        fixture,
+        '<div id="secondHost" class="shadowHost"></div>',
+        `<input>`
+      );
+      const tree = axe.setup(fixture);
+      const node1 = axe.utils.querySelectorAll(tree, 'img')[0];
+      const node2 = axe.utils.querySelectorAll(tree, 'input')[0];
+
+      assert.isFalse(axe.utils.contains(node1, node2));
+      assert.isFalse(axe.utils.contains(node2, node1));
+    });
+
+    it('works with slotted elements inside shadow DOM', () => {
+      createNestedShadowDom(
+        fixture,
+        `<div id="shadowHost"> <img> </div>`,
+        `<section> <slot /> </section>`
+      );
+      const tree = axe.setup(fixture);
+      const node1 = axe.utils.querySelectorAll(tree, 'section')[0];
+      const node2 = axe.utils.querySelectorAll(tree, 'img')[0];
 
-    assert.isTrue(axe.utils.contains(outer, inner));
-    assert.isFalse(axe.utils.contains(inner, outer));
+      assert.isTrue(axe.utils.contains(node1, node2));
+      assert.isFalse(axe.utils.contains(node2, node1));
+    });
   });
 });
diff --git a/test/core/utils/is-node-in-context.js b/test/core/utils/is-node-in-context.js
new file mode 100644
index 0000000000..0d99f7d94f
--- /dev/null
+++ b/test/core/utils/is-node-in-context.js
@@ -0,0 +1,72 @@
+describe('axe.utils.isNodeInContext', () => {
+  const { queryFixture } = axe.testUtils;
+  const { Context } = axe._thisWillBeDeletedDoNotUse.base;
+  const { isNodeInContext } = axe.utils;
+
+  it('is true when the node is included', () => {
+    const node = queryFixture(
+      `<article> <section> <img id="target"> </section> </article>`
+    );
+    const context = new Context({ include: [['article']] }, axe._tree);
+    assert.isTrue(isNodeInContext(node, context));
+  });
+
+  it('is false when the node is not included', () => {
+    const node = queryFixture(
+      `<article id="target"> <section> <img> </section> </article>`
+    );
+    const context = new Context({ include: [['section']] }, axe._tree);
+    assert.isFalse(isNodeInContext(node, context));
+  });
+
+  describe('when the node is excluded', () => {
+    it('is false when exclude is closer to the node than include', () => {
+      const node = queryFixture(
+        `<main> <article> <section> <img id="target"> </section> </article> </main>`
+      );
+      const context = new Context(
+        {
+          include: [['article']],
+          exclude: [['main'], ['section']]
+        },
+        axe._tree
+      );
+      assert.isFalse(isNodeInContext(node, context));
+    });
+
+    it('is true when include is closer to the node than exclude', () => {
+      const node = queryFixture(
+        `<main> <article> <section> <img id="target"> </section> </article> </main>`
+      );
+      const context = new Context(
+        {
+          include: [['main'], ['section']],
+          exclude: [['article']]
+        },
+        axe._tree
+      );
+      assert.isTrue(isNodeInContext(node, context));
+    });
+  });
+
+  describe('when nodeIndex is undefined', () => {
+    it('is true when the node is included', () => {
+      const node = queryFixture(`<article> <img id="target">  </article>`);
+      delete node.nodeIndex;
+      delete node.parent.nodeIndex;
+      const context = new Context({ include: [['article']] }, axe._tree);
+      assert.isTrue(isNodeInContext(node, context));
+    });
+
+    it('is false when the node is not included', () => {
+      const node = queryFixture(
+        `<article id="target"> <section> <img> </section> </article>`
+      );
+
+      delete node.nodeIndex;
+      delete node.children[0].nodeIndex;
+      const context = new Context({ include: [['section']] }, axe._tree);
+      assert.isFalse(isNodeInContext(node, context));
+    });
+  });
+});
diff --git a/test/core/utils/select.js b/test/core/utils/select.js
index 8d0d9c7559..c5a6a968ef 100644
--- a/test/core/utils/select.js
+++ b/test/core/utils/select.js
@@ -1,157 +1,140 @@
-describe('axe.utils.select', function () {
-  'use strict';
+describe('axe.utils.select', () => {
+  const $id = id => document.getElementById(id);
+  const { Context } = axe._thisWillBeDeletedDoNotUse.base;
+  const { fixtureSetup } = axe.testUtils;
 
-  function $id(id) {
-    return document.getElementById(id);
-  }
-
-  var fixture = document.getElementById('fixture');
-
-  afterEach(function () {
-    fixture.innerHTML = '';
-    axe._selectCache = undefined;
-  });
-
-  it('should be a function', function () {
+  it('should be a function', () => {
     assert.isFunction(axe.utils.select);
   });
 
-  it('should return an array', function () {
+  it('should return an array', () => {
     assert.isArray(axe.utils.select('div', { include: [] }));
   });
 
-  describe('selector', function () {
-    it('should accept a selector', function () {
-      var div = document.createElement('div');
-      div.id = 'monkeys';
-      fixture.appendChild(div);
-
-      var result = axe.utils.select('#monkeys', {
-        include: [axe.utils.getFlattenedTree(document)[0]]
-      });
-
-      assert.equal(result[0].actualNode, div);
+  describe('selector', () => {
+    it('should accept a selector', () => {
+      fixtureSetup('<div id="monkeys"></div>');
+      const context = new Context(document, axe._tree);
+      const result = axe.utils.select('#monkeys', context);
+      assert.equal(result[0].actualNode, $id('monkeys'));
     });
   });
 
-  describe('context', function () {
-    it('should include', function () {
-      fixture.innerHTML =
-        '<div id="monkeys"><div id="bananas" class="bananas"></div></div>';
-
-      var result = axe.utils.select('.bananas', {
-        include: [axe.utils.getFlattenedTree($id('monkeys'))[0]]
-      });
-
-      assert.deepEqual([result[0].actualNode], [$id('bananas')]);
+  describe('context', () => {
+    it('should include', () => {
+      fixtureSetup(
+        '<div id="monkeys"><div id="bananas" class="bananas"></div></div>'
+      );
+      const context = new Context('#monkeys', axe._tree);
+      const result = axe.utils.select('.bananas', context);
+      assert.deepEqual(result[0].actualNode, $id('bananas'));
     });
 
-    it('should exclude', function () {
-      fixture.innerHTML =
-        '<div id="monkeys"><div id="bananas" class="bananas"></div></div>';
-
-      var result = axe.utils.select('.bananas', {
-        include: [axe.utils.getFlattenedTree($id('fixture'))[0]],
-        exclude: [axe.utils.getFlattenedTree($id('monkeys'))[0]]
-      });
-
-      assert.deepEqual(result, []);
+    it('should exclude', () => {
+      fixtureSetup(
+        '<div id="monkeys"><div id="bananas" class="bananas"></div></div>'
+      );
+      const context = new Context(
+        {
+          include: [['#fixture']],
+          exclude: [['#monkeys']]
+        },
+        axe._tree
+      );
+      const result = axe.utils.select('.bananas', context);
+      assert.isEmpty(result);
     });
 
-    it('should pick the deepest exclude/include - exclude winning', function () {
-      fixture.innerHTML =
-        '<div id="include1">' +
-        '	<div id="exclude1">' +
-        '		<div id="include2">' +
-        '			<div id="exclude2">' +
-        '				<div class="bananas"></div>' +
-        '			</div>' +
-        '		</div>' +
-        '	</div>' +
-        '</div>';
-
-      var result = axe.utils.select('.bananas', {
-        include: [
-          axe.utils.getFlattenedTree($id('include1'))[0],
-          axe.utils.getFlattenedTree($id('include2'))[0]
-        ],
-        exclude: [
-          axe.utils.getFlattenedTree($id('exclude1'))[0],
-          axe.utils.getFlattenedTree($id('exclude2'))[0]
-        ]
-      });
-
+    it('should pick the deepest exclude/include - exclude winning', () => {
+      fixtureSetup(
+        `<div id="include1">
+        	<div id="exclude1">
+        		<div id="include2">
+        			<div id="exclude2">
+        				<div class="bananas"></div>
+        			</div>
+        		</div>
+        	</div>
+        </div>`
+      );
+      const context = new Context(
+        {
+          include: [['#include1'], ['#include2']],
+          exclude: [['#exclude1'], ['#exclude2']]
+        },
+        axe._tree
+      );
+      const result = axe.utils.select('.bananas', context);
       assert.deepEqual(result, []);
     });
 
-    it('should pick the deepest exclude/include - include winning', function () {
-      fixture.innerHTML =
-        '<div id="include1">' +
-        '	<div id="exclude1">' +
-        '		<div id="include2">' +
-        '			<div id="exclude2">' +
-        '				<div id="include3">' +
-        '					<div id="bananas" class="bananas"></div>' +
-        '				</div>' +
-        '			</div>' +
-        '		</div>' +
-        '	</div>' +
-        '</div>';
-
-      var result = axe.utils.select('.bananas', {
-        include: [
-          axe.utils.getFlattenedTree($id('include3'))[0],
-          axe.utils.getFlattenedTree($id('include2'))[0],
-          axe.utils.getFlattenedTree($id('include1'))[0]
-        ],
-        exclude: [
-          axe.utils.getFlattenedTree($id('exclude1'))[0],
-          axe.utils.getFlattenedTree($id('exclude2'))[0]
-        ]
-      });
-
-      assert.deepEqual([result[0].actualNode], [$id('bananas')]);
+    it('should pick the deepest exclude/include - include winning', () => {
+      fixtureSetup(
+        `<div id="include1"> 
+        	<div id="exclude1"> 
+        		<div id="include2"> 
+        			<div id="exclude2"> 
+        				<div id="include3"> 
+        					<div id="bananas" class="bananas"></div> 
+        				</div> 
+        			</div> 
+        		</div> 
+        	</div> 
+        </div>`
+      );
+      const context = new Context(
+        {
+          include: [['#include3'], ['#include2'], ['#include1']],
+          exclude: [['#exclude1'], ['#exclude2']]
+        },
+        axe._tree
+      );
+      const result = axe.utils.select('.bananas', context);
+      assert.deepEqual(result[0].actualNode, $id('bananas'));
     });
   });
 
-  it('should only contain unique elements', function () {
-    fixture.innerHTML =
-      '<div id="monkeys"><div id="bananas" class="bananas"></div></div>';
-    var tree = axe.utils.getFlattenedTree($id('fixture'))[0];
-    var monkeys = tree.children[0];
-    var result = axe.utils.select('.bananas', {
-      include: [tree, monkeys]
-    });
+  it('should only contain unique elements', () => {
+    fixtureSetup(
+      '<div id="monkeys"><div id="bananas" class="bananas"></div></div>'
+    );
+    const context = new Context(
+      {
+        include: [['#fixture'], ['#monkeys']]
+      },
+      axe._tree
+    );
 
+    const result = axe.utils.select('.bananas', context);
     assert.lengthOf(result, 1);
     assert.equal(result[0].actualNode, $id('bananas'));
   });
 
-  it('should not return duplicates on overlapping includes', function () {
-    fixture.innerHTML =
+  it('should not return duplicates on overlapping includes', () => {
+    fixtureSetup(
       '<div id="zero"><div id="one"><div id="target1" class="bananas"></div></div>' +
-      '<div id="two"><div id="target2" class="bananas"></div></div></div>';
-
-    var result = axe.utils.select('.bananas', {
-      include: [
-        axe.utils.getFlattenedTree($id('zero'))[0],
-        axe.utils.getFlattenedTree($id('one'))[0]
-      ]
-    });
+        '<div id="two"><div id="target2" class="bananas"></div></div></div>'
+    );
+    const context = new Context(
+      {
+        include: [['#zero'], ['#one']]
+      },
+      axe._tree
+    );
 
+    const result = axe.utils.select('.bananas', context);
     assert.deepEqual(
-      result.map(function (n) {
-        return n.actualNode;
-      }),
+      result.map(n => n.actualNode),
       [$id('target1'), $id('target2')]
     );
     assert.equal(result.length, 2);
   });
 
-  it('should return the cached result if one exists', function () {
-    fixture.innerHTML =
+  it('should return the cached result if one exists', () => {
+    fixtureSetup(
       '<div id="zero"><div id="one"><div id="target1" class="bananas"></div></div>' +
-      '<div id="two"><div id="target2" class="bananas"></div></div></div>';
+        '<div id="two"><div id="target2" class="bananas"></div></div></div>'
+    );
 
     axe._selectCache = [
       {
@@ -159,9 +142,8 @@ describe('axe.utils.select', function () {
         result: 'fruit bat'
       }
     ];
-    var result = axe.utils.select('.bananas', {
-      include: [axe.utils.getFlattenedTree($id('zero'))[0]]
-    });
+    const context = new Context([['#zero']], axe._tree);
+    const result = axe.utils.select('.bananas', context);
     assert.equal(result, 'fruit bat');
   });
 });
diff --git a/test/integration/full/context/frames/shadow-frame.html b/test/integration/full/context/frames/shadow-frame.html
new file mode 100644
index 0000000000..6a1e713830
--- /dev/null
+++ b/test/integration/full/context/frames/shadow-frame.html
@@ -0,0 +1,21 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <title>Shadow frame</title>
+    <script src="/axe.js"></script>
+  </head>
+  <body>
+    <input id="outOfContext3" />
+    <div id="shadowFrameHost">
+      <input id="outOfContext4" />
+    </div>
+    <script>
+      const shadowRoot = shadowFrameHost.attachShadow({ mode: 'open' });
+      shadowRoot.innerHTML = `<main>
+        <div> <input id="fail" value="fail" /> </div>
+        <aside> <input id="outOfContext5" /> </aside>
+      </main>
+      <slot />`;
+    </script>
+  </body>
+</html>
diff --git a/test/integration/full/context/shadow-dom.html b/test/integration/full/context/shadow-dom.html
new file mode 100644
index 0000000000..e3680a788e
--- /dev/null
+++ b/test/integration/full/context/shadow-dom.html
@@ -0,0 +1,41 @@
+<!DOCTYPE html>
+<html lang="en" id="main">
+  <head>
+    <title>frame exclude test</title>
+    <meta charset="utf8" />
+    <link
+      rel="stylesheet"
+      type="text/css"
+      href="/node_modules/mocha/mocha.css"
+    />
+    <script src="/node_modules/mocha/mocha.js"></script>
+    <script src="/node_modules/chai/chai.js"></script>
+    <script src="/axe.js"></script>
+    <script>
+      mocha.setup({
+        timeout: 10000,
+        ui: 'bdd'
+      });
+      const assert = chai.assert;
+    </script>
+  </head>
+  <body>
+    <input id="outOfContext1" />
+    <div id="shadowHost">
+      <input id="outOfContext2" />
+    </div>
+
+    <div id="mocha"></div>
+    <script src="/test/testutils.js"></script>
+    <script>
+      const shadowRoot = shadowHost.attachShadow({ mode: 'open' });
+      shadowRoot.innerHTML = `<iframe id="shadowFrame1" src="frames/shadow-frame.html"></iframe>
+        <iframe id="shadowFrame2" src="frames/shadow-frame.html"></iframe>
+        <br>
+        <slot />`;
+    </script>
+
+    <script src="shadow-dom.js"></script>
+    <script src="/test/integration/adapter.js"></script>
+  </body>
+</html>
diff --git a/test/integration/full/context/shadow-dom.js b/test/integration/full/context/shadow-dom.js
new file mode 100644
index 0000000000..76d953c57f
--- /dev/null
+++ b/test/integration/full/context/shadow-dom.js
@@ -0,0 +1,45 @@
+describe('context test', () => {
+  before(done => {
+    axe.testUtils.awaitNestedLoad(done);
+  });
+
+  it('is able to include & exclude from frames in shadow DOM trees', async () => {
+    const { violations } = await axe.run(
+      {
+        include: [
+          [
+            ['#shadowHost', '#shadowFrame1'],
+            ['#shadowFrameHost', 'main']
+          ],
+          [
+            ['#shadowHost', '#shadowFrame2'],
+            ['#shadowFrameHost', 'main']
+          ]
+        ],
+        exclude: [
+          [
+            ['#shadowHost', '#shadowFrame1'],
+            ['#shadowFrameHost', 'main aside']
+          ],
+          [
+            ['#shadowHost', '#shadowFrame2'],
+            ['#shadowFrameHost', 'main aside']
+          ]
+        ]
+      },
+      { runOnly: 'label' }
+    );
+
+    const targets = violations[0].nodes.map(({ target }) => target);
+    assert.deepEqual(targets, [
+      [
+        ['#shadowHost', '#shadowFrame1'],
+        ['#shadowFrameHost', '#fail']
+      ],
+      [
+        ['#shadowHost', '#shadowFrame2'],
+        ['#shadowFrameHost', '#fail']
+      ]
+    ]);
+  });
+});
diff --git a/test/testutils.js b/test/testutils.js
index 3c19aaff2b..cf935ed650 100644
--- a/test/testutils.js
+++ b/test/testutils.js
@@ -634,3 +634,33 @@ testUtils.shadowQuerySelector = function shadowQuerySelector(axeSelector, doc) {
   });
   return elm;
 };
+
+testUtils.createNestedShadowDom = function createFixtureShadowTree(
+  fixture,
+  ...htmlCodes
+) {
+  if (htmlCodes.length <= 1) {
+    throw new Error(
+      'createNestedShadowDom must contain at least two HTML snippets'
+    );
+  }
+  let htmlCode;
+  while ((htmlCode = htmlCodes.shift())) {
+    appendHtml(fixture, htmlCode);
+    if (htmlCodes.length) {
+      const query = fixture.querySelectorAll('#shadowHost, .shadowHost');
+      fixture = query[query.length - 1];
+      fixture = fixture.attachShadow({ mode: 'open' });
+    }
+  }
+  return fixture.querySelector('#target');
+};
+
+function appendHtml(fixture, htmlCode) {
+  const tmp = document.createElement('div');
+  tmp.innerHTML = htmlCode;
+  // Append to avoid clobbering other shadow trees with innerHTML
+  for (const child of tmp.children) {
+    fixture.appendChild(child.cloneNode(true));
+  }
+}
diff --git a/typings/axe-core/axe-core-tests.ts b/typings/axe-core/axe-core-tests.ts
index 1ef3d0db60..d323aff4bd 100644
--- a/typings/axe-core/axe-core-tests.ts
+++ b/typings/axe-core/axe-core-tests.ts
@@ -29,6 +29,43 @@ axe.run(
     console.log(error || results);
   }
 );
+export async function runAsync() {
+  await axe.run('main'); // Single selector
+  await axe.run(['main']); // Array of one selector
+  await axe.run([['main']]); // Selecting in the outer frame
+  // @ts-expect-error // Shadow DOM selectors must be at least 2 items long
+  await axe.run([[['main']]]);
+  await axe.run([[['#app', 'main']]]); // Selecting in the outer frame
+
+  await axe.run(document.querySelector('main'));
+  await axe.run(document.querySelectorAll('main'));
+  // axe.run with frameContext context
+  await axe.run({ fromShadowDom: ['#app', '#main', '#inner'] });
+  // @ts-expect-error // Must be two long:
+  await axe.run({ fromShadowDom: ['#app'] });
+  // @ts-expect-error // Must be two long:
+  await axe.run({ fromFrames: ['#app'] });
+  // axe.run with fromFrames context
+  await axe.run({
+    fromFrames: ['#frame', { fromShadowDom: ['#app', '#main'] }]
+  });
+  // Mixed type array
+  await axe.run([
+    'main',
+    document.head,
+    { fromShadowDom: ['#app', '#header', '#search'] },
+    { fromFrames: ['#frame', '#main'] }
+  ]);
+  // Combined fromFrames & fromContext
+  await axe.run({
+    include: { fromShadowDom: ['#frame', '#main'] },
+    exclude: [
+      'footer',
+      document.head,
+      { fromFrames: ['#frame', { fromShadowDom: ['#app', '#main'] }] }
+    ]
+  });
+}
 axe.run(
   { exclude: [$fixture[0]] },
   {},