Backed out 2 changesets (bug 1535362) for causing merge conflicts. a=backout
authorDaniel Varga <dvarga@mozilla.com>
Wed, 03 Apr 2019 09:04:17 +0300
changeset 467667 eb21297f31590fc47581036327df9779a534875c
parent 467666 52636fd2ce17ba27346db56337dda4fcce3f409d
child 467668 6188f34970576cf032692bc8679eca89607dfe34
push id35807
push userdvarga@mozilla.com
push dateWed, 03 Apr 2019 06:06:32 +0000
treeherdermozilla-central@6188f3497057 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersbackout
bugs1535362
milestone68.0a1
backs out52636fd2ce17ba27346db56337dda4fcce3f409d
d363668ebdaa772feed5c3392fed60432789458f
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Backed out 2 changesets (bug 1535362) for causing merge conflicts. a=backout Backed out changeset 52636fd2ce17 (bug 1535362) Backed out changeset d363668ebdaa (bug 1535362)
devtools/client/debugger/new/panel.js
devtools/client/debugger/new/src/actions/ast.js
devtools/client/debugger/new/src/actions/ast/setInScopeLines.js
devtools/client/debugger/new/src/actions/breakpoints/breakpointPositions.js
devtools/client/debugger/new/src/actions/breakpoints/index.js
devtools/client/debugger/new/src/actions/breakpoints/modify.js
devtools/client/debugger/new/src/actions/breakpoints/syncBreakpoint.js
devtools/client/debugger/new/src/actions/breakpoints/tests/breakpointPositions.spec.js
devtools/client/debugger/new/src/actions/breakpoints/tests/breakpoints.spec.js
devtools/client/debugger/new/src/actions/debuggee.js
devtools/client/debugger/new/src/actions/expressions.js
devtools/client/debugger/new/src/actions/file-search.js
devtools/client/debugger/new/src/actions/pause/breakOnNext.js
devtools/client/debugger/new/src/actions/pause/commands.js
devtools/client/debugger/new/src/actions/pause/continueToHere.js
devtools/client/debugger/new/src/actions/pause/fetchScopes.js
devtools/client/debugger/new/src/actions/pause/mapFrames.js
devtools/client/debugger/new/src/actions/pause/mapScopes.js
devtools/client/debugger/new/src/actions/pause/paused.js
devtools/client/debugger/new/src/actions/pause/resumed.js
devtools/client/debugger/new/src/actions/pause/selectFrame.js
devtools/client/debugger/new/src/actions/pause/setPopupObjectProperties.js
devtools/client/debugger/new/src/actions/pause/tests/pause.spec.js
devtools/client/debugger/new/src/actions/preview.js
devtools/client/debugger/new/src/actions/project-text-search.js
devtools/client/debugger/new/src/actions/source-tree.js
devtools/client/debugger/new/src/actions/sources/blackbox.js
devtools/client/debugger/new/src/actions/sources/loadSourceText.js
devtools/client/debugger/new/src/actions/sources/newSources.js
devtools/client/debugger/new/src/actions/sources/prettyPrint.js
devtools/client/debugger/new/src/actions/sources/select.js
devtools/client/debugger/new/src/actions/sources/symbols.js
devtools/client/debugger/new/src/actions/sources/tests/blackbox.spec.js
devtools/client/debugger/new/src/actions/sources/tests/loadSource.spec.js
devtools/client/debugger/new/src/actions/sources/tests/newSources.spec.js
devtools/client/debugger/new/src/actions/sources/tests/prettyPrint.spec.js
devtools/client/debugger/new/src/actions/sources/tests/select.spec.js
devtools/client/debugger/new/src/actions/tabs.js
devtools/client/debugger/new/src/actions/tests/ast.spec.js
devtools/client/debugger/new/src/actions/tests/expressions.spec.js
devtools/client/debugger/new/src/actions/tests/file-search.spec.js
devtools/client/debugger/new/src/actions/tests/navigation.spec.js
devtools/client/debugger/new/src/actions/tests/pending-breakpoints.spec.js
devtools/client/debugger/new/src/actions/tests/project-text-search.spec.js
devtools/client/debugger/new/src/actions/tests/setProjectDirectoryRoot.spec.js
devtools/client/debugger/new/src/actions/tests/tabs.spec.js
devtools/client/debugger/new/src/actions/tests/ui.spec.js
devtools/client/debugger/new/src/actions/types/ASTAction.js
devtools/client/debugger/new/src/actions/types/BreakpointAction.js
devtools/client/debugger/new/src/actions/types/PauseAction.js
devtools/client/debugger/new/src/actions/types/SourceAction.js
devtools/client/debugger/new/src/actions/types/UIAction.js
devtools/client/debugger/new/src/actions/types/index.js
devtools/client/debugger/new/src/actions/ui.js
devtools/client/debugger/new/src/actions/utils/create-store.js
devtools/client/debugger/new/src/actions/utils/middleware/context.js
devtools/client/debugger/new/src/actions/utils/middleware/moz.build
devtools/client/debugger/new/src/components/Editor/Breakpoint.js
devtools/client/debugger/new/src/components/Editor/Breakpoints.js
devtools/client/debugger/new/src/components/Editor/ColumnBreakpoint.js
devtools/client/debugger/new/src/components/Editor/ColumnBreakpoints.js
devtools/client/debugger/new/src/components/Editor/ConditionalPanel.js
devtools/client/debugger/new/src/components/Editor/EditorMenu.js
devtools/client/debugger/new/src/components/Editor/Footer.js
devtools/client/debugger/new/src/components/Editor/Preview/Popup.js
devtools/client/debugger/new/src/components/Editor/Preview/index.js
devtools/client/debugger/new/src/components/Editor/SearchBar.js
devtools/client/debugger/new/src/components/Editor/Tab.js
devtools/client/debugger/new/src/components/Editor/Tabs.js
devtools/client/debugger/new/src/components/Editor/index.js
devtools/client/debugger/new/src/components/Editor/menus/breakpoints.js
devtools/client/debugger/new/src/components/Editor/menus/editor.js
devtools/client/debugger/new/src/components/Editor/tests/SearchBar.spec.js
devtools/client/debugger/new/src/components/PrimaryPanes/Outline.js
devtools/client/debugger/new/src/components/PrimaryPanes/SourcesTree.js
devtools/client/debugger/new/src/components/PrimaryPanes/SourcesTreeItem.js
devtools/client/debugger/new/src/components/PrimaryPanes/index.js
devtools/client/debugger/new/src/components/PrimaryPanes/tests/SourcesTree.spec.js
devtools/client/debugger/new/src/components/ProjectSearch.js
devtools/client/debugger/new/src/components/QuickOpenModal.js
devtools/client/debugger/new/src/components/SecondaryPanes/Breakpoints/Breakpoint.js
devtools/client/debugger/new/src/components/SecondaryPanes/Breakpoints/BreakpointHeading.js
devtools/client/debugger/new/src/components/SecondaryPanes/Breakpoints/BreakpointHeadingsContextMenu.js
devtools/client/debugger/new/src/components/SecondaryPanes/Breakpoints/BreakpointsContextMenu.js
devtools/client/debugger/new/src/components/SecondaryPanes/Breakpoints/tests/BreakpointsContextMenu.spec.js
devtools/client/debugger/new/src/components/SecondaryPanes/CommandBar.js
devtools/client/debugger/new/src/components/SecondaryPanes/Expressions.js
devtools/client/debugger/new/src/components/SecondaryPanes/Frames/Frame.js
devtools/client/debugger/new/src/components/SecondaryPanes/Frames/Group.js
devtools/client/debugger/new/src/components/SecondaryPanes/Frames/index.js
devtools/client/debugger/new/src/components/SecondaryPanes/Frames/tests/Frame.spec.js
devtools/client/debugger/new/src/components/SecondaryPanes/Frames/tests/Group.spec.js
devtools/client/debugger/new/src/components/SecondaryPanes/Frames/tests/__snapshots__/Group.spec.js.snap
devtools/client/debugger/new/src/components/SecondaryPanes/Worker.js
devtools/client/debugger/new/src/components/SecondaryPanes/index.js
devtools/client/debugger/new/src/components/SecondaryPanes/tests/CommandBar.spec.js
devtools/client/debugger/new/src/components/test/Outline.spec.js
devtools/client/debugger/new/src/components/test/ProjectSearch.spec.js
devtools/client/debugger/new/src/components/test/QuickOpenModal.spec.js
devtools/client/debugger/new/src/components/test/__snapshots__/ProjectSearch.spec.js.snap
devtools/client/debugger/new/src/components/test/__snapshots__/QuickOpenModal.spec.js.snap
devtools/client/debugger/new/src/reducers/pause.js
devtools/client/debugger/new/src/reducers/sources.js
devtools/client/debugger/new/src/reducers/tests/sources.spec.js
devtools/client/debugger/new/src/types.js
devtools/client/debugger/new/src/utils/context.js
devtools/client/debugger/new/src/utils/moz.build
devtools/client/debugger/new/src/utils/test-head.js
devtools/client/debugger/new/src/utils/test-mockup.js
devtools/client/debugger/new/test/mochitest/browser_dbg-inline-cache.js
devtools/client/debugger/new/test/mochitest/browser_dbg-log-points.js
devtools/client/debugger/new/test/mochitest/browser_dbg-pause-points.js
devtools/client/debugger/new/test/mochitest/browser_dbg-preview-source-maps.js
devtools/client/debugger/new/test/mochitest/browser_dbg-sourcemaps.js
devtools/client/debugger/new/test/mochitest/browser_dbg-stepping.js
devtools/client/debugger/new/test/mochitest/browser_dbg-tabs-pretty-print.js
devtools/client/debugger/new/test/mochitest/browser_dbg-tabs.js
devtools/client/debugger/new/test/mochitest/browser_dbg-windowless-workers.js
devtools/client/debugger/new/test/mochitest/helpers.js
devtools/client/shared/components/SmartTrace.js
devtools/client/webconsole/test/mochitest/browser_webconsole_eval_in_debugger_stackframe2.js
devtools/client/webconsole/test/mochitest/head.js
devtools/client/webreplay/mochitest/browser_dbg_rr_logpoint-02.js
devtools/client/webreplay/mochitest/head.js
testing/talos/talos/tests/devtools/addon/content/tests/debugger/debugger-helpers.js
--- a/devtools/client/debugger/new/panel.js
+++ b/devtools/client/debugger/new/panel.js
@@ -129,23 +129,21 @@ DebuggerPanel.prototype = {
   },
 
   isPaused() {
     const thread = this._selectors.getCurrentThread(this._getState());
     return this._selectors.getIsPaused(this._getState(), thread);
   },
 
   selectSourceURL(url, line, column) {
-    const cx = this._selectors.getContext(this._getState());
-    return this._actions.selectSourceURL(cx, url, { line, column });
+    return this._actions.selectSourceURL(url, { line, column });
   },
 
   selectSource(sourceId, line, column) {
-    const cx = this._selectors.getContext(this._getState());
-    return this._actions.selectSource(cx, sourceId, { line, column });
+    return this._actions.selectSource(sourceId, { line, column });
   },
 
   getSourceByActorId(sourceId) {
     return this._selectors.getSourceByActorId(this._getState(), sourceId);
   },
 
   getSourceByURL(sourceURL) {
     return this._selectors.getSourceByURL(this._getState(), sourceURL);
--- a/devtools/client/debugger/new/src/actions/ast.js
+++ b/devtools/client/debugger/new/src/actions/ast.js
@@ -7,20 +7,19 @@
 import { getSourceFromId, getSelectedLocation } from "../selectors";
 
 import { setInScopeLines } from "./ast/setInScopeLines";
 
 import * as parser from "../workers/parser";
 
 import { isLoaded } from "../utils/source";
 
-import type { Context } from "../types";
 import type { ThunkArgs, Action } from "./types";
 
-export function setOutOfScopeLocations(cx: Context) {
+export function setOutOfScopeLocations() {
   return async ({ dispatch, getState }: ThunkArgs) => {
     const location = getSelectedLocation(getState());
     if (!location) {
       return;
     }
 
     const source = getSourceFromId(getState(), location.sourceId);
 
@@ -34,15 +33,14 @@ export function setOutOfScopeLocations(c
         source.id,
         ((location: any): parser.AstPosition)
       );
     }
 
     dispatch(
       ({
         type: "OUT_OF_SCOPE_LOCATIONS",
-        cx,
         locations
       }: Action)
     );
-    dispatch(setInScopeLines(cx));
+    dispatch(setInScopeLines());
   };
 }
--- a/devtools/client/debugger/new/src/actions/ast/setInScopeLines.js
+++ b/devtools/client/debugger/new/src/actions/ast/setInScopeLines.js
@@ -6,31 +6,30 @@
 
 import { getOutOfScopeLocations, getSelectedSource } from "../../selectors";
 import { getSourceLineCount } from "../../utils/source";
 
 import { range, flatMap, uniq, without } from "lodash";
 
 import type { AstLocation } from "../../workers/parser";
 import type { ThunkArgs } from "../types";
-import type { Context } from "../../types";
 
 function getOutOfScopeLines(outOfScopeLocations: ?(AstLocation[])) {
   if (!outOfScopeLocations) {
     return null;
   }
 
   return uniq(
     flatMap(outOfScopeLocations, location =>
       range(location.start.line, location.end.line)
     )
   );
 }
 
-export function setInScopeLines(cx: Context) {
+export function setInScopeLines() {
   return ({ dispatch, getState }: ThunkArgs) => {
     const source = getSelectedSource(getState());
     const outOfScopeLocations = getOutOfScopeLocations(getState());
 
     if (!source || !source.text) {
       return;
     }
 
@@ -40,13 +39,12 @@ export function setInScopeLines(cx: Cont
     const sourceLines = range(1, sourceNumLines + 1);
 
     const inScopeLines = !linesOutOfScope
       ? sourceLines
       : without(sourceLines, ...linesOutOfScope);
 
     dispatch({
       type: "IN_SCOPE_LINES",
-      cx,
       lines: inScopeLines
     });
   };
 }
--- a/devtools/client/debugger/new/src/actions/breakpoints/breakpointPositions.js
+++ b/devtools/client/debugger/new/src/actions/breakpoints/breakpointPositions.js
@@ -9,17 +9,17 @@ import { uniqBy, zip } from "lodash";
 
 import {
   getSource,
   getSourceFromId,
   hasBreakpointPositions,
   getBreakpointPositionsForSource
 } from "../../selectors";
 
-import type { MappedLocation, SourceLocation, Context } from "../../types";
+import type { MappedLocation, SourceLocation } from "../../types";
 import type { ThunkArgs } from "../../actions/types";
 import { makeBreakpointId } from "../../utils/breakpoint";
 import typeof SourceMaps from "../../../packages/devtools-source-map/src";
 
 const requests = new Map();
 
 async function mapLocations(
   generatedLocations: SourceLocation[],
@@ -59,17 +59,17 @@ function convertToList(results, source) 
         sourceUrl: url
       });
     }
   }
 
   return positions;
 }
 
-async function _setBreakpointPositions(cx, sourceId, thunkArgs) {
+async function _setBreakpointPositions(sourceId, thunkArgs) {
   const { client, dispatch, getState, sourceMaps } = thunkArgs;
   let generatedSource = getSource(getState(), sourceId);
   if (!generatedSource) {
     return;
   }
 
   let results = {};
   if (isOriginalId(sourceId)) {
@@ -110,17 +110,16 @@ async function _setBreakpointPositions(c
 
   const source = getSource(getState(), sourceId);
   // NOTE: it's possible that the source was removed during a navigate
   if (!source) {
     return;
   }
   dispatch({
     type: "ADD_BREAKPOINT_POSITIONS",
-    cx,
     source: source,
     positions
   });
 }
 
 function buildCacheKey(sourceId: string, thunkArgs: ThunkArgs): string {
   const generatedSource = getSource(
     thunkArgs.getState(),
@@ -132,31 +131,31 @@ function buildCacheKey(sourceId: string,
   if (generatedSource) {
     for (const actor of generatedSource.actors) {
       key += `:${actor.actor}`;
     }
   }
   return key;
 }
 
-export function setBreakpointPositions(cx: Context, sourceId: string) {
+export function setBreakpointPositions(sourceId: string) {
   return async (thunkArgs: ThunkArgs) => {
     const { getState } = thunkArgs;
     if (hasBreakpointPositions(getState(), sourceId)) {
       return getBreakpointPositionsForSource(getState(), sourceId);
     }
 
     const cacheKey = buildCacheKey(sourceId, thunkArgs);
 
     if (!requests.has(cacheKey)) {
       requests.set(
         cacheKey,
         (async () => {
           try {
-            await _setBreakpointPositions(cx, sourceId, thunkArgs);
+            await _setBreakpointPositions(sourceId, thunkArgs);
           } catch (e) {
             // TODO: Address exceptions originating from 1536618
             // `Debugger.Source belongs to a different Debugger`
           } finally {
             requests.delete(cacheKey);
           }
         })()
       );
--- a/devtools/client/debugger/new/src/actions/breakpoints/index.js
+++ b/devtools/client/debugger/new/src/actions/breakpoints/index.js
@@ -32,183 +32,173 @@ import { closeConditionalPanel } from ".
 
 // this will need to be changed so that addCLientBreakpoint is removed
 
 import type { ThunkArgs } from "../types";
 import type {
   Breakpoint,
   Source,
   SourceLocation,
-  XHRBreakpoint,
-  Context
+  XHRBreakpoint
 } from "../../types";
 
 export * from "./breakpointPositions";
 export * from "./modify";
 export * from "./syncBreakpoint";
 
-export function addHiddenBreakpoint(cx: Context, location: SourceLocation) {
+export function addHiddenBreakpoint(location: SourceLocation) {
   return ({ dispatch }: ThunkArgs) => {
-    return dispatch(addBreakpoint(cx, location, { hidden: true }));
+    return dispatch(addBreakpoint(location, { hidden: true }));
   };
 }
 
 /**
  * Disable all breakpoints in a source
  *
  * @memberof actions/breakpoints
  * @static
  */
-export function disableBreakpointsInSource(cx: Context, source: Source) {
+export function disableBreakpointsInSource(source: Source) {
   return async ({ dispatch, getState, client }: ThunkArgs) => {
     const breakpoints = getBreakpointsForSource(getState(), source.id);
     for (const breakpoint of breakpoints) {
       if (!breakpoint.disabled) {
-        dispatch(disableBreakpoint(cx, breakpoint));
+        dispatch(disableBreakpoint(breakpoint));
       }
     }
   };
 }
 
 /**
  * Enable all breakpoints in a source
  *
  * @memberof actions/breakpoints
  * @static
  */
-export function enableBreakpointsInSource(cx: Context, source: Source) {
+export function enableBreakpointsInSource(source: Source) {
   return async ({ dispatch, getState, client }: ThunkArgs) => {
     const breakpoints = getBreakpointsForSource(getState(), source.id);
     for (const breakpoint of breakpoints) {
       if (breakpoint.disabled) {
-        dispatch(enableBreakpoint(cx, breakpoint));
+        dispatch(enableBreakpoint(breakpoint));
       }
     }
   };
 }
 
 /**
  * Toggle All Breakpoints
  *
  * @memberof actions/breakpoints
  * @static
  */
-export function toggleAllBreakpoints(
-  cx: Context,
-  shouldDisableBreakpoints: boolean
-) {
+export function toggleAllBreakpoints(shouldDisableBreakpoints: boolean) {
   return async ({ dispatch, getState, client }: ThunkArgs) => {
     const breakpoints = getBreakpointsList(getState());
 
     for (const breakpoint of breakpoints) {
       if (shouldDisableBreakpoints) {
-        dispatch(disableBreakpoint(cx, breakpoint));
+        dispatch(disableBreakpoint(breakpoint));
       } else {
-        dispatch(enableBreakpoint(cx, breakpoint));
+        dispatch(enableBreakpoint(breakpoint));
       }
     }
   };
 }
 
 /**
  * Toggle Breakpoints
  *
  * @memberof actions/breakpoints
  * @static
  */
 export function toggleBreakpoints(
-  cx: Context,
   shouldDisableBreakpoints: boolean,
   breakpoints: Breakpoint[]
 ) {
   return async ({ dispatch }: ThunkArgs) => {
     const promises = breakpoints.map(
       breakpoint =>
         shouldDisableBreakpoints
-          ? dispatch(disableBreakpoint(cx, breakpoint))
-          : dispatch(enableBreakpoint(cx, breakpoint))
+          ? dispatch(disableBreakpoint(breakpoint))
+          : dispatch(enableBreakpoint(breakpoint))
     );
 
     await Promise.all(promises);
   };
 }
 
 export function toggleBreakpointsAtLine(
-  cx: Context,
   shouldDisableBreakpoints: boolean,
   line: number
 ) {
   return async ({ dispatch, getState }: ThunkArgs) => {
-    const breakpoints = getBreakpointsAtLine(getState(), line);
-    return dispatch(
-      toggleBreakpoints(cx, shouldDisableBreakpoints, breakpoints)
-    );
+    const breakpoints = await getBreakpointsAtLine(getState(), line);
+    return dispatch(toggleBreakpoints(shouldDisableBreakpoints, breakpoints));
   };
 }
 
 /**
  * Removes all breakpoints
  *
  * @memberof actions/breakpoints
  * @static
  */
-export function removeAllBreakpoints(cx: Context) {
+export function removeAllBreakpoints() {
   return async ({ dispatch, getState }: ThunkArgs) => {
     const breakpointList = getBreakpointsList(getState());
     return Promise.all(
-      breakpointList.map(bp => dispatch(removeBreakpoint(cx, bp)))
+      breakpointList.map(bp => dispatch(removeBreakpoint(bp)))
     );
   };
 }
 
 /**
  * Removes breakpoints
  *
  * @memberof actions/breakpoints
  * @static
  */
-export function removeBreakpoints(cx: Context, breakpoints: Breakpoint[]) {
+export function removeBreakpoints(breakpoints: Breakpoint[]) {
   return async ({ dispatch }: ThunkArgs) => {
-    return Promise.all(
-      breakpoints.map(bp => dispatch(removeBreakpoint(cx, bp)))
-    );
+    return Promise.all(breakpoints.map(bp => dispatch(removeBreakpoint(bp))));
   };
 }
 
 /**
  * Removes all breakpoints in a source
  *
  * @memberof actions/breakpoints
  * @static
  */
-export function removeBreakpointsInSource(cx: Context, source: Source) {
+export function removeBreakpointsInSource(source: Source) {
   return async ({ dispatch, getState, client }: ThunkArgs) => {
     const breakpoints = getBreakpointsForSource(getState(), source.id);
     for (const breakpoint of breakpoints) {
-      dispatch(removeBreakpoint(cx, breakpoint));
+      dispatch(removeBreakpoint(breakpoint));
     }
   };
 }
 
-export function remapBreakpoints(cx: Context, sourceId: string) {
+export function remapBreakpoints(sourceId: string) {
   return async ({ dispatch, getState, sourceMaps }: ThunkArgs) => {
     const breakpoints = getBreakpointsList(getState());
     const newBreakpoints = await remapLocations(
       breakpoints,
       sourceId,
       sourceMaps
     );
 
     for (const bp of newBreakpoints) {
-      await dispatch(addBreakpoint(cx, bp.location, bp.options, bp.disabled));
+      await dispatch(addBreakpoint(bp.location, bp.options, bp.disabled));
     }
   };
 }
 
-export function toggleBreakpointAtLine(cx: Context, line: number) {
+export function toggleBreakpointAtLine(line: number) {
   return ({ dispatch, getState, client, sourceMaps }: ThunkArgs) => {
     const state = getState();
     const selectedSource = getSelectedSource(state);
 
     if (!selectedSource) {
       return;
     }
 
@@ -219,99 +209,87 @@ export function toggleBreakpointAtLine(c
       return;
     }
 
     if (getConditionalPanelLocation(getState())) {
       dispatch(closeConditionalPanel());
     }
 
     if (bp) {
-      return dispatch(removeBreakpoint(cx, bp));
+      return dispatch(removeBreakpoint(bp));
     }
     return dispatch(
-      addBreakpoint(cx, {
+      addBreakpoint({
         sourceId: selectedSource.id,
         sourceUrl: selectedSource.url,
         line: line
       })
     );
   };
 }
 
-export function addBreakpointAtLine(cx: Context, line: number) {
+export function addBreakpointAtLine(line: number) {
   return ({ dispatch, getState, client, sourceMaps }: ThunkArgs) => {
     const state = getState();
     const source = getSelectedSource(state);
 
     if (!source || isEmptyLineInSource(state, line, source.id)) {
       return;
     }
 
     return dispatch(
-      addBreakpoint(cx, {
+      addBreakpoint({
         sourceId: source.id,
         sourceUrl: source.url,
         column: undefined,
         line
       })
     );
   };
 }
 
-export function removeBreakpointsAtLine(
-  cx: Context,
-  sourceId: string,
-  line: number
-) {
+export function removeBreakpointsAtLine(sourceId: string, line: number) {
   return ({ dispatch, getState, client, sourceMaps }: ThunkArgs) => {
     const breakpointsAtLine = getBreakpointsForSource(
       getState(),
       sourceId,
       line
     );
-    return dispatch(removeBreakpoints(cx, breakpointsAtLine));
+    return dispatch(removeBreakpoints(breakpointsAtLine));
   };
 }
 
-export function disableBreakpointsAtLine(
-  cx: Context,
-  sourceId: string,
-  line: number
-) {
+export function disableBreakpointsAtLine(sourceId: string, line: number) {
   return ({ dispatch, getState, client, sourceMaps }: ThunkArgs) => {
     const breakpointsAtLine = getBreakpointsForSource(
       getState(),
       sourceId,
       line
     );
-    return dispatch(toggleBreakpoints(cx, true, breakpointsAtLine));
+    return dispatch(toggleBreakpoints(true, breakpointsAtLine));
   };
 }
 
-export function enableBreakpointsAtLine(
-  cx: Context,
-  sourceId: string,
-  line: number
-) {
+export function enableBreakpointsAtLine(sourceId: string, line: number) {
   return ({ dispatch, getState, client, sourceMaps }: ThunkArgs) => {
     const breakpointsAtLine = getBreakpointsForSource(
       getState(),
       sourceId,
       line
     );
-    return dispatch(toggleBreakpoints(cx, false, breakpointsAtLine));
+    return dispatch(toggleBreakpoints(false, breakpointsAtLine));
   };
 }
 
-export function toggleDisabledBreakpoint(cx: Context, breakpoint: Breakpoint) {
+export function toggleDisabledBreakpoint(breakpoint: Breakpoint) {
   return ({ dispatch, getState, client, sourceMaps }: ThunkArgs) => {
     if (!breakpoint.disabled) {
-      return dispatch(disableBreakpoint(cx, breakpoint));
+      return dispatch(disableBreakpoint(breakpoint));
     }
-    return dispatch(enableBreakpoint(cx, breakpoint));
+    return dispatch(enableBreakpoint(breakpoint));
   };
 }
 
 export function enableXHRBreakpoint(index: number, bp?: XHRBreakpoint) {
   return ({ dispatch, getState, client }: ThunkArgs) => {
     const xhrBreakpoints = getXHRBreakpoints(getState());
     const breakpoint = bp || xhrBreakpoints[index];
     const enabledBreakpoint = {
--- a/devtools/client/debugger/new/src/actions/breakpoints/modify.js
+++ b/devtools/client/debugger/new/src/actions/breakpoints/modify.js
@@ -3,18 +3,17 @@
  * file, You can obtain one at <http://mozilla.org/MPL/2.0/>. */
 
 // @flow
 
 import type { ThunkArgs } from "../types";
 import type {
   Breakpoint,
   BreakpointOptions,
-  SourceLocation,
-  Context
+  SourceLocation
 } from "../../types";
 
 import {
   makeBreakpointLocation,
   makeBreakpointId,
   getASTLocation
 } from "../../utils/breakpoint";
 
@@ -72,66 +71,61 @@ function clientRemoveBreakpoint(breakpoi
     const breakpointLocation = makeBreakpointLocation(
       getState(),
       breakpoint.generatedLocation
     );
     return client.removeBreakpoint(breakpointLocation);
   };
 }
 
-export function enableBreakpoint(cx: Context, initialBreakpoint: Breakpoint) {
+export function enableBreakpoint(initialBreakpoint: Breakpoint) {
   return async ({ dispatch, getState, client, sourceMaps }: ThunkArgs) => {
     const breakpoint = getBreakpoint(getState(), initialBreakpoint.location);
     if (!breakpoint || !breakpoint.disabled) {
       return;
     }
 
     dispatch({
       type: "SET_BREAKPOINT",
-      cx,
       breakpoint: { ...breakpoint, disabled: false }
     });
 
     return dispatch(clientSetBreakpoint(breakpoint));
   };
 }
 
 export function addBreakpoint(
-  cx: Context,
   initialLocation: SourceLocation,
   options: BreakpointOptions = {},
   disabled: boolean = false
 ) {
   return async ({ dispatch, getState, sourceMaps, client }: ThunkArgs) => {
     recordEvent("add_breakpoint");
 
     const { sourceId, column } = initialLocation;
 
-    await dispatch(setBreakpointPositions(cx, sourceId));
+    await dispatch(setBreakpointPositions(sourceId));
 
     const position = column
       ? getBreakpointPositionsForLocation(getState(), initialLocation)
       : getFirstBreakpointPosition(getState(), initialLocation);
 
     if (!position) {
       return;
     }
 
     const { location, generatedLocation } = position;
 
     // Both the original and generated sources must be loaded to get the
     // breakpoint's text.
     await dispatch(
-      loadSourceText(cx, getSourceFromId(getState(), location.sourceId))
+      loadSourceText(getSourceFromId(getState(), location.sourceId))
     );
     await dispatch(
-      loadSourceText(
-        cx,
-        getSourceFromId(getState(), generatedLocation.sourceId)
-      )
+      loadSourceText(getSourceFromId(getState(), generatedLocation.sourceId))
     );
 
     const source = getSourceFromId(getState(), location.sourceId);
     const generatedSource = getSourceFromId(
       getState(),
       generatedLocation.sourceId
     );
 
@@ -159,24 +153,22 @@ export function addBreakpoint(
     // new breakpoint's |location| or |generatedLocation| as their own
     // |location|. We will overwrite any breakpoint at |location| with the
     // SET_BREAKPOINT action below, but need to manually remove any breakpoint
     // at |generatedLocation|.
     const generatedId = makeBreakpointId(breakpoint.generatedLocation);
     if (id != generatedId && getBreakpoint(getState(), generatedLocation)) {
       dispatch({
         type: "REMOVE_BREAKPOINT",
-        cx,
         location: generatedLocation
       });
     }
 
     dispatch({
       type: "SET_BREAKPOINT",
-      cx,
       breakpoint
     });
 
     if (disabled) {
       // If we just clobbered an enabled breakpoint with a disabled one, we need
       // to remove any installed breakpoint in the server.
       return dispatch(clientRemoveBreakpoint(breakpoint));
     }
@@ -186,28 +178,27 @@ export function addBreakpoint(
 }
 
 /**
  * Remove a single breakpoint
  *
  * @memberof actions/breakpoints
  * @static
  */
-export function removeBreakpoint(cx: Context, initialBreakpoint: Breakpoint) {
+export function removeBreakpoint(initialBreakpoint: Breakpoint) {
   return ({ dispatch, getState, client }: ThunkArgs) => {
     recordEvent("remove_breakpoint");
 
     const breakpoint = getBreakpoint(getState(), initialBreakpoint.location);
     if (!breakpoint) {
       return;
     }
 
     dispatch({
       type: "REMOVE_BREAKPOINT",
-      cx,
       location: breakpoint.location
     });
 
     // If the breakpoint is disabled then it is not installed in the server.
     if (breakpoint.disabled) {
       return;
     }
 
@@ -216,26 +207,25 @@ export function removeBreakpoint(cx: Con
 }
 
 /**
  * Disable a single breakpoint
  *
  * @memberof actions/breakpoints
  * @static
  */
-export function disableBreakpoint(cx: Context, initialBreakpoint: Breakpoint) {
+export function disableBreakpoint(initialBreakpoint: Breakpoint) {
   return ({ dispatch, getState, client }: ThunkArgs) => {
     const breakpoint = getBreakpoint(getState(), initialBreakpoint.location);
     if (!breakpoint || breakpoint.disabled) {
       return;
     }
 
     dispatch({
       type: "SET_BREAKPOINT",
-      cx,
       breakpoint: { ...breakpoint, disabled: true }
     });
 
     return dispatch(clientRemoveBreakpoint(breakpoint));
   };
 }
 
 /**
@@ -245,30 +235,28 @@ export function disableBreakpoint(cx: Co
  * @memberof actions/breakpoints
  * @static
  * @param {SourceLocation} location
  *        @see DebuggerController.Breakpoints.addBreakpoint
  * @param {Object} options
  *        Any options to set on the breakpoint
  */
 export function setBreakpointOptions(
-  cx: Context,
   location: SourceLocation,
   options: BreakpointOptions = {}
 ) {
   return ({ dispatch, getState, client, sourceMaps }: ThunkArgs) => {
     let breakpoint = getBreakpoint(getState(), location);
     if (!breakpoint) {
-      return dispatch(addBreakpoint(cx, location, options));
+      return dispatch(addBreakpoint(location, options));
     }
 
     // Note: setting a breakpoint's options implicitly enables it.
     breakpoint = { ...breakpoint, disabled: false, options };
 
     dispatch({
       type: "SET_BREAKPOINT",
-      cx,
       breakpoint
     });
 
     return dispatch(clientSetBreakpoint(breakpoint));
   };
 }
--- a/devtools/client/debugger/new/src/actions/breakpoints/syncBreakpoint.js
+++ b/devtools/client/debugger/new/src/actions/breakpoints/syncBreakpoint.js
@@ -19,28 +19,24 @@ import { getSource, getBreakpoint } from
 import { removeBreakpoint, addBreakpoint } from ".";
 
 import type { ThunkArgs } from "../types";
 
 import type {
   SourceLocation,
   ASTLocation,
   PendingBreakpoint,
-  SourceId,
-  Context
+  SourceId
 } from "../../types";
 
 async function findBreakpointPosition(
-  cx: Context,
   { getState, dispatch },
   location: SourceLocation
 ) {
-  const positions = await dispatch(
-    setBreakpointPositions(cx, location.sourceId)
-  );
+  const positions = await dispatch(setBreakpointPositions(location.sourceId));
   const position = findPosition(positions, location);
   return position && position.generatedLocation;
 }
 
 async function findNewLocation(
   { name, offset, index }: ASTLocation,
   location: SourceLocation,
   source
@@ -74,17 +70,16 @@ async function findNewLocation(
 //   to make sure that either a breakpoint is added to the reducer or that this
 //   client breakpoint is deleted.
 //
 // - If we see both the original and generated sources and the source mapping
 //   has changed, we need to make sure that only a single breakpoint is added
 //   to the reducer for the new location corresponding to the original location
 //   in the pending breakpoint.
 export function syncBreakpoint(
-  cx: Context,
   sourceId: SourceId,
   pendingBreakpoint: PendingBreakpoint
 ) {
   return async (thunkArgs: ThunkArgs) => {
     const { getState, client, dispatch } = thunkArgs;
     assertPendingBreakpoint(pendingBreakpoint);
 
     const source = getSource(getState(), sourceId);
@@ -121,34 +116,32 @@ export function syncBreakpoint(
       if (
         getBreakpoint(getState(), sourceGeneratedLocation) ||
         !client.hasBreakpoint(breakpointLocation)
       ) {
         return;
       }
       return dispatch(
         addBreakpoint(
-          cx,
           sourceGeneratedLocation,
           pendingBreakpoint.options,
           pendingBreakpoint.disabled
         )
       );
     }
 
     const previousLocation = { ...location, sourceId };
 
     const newLocation = await findNewLocation(
       astLocation,
       previousLocation,
       source
     );
 
     const newGeneratedLocation = await findBreakpointPosition(
-      cx,
       thunkArgs,
       newLocation
     );
 
     if (!newGeneratedLocation) {
       return;
     }
 
@@ -160,28 +153,27 @@ export function syncBreakpoint(
     // If the new generated location has changed from that in the pending
     // breakpoint, remove any breakpoint associated with the old generated
     // location. This could either be in the reducer or only in the client,
     // depending on whether the pending breakpoint has been processed for the
     // generated source yet.
     if (!isSameLocation) {
       const bp = getBreakpoint(getState(), sourceGeneratedLocation);
       if (bp) {
-        dispatch(removeBreakpoint(cx, bp));
+        dispatch(removeBreakpoint(bp));
       } else {
         const breakpointLocation = makeBreakpointLocation(
           getState(),
           sourceGeneratedLocation
         );
         client.removeBreakpoint(breakpointLocation);
       }
     }
 
     return dispatch(
       addBreakpoint(
-        cx,
         newLocation,
         pendingBreakpoint.options,
         pendingBreakpoint.disabled
       )
     );
   };
 }
--- a/devtools/client/debugger/new/src/actions/breakpoints/tests/breakpointPositions.spec.js
+++ b/devtools/client/debugger/new/src/actions/breakpoints/tests/breakpointPositions.spec.js
@@ -13,20 +13,20 @@ import {
 } from "../../../utils/test-head";
 
 describe("breakpointPositions", () => {
   it("fetches positions", async () => {
     const store = createStore({
       getBreakpointPositions: async () => ({ "9": [1] })
     });
 
-    const { dispatch, getState, cx } = store;
+    const { dispatch, getState } = store;
     await dispatch(actions.newSource(makeSource("foo")));
 
-    dispatch(actions.setBreakpointPositions(cx, "foo"));
+    dispatch(actions.setBreakpointPositions("foo"));
 
     await waitForState(store, state =>
       selectors.hasBreakpointPositions(state, "foo")
     );
 
     expect(
       selectors.getBreakpointPositionsForSource(getState(), "foo")
     ).toEqual([
@@ -53,21 +53,21 @@ describe("breakpointPositions", () => {
     const store = createStore({
       getBreakpointPositions: () =>
         new Promise(r => {
           count++;
           resolve = r;
         })
     });
 
-    const { dispatch, getState, cx } = store;
+    const { dispatch, getState } = store;
     await dispatch(actions.newSource(makeSource("foo")));
 
-    dispatch(actions.setBreakpointPositions(cx, "foo"));
-    dispatch(actions.setBreakpointPositions(cx, "foo"));
+    dispatch(actions.setBreakpointPositions("foo"));
+    dispatch(actions.setBreakpointPositions("foo"));
 
     resolve({ "9": [1] });
     await waitForState(store, state =>
       selectors.hasBreakpointPositions(state, "foo")
     );
 
     expect(
       selectors.getBreakpointPositionsForSource(getState(), "foo")
--- a/devtools/client/debugger/new/src/actions/breakpoints/tests/breakpoints.spec.js
+++ b/devtools/client/debugger/new/src/actions/breakpoints/tests/breakpoints.spec.js
@@ -18,137 +18,137 @@ function mockClient(positionsResponse = 
   return {
     ...simpleMockThreadClient,
     getBreakpointPositions: async () => positionsResponse
   };
 }
 
 describe("breakpoints", () => {
   it("should add a breakpoint", async () => {
-    const { dispatch, getState, cx } = createStore(mockClient({ "2": [1] }));
+    const { dispatch, getState } = createStore(mockClient({ "2": [1] }));
     const loc1 = {
       sourceId: "a",
       line: 2,
       column: 1,
       sourceUrl: "http://localhost:8000/examples/a"
     };
 
     const source = makeSource("a");
     await dispatch(actions.newSource(source));
-    await dispatch(actions.loadSourceText(cx, source));
+    await dispatch(actions.loadSourceText(source));
     await dispatch(
-      actions.setSelectedLocation(cx, source, {
+      actions.setSelectedLocation(source, {
         line: 1,
         column: 1,
         sourceId: source.id
       })
     );
 
-    await dispatch(actions.addBreakpoint(cx, loc1));
+    await dispatch(actions.addBreakpoint(loc1));
 
     expect(selectors.getBreakpointCount(getState())).toEqual(1);
     const bp = selectors.getBreakpoint(getState(), loc1);
     expect(bp && bp.location).toEqual(loc1);
     expect(getTelemetryEvents("add_breakpoint")).toHaveLength(1);
 
     const bpSources = selectors.getBreakpointSources(getState());
     expect(bpSources).toMatchSnapshot();
   });
 
   it("should not show a breakpoint that does not have text", async () => {
-    const { dispatch, getState, cx } = createStore(mockClient({ "5": [1] }));
+    const { dispatch, getState } = createStore(mockClient({ "5": [1] }));
     const loc1 = {
       sourceId: "a",
       line: 5,
       column: 1,
       sourceUrl: "http://localhost:8000/examples/a"
     };
     const source = makeSource("a");
     await dispatch(actions.newSource(source));
-    await dispatch(actions.loadSourceText(cx, source));
+    await dispatch(actions.loadSourceText(source));
     await dispatch(
-      actions.setSelectedLocation(cx, source, {
+      actions.setSelectedLocation(source, {
         line: 1,
         column: 1,
         sourceId: source.id
       })
     );
 
-    await dispatch(actions.addBreakpoint(cx, loc1));
+    await dispatch(actions.addBreakpoint(loc1));
 
     expect(selectors.getBreakpointCount(getState())).toEqual(1);
     const bp = selectors.getBreakpoint(getState(), loc1);
     expect(bp && bp.location).toEqual(loc1);
     expect(selectors.getBreakpointSources(getState())).toMatchSnapshot();
   });
 
   it("should show a disabled breakpoint that does not have text", async () => {
-    const { dispatch, getState, cx } = createStore(mockClient({ "5": [1] }));
+    const { dispatch, getState } = createStore(mockClient({ "5": [1] }));
     const loc1 = {
       sourceId: "a",
       line: 5,
       column: 1,
       sourceUrl: "http://localhost:8000/examples/a"
     };
     const source = makeSource("a");
     await dispatch(actions.newSource(source));
-    await dispatch(actions.loadSourceText(cx, source));
+    await dispatch(actions.loadSourceText(source));
     await dispatch(
-      actions.setSelectedLocation(cx, source, {
+      actions.setSelectedLocation(source, {
         line: 1,
         column: 1,
         sourceId: source.id
       })
     );
 
-    await dispatch(actions.addBreakpoint(cx, loc1));
+    await dispatch(actions.addBreakpoint(loc1));
     const breakpoint = selectors.getBreakpoint(getState(), loc1);
     if (!breakpoint) {
       throw new Error("no breakpoint");
     }
 
-    await dispatch(actions.disableBreakpoint(cx, breakpoint));
+    await dispatch(actions.disableBreakpoint(breakpoint));
 
     expect(selectors.getBreakpointCount(getState())).toEqual(1);
     const bp = selectors.getBreakpoint(getState(), loc1);
     expect(bp && bp.location).toEqual(loc1);
     expect(selectors.getBreakpointSources(getState())).toMatchSnapshot();
   });
 
   it("should not re-add a breakpoint", async () => {
-    const { dispatch, getState, cx } = createStore(mockClient({ "5": [1] }));
+    const { dispatch, getState } = createStore(mockClient({ "5": [1] }));
     const loc1 = {
       sourceId: "a",
       line: 5,
       column: 1,
       sourceUrl: "http://localhost:8000/examples/a"
     };
 
     const source = makeSource("a");
     await dispatch(actions.newSource(source));
-    await dispatch(actions.loadSourceText(cx, source));
+    await dispatch(actions.loadSourceText(source));
     await dispatch(
-      actions.setSelectedLocation(cx, source, {
+      actions.setSelectedLocation(source, {
         line: 1,
         column: 1,
         sourceId: source.id
       })
     );
 
-    await dispatch(actions.addBreakpoint(cx, loc1));
+    await dispatch(actions.addBreakpoint(loc1));
     expect(selectors.getBreakpointCount(getState())).toEqual(1);
     const bp = selectors.getBreakpoint(getState(), loc1);
     expect(bp && bp.location).toEqual(loc1);
 
-    await dispatch(actions.addBreakpoint(cx, loc1));
+    await dispatch(actions.addBreakpoint(loc1));
     expect(selectors.getBreakpointCount(getState())).toEqual(1);
   });
 
   it("should remove a breakpoint", async () => {
-    const { dispatch, getState, cx } = createStore(
+    const { dispatch, getState } = createStore(
       mockClient({ "5": [1], "6": [2] })
     );
 
     const loc1 = {
       sourceId: "a",
       line: 5,
       column: 1,
       sourceUrl: "http://localhost:8000/examples/a"
@@ -158,44 +158,44 @@ describe("breakpoints", () => {
       sourceId: "b",
       line: 6,
       column: 2,
       sourceUrl: "http://localhost:8000/examples/b"
     };
 
     const aSource = makeSource("a");
     await dispatch(actions.newSource(aSource));
-    await dispatch(actions.loadSourceText(cx, aSource));
+    await dispatch(actions.loadSourceText(aSource));
 
     const bSource = makeSource("b");
     await dispatch(actions.newSource(bSource));
-    await dispatch(actions.loadSourceText(cx, bSource));
+    await dispatch(actions.loadSourceText(bSource));
 
     await dispatch(
-      actions.setSelectedLocation(cx, aSource, {
+      actions.setSelectedLocation(aSource, {
         line: 1,
         column: 1,
         sourceId: aSource.id
       })
     );
 
-    await dispatch(actions.addBreakpoint(cx, loc1));
-    await dispatch(actions.addBreakpoint(cx, loc2));
+    await dispatch(actions.addBreakpoint(loc1));
+    await dispatch(actions.addBreakpoint(loc2));
 
     const bp = selectors.getBreakpoint(getState(), loc1);
     if (!bp) {
       throw new Error("no bp");
     }
-    await dispatch(actions.removeBreakpoint(cx, bp));
+    await dispatch(actions.removeBreakpoint(bp));
 
     expect(selectors.getBreakpointCount(getState())).toEqual(1);
   });
 
   it("should disable a breakpoint", async () => {
-    const { dispatch, getState, cx } = createStore(
+    const { dispatch, getState } = createStore(
       mockClient({ "5": [1], "6": [2] })
     );
 
     const loc1 = {
       sourceId: "a",
       line: 5,
       column: 1,
       sourceUrl: "http://localhost:8000/examples/a"
@@ -205,74 +205,74 @@ describe("breakpoints", () => {
       sourceId: "b",
       line: 6,
       column: 2,
       sourceUrl: "http://localhost:8000/examples/b"
     };
 
     const aSource = makeSource("a");
     await dispatch(actions.newSource(aSource));
-    await dispatch(actions.loadSourceText(cx, aSource));
+    await dispatch(actions.loadSourceText(aSource));
 
     const bSource = makeSource("b");
     await dispatch(actions.newSource(bSource));
-    await dispatch(actions.loadSourceText(cx, bSource));
+    await dispatch(actions.loadSourceText(bSource));
 
-    await dispatch(actions.addBreakpoint(cx, loc1));
-    await dispatch(actions.addBreakpoint(cx, loc2));
+    await dispatch(actions.addBreakpoint(loc1));
+    await dispatch(actions.addBreakpoint(loc2));
 
     const breakpoint = selectors.getBreakpoint(getState(), loc1);
     if (!breakpoint) {
       throw new Error("no breakpoint");
     }
 
-    await dispatch(actions.disableBreakpoint(cx, breakpoint));
+    await dispatch(actions.disableBreakpoint(breakpoint));
 
     const bp = selectors.getBreakpoint(getState(), loc1);
     expect(bp && bp.disabled).toBe(true);
   });
 
   it("should enable breakpoint", async () => {
-    const { dispatch, getState, cx } = createStore(
+    const { dispatch, getState } = createStore(
       mockClient({ "5": [1], "6": [2] })
     );
     const loc = {
       sourceId: "a",
       line: 5,
       column: 1,
       sourceUrl: "http://localhost:8000/examples/a"
     };
 
     const aSource = makeSource("a");
     await dispatch(actions.newSource(aSource));
-    await dispatch(actions.loadSourceText(cx, aSource));
+    await dispatch(actions.loadSourceText(aSource));
 
-    await dispatch(actions.addBreakpoint(cx, loc));
+    await dispatch(actions.addBreakpoint(loc));
     let bp = selectors.getBreakpoint(getState(), loc);
     if (!bp) {
       throw new Error("no breakpoint");
     }
 
-    await dispatch(actions.disableBreakpoint(cx, bp));
+    await dispatch(actions.disableBreakpoint(bp));
 
     bp = selectors.getBreakpoint(getState(), loc);
     if (!bp) {
       throw new Error("no breakpoint");
     }
 
     expect(bp && bp.disabled).toBe(true);
 
-    await dispatch(actions.enableBreakpoint(cx, bp));
+    await dispatch(actions.enableBreakpoint(bp));
 
     bp = selectors.getBreakpoint(getState(), loc);
     expect(bp && !bp.disabled).toBe(true);
   });
 
   it("should toggle all the breakpoints", async () => {
-    const { dispatch, getState, cx } = createStore(
+    const { dispatch, getState } = createStore(
       mockClient({ "5": [1], "6": [2] })
     );
 
     const loc1 = {
       sourceId: "a",
       line: 5,
       column: 1,
       sourceUrl: "http://localhost:8000/examples/a"
@@ -282,169 +282,169 @@ describe("breakpoints", () => {
       sourceId: "b",
       line: 6,
       column: 2,
       sourceUrl: "http://localhost:8000/examples/b"
     };
 
     const aSource = makeSource("a");
     await dispatch(actions.newSource(aSource));
-    await dispatch(actions.loadSourceText(cx, aSource));
+    await dispatch(actions.loadSourceText(aSource));
 
     const bSource = makeSource("b");
     await dispatch(actions.newSource(bSource));
-    await dispatch(actions.loadSourceText(cx, bSource));
+    await dispatch(actions.loadSourceText(bSource));
 
-    await dispatch(actions.addBreakpoint(cx, loc1));
-    await dispatch(actions.addBreakpoint(cx, loc2));
+    await dispatch(actions.addBreakpoint(loc1));
+    await dispatch(actions.addBreakpoint(loc2));
 
-    await dispatch(actions.toggleAllBreakpoints(cx, true));
+    await dispatch(actions.toggleAllBreakpoints(true));
 
     let bp1 = selectors.getBreakpoint(getState(), loc1);
     let bp2 = selectors.getBreakpoint(getState(), loc2);
 
     expect(bp1 && bp1.disabled).toBe(true);
     expect(bp2 && bp2.disabled).toBe(true);
 
-    await dispatch(actions.toggleAllBreakpoints(cx, false));
+    await dispatch(actions.toggleAllBreakpoints(false));
 
     bp1 = selectors.getBreakpoint(getState(), loc1);
     bp2 = selectors.getBreakpoint(getState(), loc2);
     expect(bp1 && bp1.disabled).toBe(false);
     expect(bp2 && bp2.disabled).toBe(false);
   });
 
   it("should toggle a breakpoint at a location", async () => {
     const loc = { sourceId: "foo1", line: 5, column: 1 };
     const getBp = () => selectors.getBreakpoint(getState(), loc);
 
-    const { dispatch, getState, cx } = createStore(mockClient({ "5": [1] }));
+    const { dispatch, getState } = createStore(mockClient({ "5": [1] }));
 
     const source = makeSource("foo1");
     await dispatch(actions.newSource(source));
-    await dispatch(actions.loadSourceText(cx, source));
+    await dispatch(actions.loadSourceText(source));
 
-    await dispatch(actions.selectLocation(cx, loc));
+    await dispatch(actions.selectLocation(loc));
 
-    await dispatch(actions.toggleBreakpointAtLine(cx, 5));
+    await dispatch(actions.toggleBreakpointAtLine(5));
     const bp = getBp();
     expect(bp && !bp.disabled).toBe(true);
 
-    await dispatch(actions.toggleBreakpointAtLine(cx, 5));
+    await dispatch(actions.toggleBreakpointAtLine(5));
     expect(getBp()).toBe(undefined);
   });
 
   it("should disable/enable a breakpoint at a location", async () => {
     const location = { sourceId: "foo1", line: 5, column: 1 };
     const getBp = () => selectors.getBreakpoint(getState(), location);
 
-    const { dispatch, getState, cx } = createStore(mockClient({ "5": [1] }));
+    const { dispatch, getState } = createStore(mockClient({ "5": [1] }));
 
     const source = makeSource("foo1");
     await dispatch(actions.newSource(source));
-    await dispatch(actions.loadSourceText(cx, source));
+    await dispatch(actions.loadSourceText(source));
 
-    await dispatch(actions.selectLocation(cx, { sourceId: "foo1", line: 1 }));
+    await dispatch(actions.selectLocation({ sourceId: "foo1", line: 1 }));
 
-    await dispatch(actions.toggleBreakpointAtLine(cx, 5));
+    await dispatch(actions.toggleBreakpointAtLine(5));
     let bp = getBp();
     expect(bp && !bp.disabled).toBe(true);
     bp = getBp();
     if (!bp) {
       throw new Error("no bp");
     }
-    await dispatch(actions.toggleDisabledBreakpoint(cx, bp));
+    await dispatch(actions.toggleDisabledBreakpoint(bp));
     bp = getBp();
     expect(bp && bp.disabled).toBe(true);
   });
 
   it("should set the breakpoint condition", async () => {
-    const { dispatch, getState, cx } = createStore(mockClient({ "5": [1] }));
+    const { dispatch, getState } = createStore(mockClient({ "5": [1] }));
 
     const loc = {
       sourceId: "a",
       line: 5,
       column: 1,
       sourceUrl: "http://localhost:8000/examples/a"
     };
 
     const source = makeSource("a");
     await dispatch(actions.newSource(source));
-    await dispatch(actions.loadSourceText(cx, source));
+    await dispatch(actions.loadSourceText(source));
 
-    await dispatch(actions.addBreakpoint(cx, loc));
+    await dispatch(actions.addBreakpoint(loc));
 
     let bp = selectors.getBreakpoint(getState(), loc);
     expect(bp && bp.options.condition).toBe(undefined);
 
     await dispatch(
-      actions.setBreakpointOptions(cx, loc, {
+      actions.setBreakpointOptions(loc, {
         condition: "const foo = 0",
         getTextForLine: () => {}
       })
     );
 
     bp = selectors.getBreakpoint(getState(), loc);
     expect(bp && bp.options.condition).toBe("const foo = 0");
   });
 
   it("should set the condition and enable a breakpoint", async () => {
-    const { dispatch, getState, cx } = createStore(mockClient({ "5": [1] }));
+    const { dispatch, getState } = createStore(mockClient({ "5": [1] }));
 
     const loc = {
       sourceId: "a",
       line: 5,
       column: 1,
       sourceUrl: "http://localhost:8000/examples/a"
     };
 
     const source = makeSource("a");
     await dispatch(actions.newSource(source));
-    await dispatch(actions.loadSourceText(cx, source));
+    await dispatch(actions.loadSourceText(source));
 
-    await dispatch(actions.addBreakpoint(cx, loc));
+    await dispatch(actions.addBreakpoint(loc));
     let bp = selectors.getBreakpoint(getState(), loc);
     if (!bp) {
       throw new Error("no breakpoint");
     }
 
-    await dispatch(actions.disableBreakpoint(cx, bp));
+    await dispatch(actions.disableBreakpoint(bp));
 
     bp = selectors.getBreakpoint(getState(), loc);
     expect(bp && bp.options.condition).toBe(undefined);
 
     await dispatch(
-      actions.setBreakpointOptions(cx, loc, {
+      actions.setBreakpointOptions(loc, {
         condition: "const foo = 0",
         getTextForLine: () => {}
       })
     );
     const newBreakpoint = selectors.getBreakpoint(getState(), loc);
     expect(newBreakpoint && !newBreakpoint.disabled).toBe(true);
     expect(newBreakpoint && newBreakpoint.options.condition).toBe(
       "const foo = 0"
     );
   });
 
   it("should remap breakpoints on pretty print", async () => {
-    const { dispatch, getState, cx } = createStore(mockClient({ "1": [0] }));
+    const { dispatch, getState } = createStore(mockClient({ "1": [0] }));
 
     const loc = {
       sourceId: "a.js",
       line: 1,
       column: 0,
       sourceUrl: "http://localhost:8000/examples/a.js"
     };
 
     const source = makeSource("a.js");
     await dispatch(actions.newSource(source));
-    await dispatch(actions.loadSourceText(cx, source));
+    await dispatch(actions.loadSourceText(source));
 
-    await dispatch(actions.addBreakpoint(cx, loc));
-    await dispatch(actions.togglePrettyPrint(cx, "a.js"));
+    await dispatch(actions.addBreakpoint(loc));
+    await dispatch(actions.togglePrettyPrint("a.js"));
 
     const breakpoint = selectors.getBreakpointsList(getState())[0];
 
     expect(
       breakpoint.location.sourceUrl &&
         breakpoint.location.sourceUrl.includes("formatted")
     ).toBe(true);
     expect(breakpoint).toMatchSnapshot();
--- a/devtools/client/debugger/new/src/actions/debuggee.js
+++ b/devtools/client/debugger/new/src/actions/debuggee.js
@@ -1,18 +1,15 @@
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at <http://mozilla.org/MPL/2.0/>. */
 
 // @flow
 
 import type { Action, ThunkArgs } from "./types";
 
-import { getContext } from "../selectors";
-
 export function updateWorkers() {
   return async function({ dispatch, getState, client }: ThunkArgs) {
-    const cx = getContext(getState());
     const workers = await client.fetchWorkers();
     const mainThread = client.getMainThread();
-    dispatch(({ type: "SET_WORKERS", cx, workers, mainThread }: Action));
+    dispatch(({ type: "SET_WORKERS", workers, mainThread }: Action));
   };
 }
--- a/devtools/client/debugger/new/src/actions/expressions.js
+++ b/devtools/client/debugger/new/src/actions/expressions.js
@@ -17,88 +17,84 @@ import {
   getIsPaused
 } from "../selectors";
 import { PROMISE } from "./utils/middleware/promise";
 import { wrapExpression } from "../utils/expressions";
 import { features } from "../utils/prefs";
 import { isOriginal } from "../utils/source";
 
 import * as parser from "../workers/parser";
-import type { Expression, ThreadContext } from "../types";
+import type { Expression } from "../types";
 import type { ThunkArgs } from "./types";
 
 /**
  * Add expression for debugger to watch
  *
  * @param {object} expression
  * @param {number} expression.id
  * @memberof actions/pause
  * @static
  */
-export function addExpression(cx: ThreadContext, input: string) {
+export function addExpression(input: string) {
   return async ({ dispatch, getState }: ThunkArgs) => {
     if (!input) {
       return;
     }
 
     const expressionError = await parser.hasSyntaxError(input);
 
     const expression = getExpression(getState(), input);
     if (expression) {
-      return dispatch(evaluateExpression(cx, expression));
+      return dispatch(evaluateExpression(expression));
     }
 
-    dispatch({ type: "ADD_EXPRESSION", cx, input, expressionError });
+    dispatch({ type: "ADD_EXPRESSION", input, expressionError });
 
     const newExpression = getExpression(getState(), input);
     if (newExpression) {
-      return dispatch(evaluateExpression(cx, newExpression));
+      return dispatch(evaluateExpression(newExpression));
     }
   };
 }
 
-export function autocomplete(cx: ThreadContext, input: string, cursor: number) {
+export function autocomplete(input: string, cursor: number) {
   return async ({ dispatch, getState, client }: ThunkArgs) => {
     if (!input) {
       return;
     }
-    const frameId = getSelectedFrameId(getState(), cx.thread);
+    const thread = getCurrentThread(getState());
+    const frameId = getSelectedFrameId(getState(), thread);
     const result = await client.autocomplete(input, cursor, frameId);
-    await dispatch({ type: "AUTOCOMPLETE", cx, input, result });
+    await dispatch({ type: "AUTOCOMPLETE", input, result });
   };
 }
 
 export function clearAutocomplete() {
   return { type: "CLEAR_AUTOCOMPLETE" };
 }
 
 export function clearExpressionError() {
   return { type: "CLEAR_EXPRESSION_ERROR" };
 }
 
-export function updateExpression(
-  cx: ThreadContext,
-  input: string,
-  expression: Expression
-) {
+export function updateExpression(input: string, expression: Expression) {
   return async ({ dispatch, getState }: ThunkArgs) => {
     if (!input) {
       return;
     }
 
     const expressionError = await parser.hasSyntaxError(input);
     dispatch({
       type: "UPDATE_EXPRESSION",
-      cx,
       expression,
       input: expressionError ? expression.input : input,
       expressionError
     });
 
-    dispatch(evaluateExpressions(cx));
+    dispatch(evaluateExpressions());
   };
 }
 
 /**
  *
  * @param {object} expression
  * @param {number} expression.id
  * @memberof actions/pause
@@ -114,63 +110,64 @@ export function deleteExpression(express
 }
 
 /**
  *
  * @memberof actions/pause
  * @param {number} selectedFrameId
  * @static
  */
-export function evaluateExpressions(cx: ThreadContext) {
+export function evaluateExpressions() {
   return async function({ dispatch, getState, client }: ThunkArgs) {
     const expressions = getExpressions(getState()).toJS();
     const inputs = expressions.map(({ input }) => input);
-    const frameId = getSelectedFrameId(getState(), cx.thread);
+    const thread = getCurrentThread(getState());
+    const frameId = getSelectedFrameId(getState(), thread);
     const results = await client.evaluateExpressions(inputs, {
       frameId,
-      thread: cx.thread
+      thread
     });
-    dispatch({ type: "EVALUATE_EXPRESSIONS", cx, inputs, results });
+    dispatch({ type: "EVALUATE_EXPRESSIONS", inputs, results });
   };
 }
 
-function evaluateExpression(cx: ThreadContext, expression: Expression) {
+function evaluateExpression(expression: Expression) {
   return async function({ dispatch, getState, client, sourceMaps }: ThunkArgs) {
     if (!expression.input) {
       console.warn("Expressions should not be empty");
       return;
     }
 
     let input = expression.input;
-    const frame = getSelectedFrame(getState(), cx.thread);
+    const thread = getCurrentThread(getState());
+    const frame = getSelectedFrame(getState(), thread);
 
     if (frame) {
       const { location } = frame;
       const source = getSourceFromId(getState(), location.sourceId);
 
       const selectedSource = getSelectedSource(getState());
 
       if (selectedSource && isOriginal(source) && isOriginal(selectedSource)) {
         const mapResult = await dispatch(getMappedExpression(input));
         if (mapResult) {
           input = mapResult.expression;
         }
       }
     }
 
-    const frameId = getSelectedFrameId(getState(), cx.thread);
+    const frameId = getSelectedFrameId(getState(), thread);
 
     return dispatch({
       type: "EVALUATE_EXPRESSION",
-      cx,
-      thread: cx.thread,
+      thread,
       input: expression.input,
       [PROMISE]: client.evaluateInFrame(wrapExpression(input), {
         frameId,
-        thread: cx.thread
+        thread
       })
     });
   };
 }
 
 /**
  * Gets information about original variable names from the source map
  * and replaces all posible generated names.
--- a/devtools/client/debugger/new/src/actions/file-search.js
+++ b/devtools/client/debugger/new/src/actions/file-search.js
@@ -10,42 +10,42 @@ import {
   findNext,
   findPrev,
   removeOverlay,
   searchSourceForHighlight
 } from "../utils/editor";
 import { isWasm, renderWasmText } from "../utils/wasm";
 import { getMatches } from "../workers/search";
 import type { Action, FileTextSearchModifier, ThunkArgs } from "./types";
-import type { WasmSource, Context } from "../types";
+import type { WasmSource } from "../types";
 
 import {
   getSelectedSource,
   getFileSearchModifiers,
   getFileSearchQuery,
   getFileSearchResults
 } from "../selectors";
 
 import {
   closeActiveSearch,
   clearHighlightLineRange,
   setActiveSearch
 } from "./ui";
 type Editor = Object;
 type Match = Object;
 
-export function doSearch(cx: Context, query: string, editor: Editor) {
+export function doSearch(query: string, editor: Editor) {
   return ({ getState, dispatch }: ThunkArgs) => {
     const selectedSource = getSelectedSource(getState());
     if (!selectedSource || !selectedSource.text) {
       return;
     }
 
-    dispatch(setFileSearchQuery(cx, query));
-    dispatch(searchContents(cx, query, editor));
+    dispatch(setFileSearchQuery(query));
+    dispatch(searchContents(query, editor));
   };
 }
 
 export function doSearchForHighlight(
   query: string,
   editor: Editor,
   line: number,
   ch: number
@@ -54,54 +54,50 @@ export function doSearchForHighlight(
     const selectedSource = getSelectedSource(getState());
     if (!selectedSource || !selectedSource.text) {
       return;
     }
     dispatch(searchContentsForHighlight(query, editor, line, ch));
   };
 }
 
-export function setFileSearchQuery(cx: Context, query: string): Action {
+export function setFileSearchQuery(query: string): Action {
   return {
     type: "UPDATE_FILE_SEARCH_QUERY",
-    cx,
     query
   };
 }
 
 export function toggleFileSearchModifier(
-  cx: Context,
   modifier: FileTextSearchModifier
 ): Action {
-  return { type: "TOGGLE_FILE_SEARCH_MODIFIER", cx, modifier };
+  return { type: "TOGGLE_FILE_SEARCH_MODIFIER", modifier };
 }
 
 export function updateSearchResults(
-  cx: Context,
   characterIndex: number,
   line: number,
   matches: Match[]
 ): Action {
   const matchIndex = matches.findIndex(
     elm => elm.line === line && elm.ch === characterIndex
   );
 
   return {
     type: "UPDATE_SEARCH_RESULTS",
-    cx,
     results: {
       matches,
       matchIndex,
       count: matches.length,
       index: characterIndex
     }
   };
 }
 
-export function searchContents(cx: Context, query: string, editor: Object) {
+export function searchContents(query: string, editor: Object) {
   return async ({ getState, dispatch }: ThunkArgs) => {
     const modifiers = getFileSearchModifiers(getState());
     const selectedSource = getSelectedSource(getState());
 
     if (!editor || !selectedSource || !selectedSource.text || !modifiers) {
       return;
     }
 
@@ -123,17 +119,17 @@ export function searchContents(cx: Conte
 
     const res = find(ctx, query, true, _modifiers);
     if (!res) {
       return;
     }
 
     const { ch, line } = res;
 
-    dispatch(updateSearchResults(cx, ch, line, matches));
+    dispatch(updateSearchResults(ch, line, matches));
   };
 }
 
 export function searchContentsForHighlight(
   query: string,
   editor: Object,
   line: number,
   ch: number
@@ -154,17 +150,17 @@ export function searchContentsForHighlig
 
     const ctx = { ed: editor, cm: editor.codeMirror };
     const _modifiers = modifiers.toJS();
 
     searchSourceForHighlight(ctx, false, query, true, _modifiers, line, ch);
   };
 }
 
-export function traverseResults(cx: Context, rev: boolean, editor: Editor) {
+export function traverseResults(rev: boolean, editor: Editor) {
   return async ({ getState, dispatch }: ThunkArgs) => {
     if (!editor) {
       return;
     }
 
     const ctx = { ed: editor, cm: editor.codeMirror };
 
     const query = getFileSearchQuery(getState());
@@ -179,26 +175,26 @@ export function traverseResults(cx: Cont
       const matchedLocations = matches || [];
       const findArgs = [ctx, query, true, modifiers.toJS()];
       const results = rev ? findPrev(...findArgs) : findNext(...findArgs);
 
       if (!results) {
         return;
       }
       const { ch, line } = results;
-      dispatch(updateSearchResults(cx, ch, line, matchedLocations));
+      dispatch(updateSearchResults(ch, line, matchedLocations));
     }
   };
 }
 
-export function closeFileSearch(cx: Context, editor: Editor) {
+export function closeFileSearch(editor: Editor) {
   return ({ getState, dispatch }: ThunkArgs) => {
     if (editor) {
       const query = getFileSearchQuery(getState());
       const ctx = { ed: editor, cm: editor.codeMirror };
       removeOverlay(ctx, query);
     }
 
-    dispatch(setFileSearchQuery(cx, ""));
+    dispatch(setFileSearchQuery(""));
     dispatch(closeActiveSearch());
     dispatch(clearHighlightLineRange());
   };
 }
--- a/devtools/client/debugger/new/src/actions/pause/breakOnNext.js
+++ b/devtools/client/debugger/new/src/actions/pause/breakOnNext.js
@@ -1,23 +1,24 @@
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at <http://mozilla.org/MPL/2.0/>. */
 
 // @flow
 
+import { getCurrentThread } from "../../selectors";
 import type { ThunkArgs } from "../types";
-import type { ThreadContext } from "../../types";
 
 /**
  * Debugger breakOnNext command.
  * It's different from the comand action because we also want to
  * highlight the pause icon.
  *
  * @memberof actions/pause
  * @static
  */
-export function breakOnNext(cx: ThreadContext) {
+export function breakOnNext() {
   return async ({ dispatch, getState, client }: ThunkArgs) => {
-    await client.breakOnNext(cx.thread);
-    return dispatch({ type: "BREAK_ON_NEXT", thread: cx.thread });
+    const thread = getCurrentThread(getState());
+    await client.breakOnNext(thread);
+    return dispatch({ type: "BREAK_ON_NEXT", thread });
   };
 }
--- a/devtools/client/debugger/new/src/actions/pause/commands.js
+++ b/devtools/client/debugger/new/src/actions/pause/commands.js
@@ -1,183 +1,183 @@
 /* -*- indent-tabs-mode: nil; js-indent-level: 2; js-indent-level: 2 -*- */
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at <http://mozilla.org/MPL/2.0/>. */
 
 // @flow
 
 import {
+  getIsPaused,
+  getCurrentThread,
   getSource,
   getTopFrame,
-  getSelectedFrame,
-  getThreadContext
+  getSelectedFrame
 } from "../../selectors";
 import { PROMISE } from "../utils/middleware/promise";
 import { getNextStep } from "../../workers/parser";
 import { addHiddenBreakpoint } from "../breakpoints";
 import { evaluateExpressions } from "../expressions";
 import { selectLocation } from "../sources";
-import { fetchScopes } from "./fetchScopes";
 import { features } from "../../utils/prefs";
 import { recordEvent } from "../../utils/telemetry";
-import assert from "../../utils/assert";
 
-import type { Source, ThreadId, Context, ThreadContext } from "../../types";
+import type { Source, ThreadId } from "../../types";
 import type { ThunkArgs } from "../types";
 import type { Command } from "../../reducers/types";
 
-export function selectThread(cx: Context, thread: ThreadId) {
+export function selectThread(thread: ThreadId) {
   return async ({ dispatch, getState, client }: ThunkArgs) => {
-    await dispatch({ cx, type: "SELECT_THREAD", thread });
-
-    // Get a new context now that the current thread has changed.
-    const threadcx = getThreadContext(getState());
-    assert(threadcx.thread == thread, "Thread mismatch");
-
-    dispatch(evaluateExpressions(threadcx));
+    await dispatch({ type: "SELECT_THREAD", thread });
+    dispatch(evaluateExpressions());
 
     const frame = getSelectedFrame(getState(), thread);
     if (frame) {
-      dispatch(selectLocation(threadcx, frame.location));
-      dispatch(fetchScopes(threadcx));
+      dispatch(selectLocation(frame.location));
     }
   };
 }
 
 /**
  * Debugger commands like stepOver, stepIn, stepUp
  *
  * @param string $0.type
  * @memberof actions/pause
  * @static
  */
-export function command(cx: ThreadContext, type: Command) {
+export function command(thread: ThreadId, type: Command) {
   return async ({ dispatch, getState, client }: ThunkArgs) => {
     if (type) {
       return dispatch({
         type: "COMMAND",
         command: type,
-        cx,
-        thread: cx.thread,
-        [PROMISE]: client[type](cx.thread)
+        thread,
+        [PROMISE]: client[type](thread)
       });
     }
   };
 }
 
 /**
  * StepIn
  * @memberof actions/pause
  * @static
  * @returns {Function} {@link command}
  */
-export function stepIn(cx: ThreadContext) {
+export function stepIn() {
   return ({ dispatch, getState }: ThunkArgs) => {
-    if (cx.isPaused) {
-      return dispatch(command(cx, "stepIn"));
+    const thread = getCurrentThread(getState());
+    if (getIsPaused(getState(), thread)) {
+      return dispatch(command(thread, "stepIn"));
     }
   };
 }
 
 /**
  * stepOver
  * @memberof actions/pause
  * @static
  * @returns {Function} {@link command}
  */
-export function stepOver(cx: ThreadContext) {
+export function stepOver() {
   return ({ dispatch, getState }: ThunkArgs) => {
-    if (cx.isPaused) {
-      return dispatch(astCommand(cx, "stepOver"));
+    const thread = getCurrentThread(getState());
+    if (getIsPaused(getState(), thread)) {
+      return dispatch(astCommand(thread, "stepOver"));
     }
   };
 }
 
 /**
  * stepOut
  * @memberof actions/pause
  * @static
  * @returns {Function} {@link command}
  */
-export function stepOut(cx: ThreadContext) {
+export function stepOut() {
   return ({ dispatch, getState }: ThunkArgs) => {
-    if (cx.isPaused) {
-      return dispatch(command(cx, "stepOut"));
+    const thread = getCurrentThread(getState());
+    if (getIsPaused(getState(), thread)) {
+      return dispatch(command(thread, "stepOut"));
     }
   };
 }
 
 /**
  * resume
  * @memberof actions/pause
  * @static
  * @returns {Function} {@link command}
  */
-export function resume(cx: ThreadContext) {
+export function resume() {
   return ({ dispatch, getState }: ThunkArgs) => {
-    if (cx.isPaused) {
+    const thread = getCurrentThread(getState());
+    if (getIsPaused(getState(), thread)) {
       recordEvent("continue");
-      return dispatch(command(cx, "resume"));
+      return dispatch(command(thread, "resume"));
     }
   };
 }
 
 /**
  * rewind
  * @memberof actions/pause
  * @static
  * @returns {Function} {@link command}
  */
-export function rewind(cx: ThreadContext) {
+export function rewind() {
   return ({ dispatch, getState }: ThunkArgs) => {
-    if (cx.isPaused) {
-      return dispatch(command(cx, "rewind"));
+    const thread = getCurrentThread(getState());
+    if (getIsPaused(getState(), thread)) {
+      return dispatch(command(thread, "rewind"));
     }
   };
 }
 
 /**
  * reverseStepIn
  * @memberof actions/pause
  * @static
  * @returns {Function} {@link command}
  */
-export function reverseStepIn(cx: ThreadContext) {
+export function reverseStepIn() {
   return ({ dispatch, getState }: ThunkArgs) => {
-    if (cx.isPaused) {
-      return dispatch(command(cx, "reverseStepIn"));
+    const thread = getCurrentThread(getState());
+    if (getIsPaused(getState(), thread)) {
+      return dispatch(command(thread, "reverseStepIn"));
     }
   };
 }
 
 /**
  * reverseStepOver
  * @memberof actions/pause
  * @static
  * @returns {Function} {@link command}
  */
-export function reverseStepOver(cx: ThreadContext) {
+export function reverseStepOver() {
   return ({ dispatch, getState }: ThunkArgs) => {
-    if (cx.isPaused) {
-      return dispatch(astCommand(cx, "reverseStepOver"));
+    const thread = getCurrentThread(getState());
+    if (getIsPaused(getState(), thread)) {
+      return dispatch(astCommand(thread, "reverseStepOver"));
     }
   };
 }
 
 /**
  * reverseStepOut
  * @memberof actions/pause
  * @static
  * @returns {Function} {@link command}
  */
-export function reverseStepOut(cx: ThreadContext) {
+export function reverseStepOut() {
   return ({ dispatch, getState }: ThunkArgs) => {
-    if (cx.isPaused) {
-      return dispatch(command(cx, "reverseStepOut"));
+    const thread = getCurrentThread(getState());
+    if (getIsPaused(getState(), thread)) {
+      return dispatch(command(thread, "reverseStepOut"));
     }
   };
 }
 
 /*
  * Checks for await or yield calls on the paused line
  * This avoids potentially expensive parser calls when we are likely
  * not at an async expression.
@@ -200,31 +200,31 @@ function hasAwait(source: Source, pauseL
 }
 
 /**
  * @memberOf actions/pause
  * @static
  * @param stepType
  * @returns {function(ThunkArgs)}
  */
-export function astCommand(cx: ThreadContext, stepType: Command) {
+export function astCommand(thread: ThreadId, stepType: Command) {
   return async ({ dispatch, getState, sourceMaps }: ThunkArgs) => {
     if (!features.asyncStepping) {
-      return dispatch(command(cx, stepType));
+      return dispatch(command(thread, stepType));
     }
 
     if (stepType == "stepOver") {
       // This type definition is ambiguous:
-      const frame: any = getTopFrame(getState(), cx.thread);
+      const frame: any = getTopFrame(getState(), thread);
       const source = getSource(getState(), frame.location.sourceId);
 
       if (source && hasAwait(source, frame.location)) {
         const nextLocation = await getNextStep(source.id, frame.location);
         if (nextLocation) {
-          await dispatch(addHiddenBreakpoint(cx, nextLocation));
-          return dispatch(command(cx, "resume"));
+          await dispatch(addHiddenBreakpoint(nextLocation));
+          return dispatch(command(thread, "resume"));
         }
       }
     }
 
-    return dispatch(command(cx, stepType));
+    return dispatch(command(thread, stepType));
   };
 }
--- a/devtools/client/debugger/new/src/actions/pause/continueToHere.js
+++ b/devtools/client/debugger/new/src/actions/pause/continueToHere.js
@@ -1,49 +1,46 @@
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at <http://mozilla.org/MPL/2.0/>. */
 
 // @flow
 
 import {
+  getCurrentThread,
   getSelectedSource,
   getSelectedFrame,
   getCanRewind
 } from "../../selectors";
 import { addHiddenBreakpoint } from "../breakpoints";
 import { resume, rewind } from "./commands";
 
 import type { ThunkArgs } from "../types";
-import type { ThreadContext } from "../../types";
 
-export function continueToHere(
-  cx: ThreadContext,
-  line: number,
-  column?: number
-) {
+export function continueToHere(line: number, column?: number) {
   return async function({ dispatch, getState }: ThunkArgs) {
+    const thread = getCurrentThread(getState());
     const selectedSource = getSelectedSource(getState());
-    const selectedFrame = getSelectedFrame(getState(), cx.thread);
+    const selectedFrame = getSelectedFrame(getState(), thread);
 
     if (!selectedFrame || !selectedSource) {
       return;
     }
 
     const debugLine = selectedFrame.location.line;
     if (debugLine == line) {
       return;
     }
 
     const action =
       getCanRewind(getState()) && line < debugLine ? rewind : resume;
 
     await dispatch(
-      addHiddenBreakpoint(cx, {
+      addHiddenBreakpoint({
         line,
         column: column,
         sourceId: selectedSource.id
       })
     );
 
-    dispatch(action(cx));
+    dispatch(action());
   };
 }
--- a/devtools/client/debugger/new/src/actions/pause/fetchScopes.js
+++ b/devtools/client/debugger/new/src/actions/pause/fetchScopes.js
@@ -2,29 +2,28 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at <http://mozilla.org/MPL/2.0/>. */
 
 // @flow
 
 import { getSelectedFrame, getGeneratedFrameScope } from "../../selectors";
 import { mapScopes } from "./mapScopes";
 import { PROMISE } from "../utils/middleware/promise";
-import type { ThreadContext } from "../../types";
+import type { ThreadId } from "../../types";
 import type { ThunkArgs } from "../types";
 
-export function fetchScopes(cx: ThreadContext) {
+export function fetchScopes(thread: ThreadId) {
   return async function({ dispatch, getState, client, sourceMaps }: ThunkArgs) {
-    const frame = getSelectedFrame(getState(), cx.thread);
+    const frame = getSelectedFrame(getState(), thread);
     if (!frame || getGeneratedFrameScope(getState(), frame.id)) {
       return;
     }
 
     const scopes = dispatch({
       type: "ADD_SCOPES",
-      cx,
-      thread: cx.thread,
+      thread,
       frame,
       [PROMISE]: client.getFrameScopes(frame)
     });
 
-    await dispatch(mapScopes(cx, scopes, frame));
+    await dispatch(mapScopes(scopes, frame));
   };
 }
--- a/devtools/client/debugger/new/src/actions/pause/mapFrames.js
+++ b/devtools/client/debugger/new/src/actions/pause/mapFrames.js
@@ -9,17 +9,17 @@ import {
   getSymbols,
   getSource,
   getSelectedFrame
 } from "../../selectors";
 
 import assert from "../../utils/assert";
 import { findClosestFunction } from "../../utils/ast";
 
-import type { Frame, ThreadContext } from "../../types";
+import type { Frame, ThreadId } from "../../types";
 import type { State } from "../../reducers/types";
 import type { ThunkArgs } from "../types";
 
 import { isGeneratedId } from "devtools-source-map";
 
 function isFrameBlackboxed(state, frame) {
   const source = getSource(state, frame.location.sourceId);
   return source && source.isBlackBoxed;
@@ -156,33 +156,32 @@ async function expandFrames(
  * Map call stack frame locations and display names to originals.
  * e.g.
  * 1. When the debuggee pauses
  * 2. When a source is pretty printed
  * 3. When symbols are loaded
  * @memberof actions/pause
  * @static
  */
-export function mapFrames(cx: ThreadContext) {
+export function mapFrames(thread: ThreadId) {
   return async function({ dispatch, getState, sourceMaps }: ThunkArgs) {
-    const frames = getFrames(getState(), cx.thread);
+    const frames = getFrames(getState(), thread);
     if (!frames) {
       return;
     }
 
     let mappedFrames = await updateFrameLocations(frames, sourceMaps);
     mappedFrames = await expandFrames(mappedFrames, sourceMaps, getState);
     mappedFrames = mapDisplayNames(mappedFrames, getState);
 
     const selectedFrameId = getSelectedFrameId(
       getState(),
-      cx.thread,
+      thread,
       mappedFrames
     );
     dispatch({
       type: "MAP_FRAMES",
-      cx,
-      thread: cx.thread,
+      thread,
       frames: mappedFrames,
       selectedFrameId
     });
   };
 }
--- a/devtools/client/debugger/new/src/actions/pause/mapScopes.js
+++ b/devtools/client/debugger/new/src/actions/pause/mapScopes.js
@@ -5,90 +5,81 @@
 // @flow
 
 import {
   getSource,
   getMapScopes,
   getSelectedFrame,
   getSelectedGeneratedScope,
   getSelectedOriginalScope,
-  getThreadContext
+  getCurrentThread
 } from "../../selectors";
 import { loadSourceText } from "../sources/loadSourceText";
 import { PROMISE } from "../utils/middleware/promise";
-import assert from "../../utils/assert";
 
 import { features } from "../../utils/prefs";
 import { log } from "../../utils/log";
 import { isGenerated, isOriginal } from "../../utils/source";
-import type { Frame, Scope, ThreadContext } from "../../types";
+import type { Frame, Scope } from "../../types";
 
 import type { ThunkArgs } from "../types";
 
 import { buildMappedScopes } from "../../utils/pause/mapScopes";
 
 export function toggleMapScopes() {
   return async function({ dispatch, getState, client, sourceMaps }: ThunkArgs) {
     if (getMapScopes(getState())) {
       return dispatch({ type: "TOGGLE_MAP_SCOPES", mapScopes: false });
     }
 
     dispatch({ type: "TOGGLE_MAP_SCOPES", mapScopes: true });
 
-    const cx = getThreadContext(getState());
-
-    if (getSelectedOriginalScope(getState(), cx.thread)) {
+    const thread = getCurrentThread(getState());
+    if (getSelectedOriginalScope(getState(), thread)) {
       return;
     }
 
-    const scopes = getSelectedGeneratedScope(getState(), cx.thread);
-    const frame = getSelectedFrame(getState(), cx.thread);
+    const scopes = getSelectedGeneratedScope(getState(), thread);
+    const frame = getSelectedFrame(getState(), thread);
     if (!scopes || !frame) {
       return;
     }
 
-    dispatch(mapScopes(cx, Promise.resolve(scopes.scope), frame));
+    dispatch(mapScopes(Promise.resolve(scopes.scope), frame));
   };
 }
 
-export function mapScopes(
-  cx: ThreadContext,
-  scopes: Promise<Scope>,
-  frame: Frame
-) {
+export function mapScopes(scopes: Promise<Scope>, frame: Frame) {
   return async function({ dispatch, getState, client, sourceMaps }: ThunkArgs) {
-    assert(cx.thread == frame.thread, "Thread mismatch");
-
     const generatedSource = getSource(
       getState(),
       frame.generatedLocation.sourceId
     );
 
     const source = getSource(getState(), frame.location.sourceId);
 
     await dispatch({
       type: "MAP_SCOPES",
-      cx,
-      thread: cx.thread,
+      thread: frame.thread,
       frame,
       [PROMISE]: (async function() {
         if (
           !features.mapScopes ||
           !source ||
           !generatedSource ||
           generatedSource.isWasm ||
           source.isPrettyPrinted ||
           isGenerated(source)
         ) {
           return null;
         }
 
-        await dispatch(loadSourceText(cx, source));
+        await dispatch(loadSourceText(source));
         if (isOriginal(source)) {
-          await dispatch(loadSourceText(cx, generatedSource));
+          await dispatch(loadSourceText(generatedSource));
         }
 
         try {
           return await buildMappedScopes(
             source,
             frame,
             await scopes,
             sourceMaps,
--- a/devtools/client/debugger/new/src/actions/pause/paused.js
+++ b/devtools/client/debugger/new/src/actions/pause/paused.js
@@ -2,26 +2,24 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at <http://mozilla.org/MPL/2.0/>. */
 
 // @flow
 import {
   getHiddenBreakpoint,
   isEvaluatingExpression,
   getSelectedFrame,
-  wasStepping,
-  getThreadContext
+  wasStepping
 } from "../../selectors";
 
 import { mapFrames } from ".";
 import { removeBreakpoint } from "../breakpoints";
 import { evaluateExpressions } from "../expressions";
 import { selectLocation } from "../sources";
 import { togglePaneCollapse } from "../ui";
-import assert from "../../utils/assert";
 
 import { fetchScopes } from "./fetchScopes";
 
 import type { Pause } from "../../types";
 import type { ThunkArgs } from "../types";
 
 /**
  * Debugger has just paused
@@ -39,38 +37,34 @@ export function paused(pauseInfo: Pause)
       type: "PAUSED",
       thread,
       why,
       frames,
       selectedFrameId: topFrame ? topFrame.id : undefined,
       loadedObjects: loadedObjects || []
     });
 
-    // Get a context capturing the newly paused and selected thread.
-    const cx = getThreadContext(getState());
-    assert(cx.thread == thread, "Thread mismatch");
-
     const hiddenBreakpoint = getHiddenBreakpoint(getState());
     if (hiddenBreakpoint) {
-      dispatch(removeBreakpoint(cx, hiddenBreakpoint));
+      dispatch(removeBreakpoint(hiddenBreakpoint));
     }
 
-    await dispatch(mapFrames(cx));
+    await dispatch(mapFrames(thread));
 
     const selectedFrame = getSelectedFrame(getState(), thread);
     if (selectedFrame) {
-      await dispatch(selectLocation(cx, selectedFrame.location));
+      await dispatch(selectLocation(selectedFrame.location));
     }
 
     if (!wasStepping(getState(), thread)) {
       dispatch(togglePaneCollapse("end", false));
     }
 
-    await dispatch(fetchScopes(cx));
+    await dispatch(fetchScopes(thread));
 
     // Run after fetching scoping data so that it may make use of the sourcemap
     // expression mappings for local variables.
     const atException = why.type == "exception";
     if (!atException || !isEvaluatingExpression(getState(), thread)) {
-      await dispatch(evaluateExpressions(cx));
+      await dispatch(evaluateExpressions());
     }
   };
 }
--- a/devtools/client/debugger/new/src/actions/pause/resumed.js
+++ b/devtools/client/debugger/new/src/actions/pause/resumed.js
@@ -1,15 +1,15 @@
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at <http://mozilla.org/MPL/2.0/>. */
 
 // @flow
 
-import { isStepping, getPauseReason, getThreadContext } from "../../selectors";
+import { isStepping, getPauseReason } from "../../selectors";
 import { evaluateExpressions } from "../expressions";
 import { inDebuggerEval } from "../../utils/pause";
 
 import type { ThunkArgs } from "../types";
 import type { ResumedPacket } from "../../client/firefox/types";
 
 /**
  * Debugger has just resumed
@@ -21,14 +21,13 @@ export function resumed(packet: ResumedP
   return async ({ dispatch, client, getState }: ThunkArgs) => {
     const thread = packet.from;
     const why = getPauseReason(getState(), thread);
     const wasPausedInEval = inDebuggerEval(why);
     const wasStepping = isStepping(getState(), thread);
 
     dispatch({ type: "RESUME", thread, wasStepping });
 
-    const cx = getThreadContext(getState());
-    if (!wasStepping && !wasPausedInEval && cx.thread == thread) {
-      await dispatch(evaluateExpressions(cx));
+    if (!wasStepping && !wasPausedInEval) {
+      await dispatch(evaluateExpressions());
     }
   };
 }
--- a/devtools/client/debugger/new/src/actions/pause/selectFrame.js
+++ b/devtools/client/debugger/new/src/actions/pause/selectFrame.js
@@ -2,34 +2,30 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at <http://mozilla.org/MPL/2.0/>. */
 
 // @flow
 
 import { selectLocation } from "../sources";
 import { evaluateExpressions } from "../expressions";
 import { fetchScopes } from "./fetchScopes";
-import assert from "../../utils/assert";
 
-import type { Frame, ThreadContext } from "../../types";
+import type { Frame } from "../../types";
 import type { ThunkArgs } from "../types";
 
 /**
  * @memberof actions/pause
  * @static
  */
-export function selectFrame(cx: ThreadContext, frame: Frame) {
+export function selectFrame(frame: Frame) {
   return async ({ dispatch, client, getState, sourceMaps }: ThunkArgs) => {
-    assert(cx.thread == frame.thread, "Thread mismatch");
-
     dispatch({
       type: "SELECT_FRAME",
-      cx,
-      thread: cx.thread,
+      thread: frame.thread,
       frame
     });
 
-    dispatch(selectLocation(cx, frame.location));
+    dispatch(selectLocation(frame.location));
 
-    dispatch(evaluateExpressions(cx));
-    dispatch(fetchScopes(cx));
+    dispatch(evaluateExpressions());
+    dispatch(fetchScopes(frame.thread));
   };
 }
--- a/devtools/client/debugger/new/src/actions/pause/setPopupObjectProperties.js
+++ b/devtools/client/debugger/new/src/actions/pause/setPopupObjectProperties.js
@@ -1,35 +1,30 @@
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at <http://mozilla.org/MPL/2.0/>. */
 
 // @flow
 
-import { getPopupObjectProperties } from "../../selectors";
+import { getPopupObjectProperties, getCurrentThread } from "../../selectors";
 import type { ThunkArgs } from "../types";
-import type { ThreadContext } from "../../types";
 
 /**
  * @memberof actions/pause
  * @static
  */
-export function setPopupObjectProperties(
-  cx: ThreadContext,
-  object: any,
-  properties: Object
-) {
+export function setPopupObjectProperties(object: any, properties: Object) {
   return ({ dispatch, client, getState }: ThunkArgs) => {
     const objectId = object.actor || object.objectId;
+    const thread = getCurrentThread(getState());
 
-    if (getPopupObjectProperties(getState(), cx.thread, object.actor)) {
+    if (getPopupObjectProperties(getState(), thread, object.actor)) {
       return;
     }
 
     dispatch({
       type: "SET_POPUP_OBJECT_PROPERTIES",
-      cx,
-      thread: cx.thread,
+      thread,
       objectId,
       properties
     });
   };
 }
--- a/devtools/client/debugger/new/src/actions/pause/tests/pause.spec.js
+++ b/devtools/client/debugger/new/src/actions/pause/tests/pause.spec.js
@@ -104,121 +104,116 @@ function resumedPacket() {
 describe("pause", () => {
   describe("stepping", () => {
     it("should set and clear the command", async () => {
       const { dispatch, getState } = createStore(mockThreadClient);
       const mockPauseInfo = createPauseInfo();
 
       await dispatch(actions.newSource(makeSource("foo1")));
       await dispatch(actions.paused(mockPauseInfo));
-      const cx = selectors.getThreadContext(getState());
-      const stepped = dispatch(actions.stepIn(cx));
+      const stepped = dispatch(actions.stepIn());
       expect(isStepping(getState(), "FakeThread")).toBeTruthy();
       if (!stepInResolve) {
         throw new Error("no stepInResolve");
       }
       await stepInResolve();
       await stepped;
       expect(isStepping(getState(), "FakeThread")).toBeFalsy();
     });
 
     it("should only step when paused", async () => {
       const client = { stepIn: jest.fn() };
-      const { dispatch, cx } = createStore(client);
+      const { dispatch } = createStore(client);
 
-      dispatch(actions.stepIn(cx));
+      dispatch(actions.stepIn());
       expect(client.stepIn.mock.calls).toHaveLength(0);
     });
 
     it("should step when paused", async () => {
       const { dispatch, getState } = createStore(mockThreadClient);
       const mockPauseInfo = createPauseInfo();
 
       await dispatch(actions.newSource(makeSource("foo1")));
       await dispatch(actions.paused(mockPauseInfo));
-      const cx = selectors.getThreadContext(getState());
-      dispatch(actions.stepIn(cx));
+      dispatch(actions.stepIn());
       expect(isStepping(getState(), "FakeThread")).toBeTruthy();
     });
 
     it("should step over when paused", async () => {
       const store = createStore(mockThreadClient);
       const { dispatch, getState } = store;
       const mockPauseInfo = createPauseInfo();
 
       await dispatch(actions.newSource(makeSource("foo1")));
       await dispatch(actions.paused(mockPauseInfo));
-      const cx = selectors.getThreadContext(getState());
       const getNextStepSpy = jest.spyOn(parser, "getNextStep");
-      dispatch(actions.stepOver(cx));
+      dispatch(actions.stepOver());
       expect(getNextStepSpy).not.toBeCalled();
       expect(isStepping(getState(), "FakeThread")).toBeTruthy();
     });
 
     it("should step over when paused before an await", async () => {
       const store = createStore(mockThreadClient);
-      const { dispatch, getState, cx } = store;
+      const { dispatch } = store;
       const mockPauseInfo = createPauseInfo({
         sourceId: "await",
         line: 2,
         column: 0
       });
 
       const source = makeSource("await");
       await dispatch(actions.newSource(source));
-      await dispatch(actions.loadSourceText(cx, source));
+      await dispatch(actions.loadSourceText(source));
 
       await dispatch(actions.paused(mockPauseInfo));
-      const ncx = selectors.getThreadContext(getState());
       const getNextStepSpy = jest.spyOn(parser, "getNextStep");
-      dispatch(actions.stepOver(ncx));
+      dispatch(actions.stepOver());
       expect(getNextStepSpy).toBeCalled();
       getNextStepSpy.mockRestore();
     });
 
     it("should step over when paused after an await", async () => {
       const store = createStore(mockThreadClient);
-      const { dispatch, getState, cx } = store;
+      const { dispatch } = store;
       const mockPauseInfo = createPauseInfo({
         sourceId: "await",
         line: 2,
         column: 6
       });
 
       const source = makeSource("await");
       await dispatch(actions.newSource(source));
-      await dispatch(actions.loadSourceText(cx, source));
+      await dispatch(actions.loadSourceText(source));
 
       await dispatch(actions.paused(mockPauseInfo));
-      const ncx = selectors.getThreadContext(getState());
       const getNextStepSpy = jest.spyOn(parser, "getNextStep");
-      dispatch(actions.stepOver(ncx));
+      dispatch(actions.stepOver());
       expect(getNextStepSpy).toBeCalled();
       getNextStepSpy.mockRestore();
     });
 
     it("getting frame scopes with bindings", async () => {
       const generatedLocation = {
         sourceId: "foo",
         line: 1,
         column: 0
       };
 
       const store = createStore(mockThreadClient, {});
-      const { dispatch, getState, cx } = store;
+      const { dispatch, getState } = store;
       const mockPauseInfo = createPauseInfo(generatedLocation, {
         scope: {
           bindings: { variables: { b: {} }, arguments: [{ a: {} }] }
         }
       });
 
       const source = makeSource("foo");
       await dispatch(actions.newSource(source));
       await dispatch(actions.newSource(makeOriginalSource("foo")));
-      await dispatch(actions.loadSourceText(cx, source));
+      await dispatch(actions.loadSourceText(source));
 
       await dispatch(actions.paused(mockPauseInfo));
       expect(selectors.getFrames(getState(), "FakeThread")).toEqual([
         {
           generatedLocation: { column: 0, line: 1, sourceId: "foo" },
           id: mockFrameId,
           location: { column: 0, line: 1, sourceId: "foo" },
           scope: {
@@ -265,26 +260,26 @@ describe("pause", () => {
         getOriginalSourceText: async () => ({
           source: "\n\nfunction fooOriginal() {\n  return -5;\n}",
           contentType: "text/javascript"
         }),
         getGeneratedLocation: async location => location
       };
 
       const store = createStore(mockThreadClient, {}, sourceMapsMock);
-      const { dispatch, getState, cx } = store;
+      const { dispatch, getState } = store;
       const mockPauseInfo = createPauseInfo(generatedLocation);
 
       const fooSource = makeSource("foo");
       const fooOriginalSource = makeSource("foo-original");
       await dispatch(actions.newSource(fooSource));
       await dispatch(actions.newSource(fooOriginalSource));
-      await dispatch(actions.loadSourceText(cx, fooSource));
-      await dispatch(actions.loadSourceText(cx, fooOriginalSource));
-      await dispatch(actions.setSymbols(cx, "foo-original"));
+      await dispatch(actions.loadSourceText(fooSource));
+      await dispatch(actions.loadSourceText(fooOriginalSource));
+      await dispatch(actions.setSymbols("foo-original"));
 
       await dispatch(actions.paused(mockPauseInfo));
       expect(selectors.getFrames(getState(), "FakeThread")).toEqual([
         {
           generatedLocation: { column: 0, line: 1, sourceId: "foo" },
           id: mockFrameId,
           location: { column: 0, line: 3, sourceId: "foo-original" },
           originalDisplayName: "fooOriginal",
@@ -331,26 +326,26 @@ describe("pause", () => {
         getOriginalSourceText: async () => ({
           source: "fn fooBar() {}\nfn barZoo() { fooBar() }",
           contentType: "text/rust"
         }),
         getGeneratedRangesForOriginal: async () => []
       };
 
       const store = createStore(mockThreadClient, {}, sourceMapsMock);
-      const { dispatch, getState, cx } = store;
+      const { dispatch, getState } = store;
       const mockPauseInfo = createPauseInfo(generatedLocation);
 
       const source = makeSource("foo-wasm", { isWasm: true });
       const originalSource = makeOriginalSource("foo-wasm");
 
       await dispatch(actions.newSource(source));
       await dispatch(actions.newSource(originalSource));
-      await dispatch(actions.loadSourceText(cx, source));
-      await dispatch(actions.loadSourceText(cx, originalSource));
+      await dispatch(actions.loadSourceText(source));
+      await dispatch(actions.loadSourceText(originalSource));
 
       await dispatch(actions.paused(mockPauseInfo));
       expect(selectors.getFrames(getState(), "FakeThread")).toEqual([
         {
           displayName: "fooBar",
           generatedLocation: { column: 0, line: 1, sourceId: "foo-wasm" },
           id: mockFrameId,
           isOriginal: true,
@@ -374,36 +369,32 @@ describe("pause", () => {
           thread: "FakeThread"
         }
       ]);
     });
   });
 
   describe("resumed", () => {
     it("should not evaluate expression while stepping", async () => {
-      const client = { ...mockThreadClient, evaluateExpressions: jest.fn() };
-      const { dispatch, getState } = createStore(client);
-      const mockPauseInfo = createPauseInfo();
+      const client = { evaluateExpressions: jest.fn() };
+      const { dispatch } = createStore(client);
 
-      await dispatch(actions.paused(mockPauseInfo));
-
-      const cx = selectors.getThreadContext(getState());
-      dispatch(actions.stepIn(cx));
+      dispatch(actions.stepIn());
       await dispatch(actions.resumed(resumedPacket()));
       expect(client.evaluateExpressions.mock.calls).toHaveLength(1);
     });
 
     it("resuming - will re-evaluate watch expressions", async () => {
       const store = createStore(mockThreadClient);
-      const { dispatch, getState, cx } = store;
+      const { dispatch, getState } = store;
       const mockPauseInfo = createPauseInfo();
 
       await dispatch(actions.newSource(makeSource("foo1")));
       await dispatch(actions.newSource(makeSource("foo")));
-      await dispatch(actions.addExpression(cx, "foo"));
+      dispatch(actions.addExpression("foo"));
       await waitForState(store, state => selectors.getExpression(state, "foo"));
 
       mockThreadClient.evaluateExpressions = () => new Promise(r => r(["YAY"]));
       await dispatch(actions.paused(mockPauseInfo));
 
       await dispatch(actions.resumed(resumedPacket()));
       const expression = selectors.getExpression(getState(), "foo");
       expect(expression.value).toEqual("YAY");
--- a/devtools/client/debugger/new/src/actions/preview.js
+++ b/devtools/client/debugger/new/src/actions/preview.js
@@ -17,17 +17,17 @@ import {
   getSelectedFrame,
   getSymbols,
   getCurrentThread
 } from "../selectors";
 
 import { getMappedExpression } from "./expressions";
 
 import type { Action, ThunkArgs } from "./types";
-import type { Position, Context } from "../types";
+import type { Position } from "../types";
 import type { AstLocation } from "../workers/parser";
 
 function findExpressionMatch(state, codeMirror, tokenPos) {
   const source = getSelectedSource(state);
   if (!source) {
     return;
   }
 
@@ -38,17 +38,16 @@ function findExpressionMatch(state, code
     match = getExpressionFromCoords(codeMirror, tokenPos);
   } else {
     match = findBestMatchExpression(symbols, tokenPos);
   }
   return match;
 }
 
 export function updatePreview(
-  cx: Context,
   target: HTMLElement,
   tokenPos: Object,
   codeMirror: any
 ) {
   return ({ dispatch, getState, client, sourceMaps }: ThunkArgs) => {
     const cursorPos = target.getBoundingClientRect();
 
     if (
@@ -64,31 +63,29 @@ export function updatePreview(
     }
 
     const { expression, location } = match;
 
     if (isConsole(expression)) {
       return;
     }
 
-    dispatch(setPreview(cx, expression, location, tokenPos, cursorPos));
+    dispatch(setPreview(expression, location, tokenPos, cursorPos));
   };
 }
 
 export function setPreview(
-  cx: Context,
   expression: string,
   location: AstLocation,
   tokenPos: Position,
   cursorPos: ClientRect
 ) {
   return async ({ dispatch, getState, client, sourceMaps }: ThunkArgs) => {
     await dispatch({
       type: "SET_PREVIEW",
-      cx,
       [PROMISE]: (async function() {
         const source = getSelectedSource(getState());
         if (!source) {
           return;
         }
 
         const thread = getCurrentThread(getState());
         const selectedFrame = getSelectedFrame(getState(), thread);
@@ -124,23 +121,22 @@ export function setPreview(
           tokenPos,
           cursorPos
         };
       })()
     });
   };
 }
 
-export function clearPreview(cx: Context) {
+export function clearPreview() {
   return ({ dispatch, getState, client }: ThunkArgs) => {
     const currentSelection = getPreview(getState());
     if (!currentSelection) {
       return;
     }
 
     return dispatch(
       ({
-        type: "CLEAR_SELECTION",
-        cx
+        type: "CLEAR_SELECTION"
       }: Action)
     );
   };
 }
--- a/devtools/client/debugger/new/src/actions/project-text-search.js
+++ b/devtools/client/debugger/new/src/actions/project-text-search.js
@@ -15,109 +15,103 @@ import { isThirdParty } from "../utils/s
 import { loadSourceText } from "./sources/loadSourceText";
 import {
   statusType,
   getTextSearchOperation,
   getTextSearchStatus
 } from "../reducers/project-text-search";
 
 import type { Action, ThunkArgs } from "./types";
-import type { Context } from "../types";
 import type { SearchOperation } from "../reducers/project-text-search";
 
-export function addSearchQuery(cx: Context, query: string): Action {
-  return { type: "ADD_QUERY", cx, query };
+export function addSearchQuery(query: string): Action {
+  return { type: "ADD_QUERY", query };
 }
 
-export function addOngoingSearch(
-  cx: Context,
-  ongoingSearch: SearchOperation
-): Action {
-  return { type: "ADD_ONGOING_SEARCH", cx, ongoingSearch };
+export function addOngoingSearch(ongoingSearch: SearchOperation): Action {
+  return { type: "ADD_ONGOING_SEARCH", ongoingSearch };
 }
 
 export function addSearchResult(
-  cx: Context,
   sourceId: string,
   filepath: string,
   matches: Object[]
 ): Action {
   return {
     type: "ADD_SEARCH_RESULT",
-    cx,
     result: { sourceId, filepath, matches }
   };
 }
 
-export function clearSearchResults(cx: Context): Action {
-  return { type: "CLEAR_SEARCH_RESULTS", cx };
+export function clearSearchResults(): Action {
+  return { type: "CLEAR_SEARCH_RESULTS" };
 }
 
-export function clearSearch(cx: Context): Action {
-  return { type: "CLEAR_SEARCH", cx };
+export function clearSearch(): Action {
+  return { type: "CLEAR_SEARCH" };
 }
 
-export function updateSearchStatus(cx: Context, status: string): Action {
-  return { type: "UPDATE_STATUS", cx, status };
+export function updateSearchStatus(status: string): Action {
+  return { type: "UPDATE_STATUS", status };
 }
 
-export function closeProjectSearch(cx: Context) {
+export function closeProjectSearch() {
   return ({ dispatch, getState }: ThunkArgs) => {
-    dispatch(stopOngoingSearch(cx));
+    dispatch(stopOngoingSearch());
     dispatch({ type: "CLOSE_PROJECT_SEARCH" });
   };
 }
 
-export function stopOngoingSearch(cx: Context) {
+export function stopOngoingSearch() {
   return ({ dispatch, getState }: ThunkArgs) => {
     const state = getState();
     const ongoingSearch = getTextSearchOperation(state);
     const status = getTextSearchStatus(state);
     if (ongoingSearch && status !== statusType.done) {
       ongoingSearch.cancel();
-      dispatch(updateSearchStatus(cx, statusType.cancelled));
+      dispatch(updateSearchStatus(statusType.cancelled));
     }
   };
 }
 
-export function searchSources(cx: Context, query: string) {
+export function searchSources(query: string) {
   let cancelled = false;
 
   const search = async ({ dispatch, getState }: ThunkArgs) => {
-    dispatch(stopOngoingSearch(cx));
-    await dispatch(addOngoingSearch(cx, search));
-    await dispatch(clearSearchResults(cx));
-    await dispatch(addSearchQuery(cx, query));
-    dispatch(updateSearchStatus(cx, statusType.fetching));
+    dispatch(stopOngoingSearch());
+    await dispatch(addOngoingSearch(search));
+    await dispatch(clearSearchResults());
+    await dispatch(addSearchQuery(query));
+    dispatch(updateSearchStatus(statusType.fetching));
     const validSources = getSourceList(getState()).filter(
       source => !hasPrettySource(getState(), source.id) && !isThirdParty(source)
     );
     for (const source of validSources) {
       if (cancelled) {
         return;
       }
-      await dispatch(loadSourceText(cx, source));
-      await dispatch(searchSource(cx, source.id, query));
+      await dispatch(loadSourceText(source));
+      await dispatch(searchSource(source.id, query));
     }
-    dispatch(updateSearchStatus(cx, statusType.done));
+    dispatch(updateSearchStatus(statusType.done));
   };
 
   search.cancel = () => {
     cancelled = true;
   };
 
   return search;
 }
 
-export function searchSource(cx: Context, sourceId: string, query: string) {
+export function searchSource(sourceId: string, query: string) {
   return async ({ dispatch, getState }: ThunkArgs) => {
     const source = getSource(getState(), sourceId);
     if (!source) {
       return;
     }
 
     const matches = await findSourceMatches(source, query);
     if (!matches.length) {
       return;
     }
-    dispatch(addSearchResult(cx, source.id, source.url, matches));
+    dispatch(addSearchResult(source.id, source.url, matches));
   };
 }
--- a/devtools/client/debugger/new/src/actions/source-tree.js
+++ b/devtools/client/debugger/new/src/actions/source-tree.js
@@ -1,29 +1,27 @@
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at <http://mozilla.org/MPL/2.0/>. */
 // @flow
 
 import type { Action, FocusItem, ThunkArgs } from "./types";
-import type { Context } from "../types";
 
 export function setExpandedState(thread: string, expanded: Set<string>) {
   return ({ dispatch, getState }: ThunkArgs) => {
     dispatch(
       ({
         type: "SET_EXPANDED_STATE",
         thread,
         expanded
       }: Action)
     );
   };
 }
 
-export function focusItem(cx: Context, item: FocusItem) {
+export function focusItem(item: FocusItem) {
   return ({ dispatch, getState }: ThunkArgs) => {
     dispatch({
       type: "SET_FOCUSED_SOURCE_ITEM",
-      cx,
       item
     });
   };
 }
--- a/devtools/client/debugger/new/src/actions/sources/blackbox.js
+++ b/devtools/client/debugger/new/src/actions/sources/blackbox.js
@@ -11,28 +11,28 @@
 
 import { isOriginalId, originalToGeneratedId } from "devtools-source-map";
 import { recordEvent } from "../../utils/telemetry";
 import { features } from "../../utils/prefs";
 import { getSourceFromId } from "../../selectors";
 
 import { PROMISE } from "../utils/middleware/promise";
 
-import type { Source, Context } from "../../types";
+import type { Source } from "../../types";
 import type { ThunkArgs } from "../types";
 
 async function blackboxActors(state, client, sourceId, isBlackBoxed, range?) {
   const source = getSourceFromId(state, sourceId);
   for (const sourceActor of source.actors) {
     await client.blackBox(sourceActor, isBlackBoxed, range);
   }
   return { isBlackBoxed: !isBlackBoxed };
 }
 
-export function toggleBlackBox(cx: Context, source: Source) {
+export function toggleBlackBox(source: Source) {
   return async ({ dispatch, getState, client, sourceMaps }: ThunkArgs) => {
     const { isBlackBoxed } = source;
 
     if (!isBlackBoxed) {
       recordEvent("blackbox");
     }
 
     let sourceId, range;
@@ -40,17 +40,16 @@ export function toggleBlackBox(cx: Conte
       range = await sourceMaps.getFileGeneratedRange(source);
       sourceId = originalToGeneratedId(source.id);
     } else {
       sourceId = source.id;
     }
 
     return dispatch({
       type: "BLACKBOX",
-      cx,
       source,
       [PROMISE]: blackboxActors(
         getState(),
         client,
         sourceId,
         isBlackBoxed,
         range
       )
--- a/devtools/client/debugger/new/src/actions/sources/loadSourceText.js
+++ b/devtools/client/debugger/new/src/actions/sources/loadSourceText.js
@@ -15,17 +15,17 @@ import { setBreakpointPositions } from "
 import { prettyPrintSource } from "./prettyPrint";
 
 import * as parser from "../../workers/parser";
 import { isLoaded, isOriginal, isPretty } from "../../utils/source";
 import { Telemetry } from "devtools-modules";
 
 import type { ThunkArgs } from "../types";
 
-import type { Source, Context } from "../../types";
+import type { Source } from "../../types";
 
 const requests = new Map();
 
 // Measures the time it takes for a source to load
 const loadSourceHistogram = "DEVTOOLS_DEBUGGER_LOAD_SOURCE_MS";
 const telemetry = new Telemetry();
 
 async function loadSource(
@@ -63,17 +63,16 @@ async function loadSource(
 
   return {
     text: response.source,
     contentType: response.contentType || "text/javascript"
   };
 }
 
 async function loadSourceTextPromise(
-  cx: Context,
   source: Source,
   epoch: number,
   { dispatch, getState, client, sourceMaps }: ThunkArgs
 ): Promise<?Source> {
   if (isLoaded(source)) {
     return source;
   }
 
@@ -86,44 +85,44 @@ async function loadSourceTextPromise(
 
   const newSource = getSource(getState(), source.id);
   if (!newSource) {
     return;
   }
 
   if (!newSource.isWasm && isLoaded(newSource)) {
     parser.setSource(newSource);
-    dispatch(setBreakpointPositions(cx, newSource.id));
+    dispatch(setBreakpointPositions(newSource.id));
   }
 
   return newSource;
 }
 
 /**
  * @memberof actions/sources
  * @static
  */
-export function loadSourceText(cx: Context, inputSource: ?Source) {
+export function loadSourceText(inputSource: ?Source) {
   return async (thunkArgs: ThunkArgs) => {
     if (!inputSource) {
       return;
     }
 
     // This ensures that the falsy check above is preserved into the IIFE
     // below in a way that Flow is happy with.
     const source = inputSource;
 
     const epoch = getSourcesEpoch(thunkArgs.getState());
 
     const id = `${epoch}:${source.id}`;
     let promise = requests.get(id);
     if (!promise) {
       promise = (async () => {
         try {
-          return await loadSourceTextPromise(cx, source, epoch, thunkArgs);
+          return await loadSourceTextPromise(source, epoch, thunkArgs);
         } catch (e) {
           // TODO: This swallows errors for now. Ideally we would get rid of
           // this once we have a better handle on our async state management.
         } finally {
           requests.delete(id);
         }
       })();
       requests.set(id, promise);
--- a/devtools/client/debugger/new/src/actions/sources/newSources.js
+++ b/devtools/client/debugger/new/src/actions/sources/newSources.js
@@ -23,24 +23,23 @@ import {
   isOriginal,
   isInlineScript
 } from "../../utils/source";
 import {
   getBlackBoxList,
   getSource,
   getPendingSelectedLocation,
   getPendingBreakpointsForSource,
-  hasBreakpointPositions,
-  getContext
+  hasBreakpointPositions
 } from "../../selectors";
 
 import { prefs } from "../../utils/prefs";
 import sourceQueue from "../../utils/source-queue";
 
-import type { Source, SourceId, Context } from "../../types";
+import type { Source, SourceId } from "../../types";
 import type { Action, ThunkArgs } from "../types";
 
 function createOriginalSource(
   originalUrl,
   generatedSource,
   sourceMaps
 ): Source {
   return {
@@ -53,47 +52,47 @@ function createOriginalSource(
     loadedState: "unloaded",
     introductionUrl: null,
     introductionType: undefined,
     isExtension: false,
     actors: []
   };
 }
 
-function loadSourceMaps(cx: Context, sources: Source[]) {
+function loadSourceMaps(sources: Source[]) {
   return async function({
     dispatch,
     sourceMaps
   }: ThunkArgs): Promise<Promise<Source>[]> {
     const sourceList = await Promise.all(
       sources.map(async ({ id }) => {
-        const originalSources = await dispatch(loadSourceMap(cx, id));
+        const originalSources = await dispatch(loadSourceMap(id));
         sourceQueue.queueSources(originalSources);
         return originalSources;
       })
     );
 
     await sourceQueue.flush();
 
     // We would like to sync breakpoints after we are done
     // loading source maps as sometimes generated and original
     // files share the same paths.
     for (const source of sources) {
-      dispatch(checkPendingBreakpoints(cx, source.id));
+      dispatch(checkPendingBreakpoints(source.id));
     }
 
     return flatten(sourceList);
   };
 }
 
 /**
  * @memberof actions/sources
  * @static
  */
-function loadSourceMap(cx: Context, sourceId: SourceId) {
+function loadSourceMap(sourceId: SourceId) {
   return async function({
     dispatch,
     getState,
     sourceMaps
   }: ThunkArgs): Promise<Source[]> {
     const source = getSource(getState(), sourceId);
 
     if (
@@ -127,61 +126,60 @@ function loadSourceMap(cx: Context, sour
       // this was previously using 'source' and was at risk of resetting the
       // 'loadedState' field to 'loading', putting it in an inconsistent state.
       const currentSource = getSource(getState(), sourceId);
 
       // If this source doesn't have a sourcemap, enable it for pretty printing
       dispatch(
         ({
           type: "UPDATE_SOURCE",
-          cx,
           // NOTE: Flow https://github.com/facebook/flow/issues/6342 issue
           source: (({ ...currentSource, sourceMapURL: "" }: any): Source)
         }: Action)
       );
       return [];
     }
 
     return urls.map(url => createOriginalSource(url, source, sourceMaps));
   };
 }
 
 // If a request has been made to show this source, go ahead and
 // select it.
-function checkSelectedSource(cx: Context, sourceId: string) {
+function checkSelectedSource(sourceId: string) {
   return async ({ dispatch, getState }: ThunkArgs) => {
     const source = getSource(getState(), sourceId);
     const pendingLocation = getPendingSelectedLocation(getState());
 
     if (!pendingLocation || !pendingLocation.url || !source || !source.url) {
       return;
     }
 
     const pendingUrl = pendingLocation.url;
     const rawPendingUrl = getRawSourceURL(pendingUrl);
 
     if (rawPendingUrl === source.url) {
       if (isPrettyURL(pendingUrl)) {
-        const prettySource = await dispatch(togglePrettyPrint(cx, source.id));
-        return dispatch(checkPendingBreakpoints(cx, prettySource.id));
+        const prettySource = await dispatch(togglePrettyPrint(source.id));
+        return dispatch(checkPendingBreakpoints(prettySource.id));
       }
 
       await dispatch(
-        selectLocation(cx, {
+        selectLocation({
           sourceId: source.id,
           line:
             typeof pendingLocation.line === "number" ? pendingLocation.line : 0,
           column: pendingLocation.column
         })
       );
     }
   };
 }
 
-function checkPendingBreakpoints(cx: Context, sourceId: string) {
+function checkPendingBreakpoints(sourceId: string) {
   return async ({ dispatch, getState }: ThunkArgs) => {
     // source may have been modified by selectLocation
     const source = getSource(getState(), sourceId);
     if (!source) {
       return;
     }
 
     const pendingBreakpoints = getPendingBreakpointsForSource(
@@ -189,35 +187,35 @@ function checkPendingBreakpoints(cx: Con
       source
     );
 
     if (pendingBreakpoints.length === 0) {
       return;
     }
 
     // load the source text if there is a pending breakpoint for it
-    await dispatch(loadSourceText(cx, source));
+    await dispatch(loadSourceText(source));
 
     await Promise.all(
       pendingBreakpoints.map(bp => {
-        return dispatch(syncBreakpoint(cx, sourceId, bp));
+        return dispatch(syncBreakpoint(sourceId, bp));
       })
     );
   };
 }
 
-function restoreBlackBoxedSources(cx: Context, sources: Source[]) {
+function restoreBlackBoxedSources(sources: Source[]) {
   return async ({ dispatch }: ThunkArgs) => {
     const tabs = getBlackBoxList();
     if (tabs.length == 0) {
       return;
     }
     for (const source of sources) {
       if (tabs.includes(source.url) && !source.isBlackBoxed) {
-        dispatch(toggleBlackBox(cx, source));
+        dispatch(toggleBlackBox(source));
       }
     }
   };
 }
 
 /**
  * Handler for the debugger client's unsolicited newSource notification.
  * @memberof actions/sources
@@ -226,37 +224,35 @@ function restoreBlackBoxedSources(cx: Co
 export function newSource(source: Source) {
   return async ({ dispatch }: ThunkArgs) => {
     await dispatch(newSources([source]));
   };
 }
 
 export function newSources(sources: Source[]) {
   return async ({ dispatch, getState }: ThunkArgs) => {
-    const cx = getContext(getState());
-
     const _newSources = sources.filter(
       source => !getSource(getState(), source.id) || isInlineScript(source)
     );
 
     const sourcesNeedingPositions = _newSources.filter(source =>
       hasBreakpointPositions(getState(), source.id)
     );
 
-    dispatch({ type: "ADD_SOURCES", cx, sources });
+    dispatch({ type: "ADD_SOURCES", sources });
 
     for (const source of _newSources) {
-      dispatch(checkSelectedSource(cx, source.id));
+      dispatch(checkSelectedSource(source.id));
     }
 
     // Adding new sources may have cleared this file's breakpoint positions
     // in cases where a new <script> loaded in the HTML, so we manually
     // re-request new breakpoint positions.
     for (const source of sourcesNeedingPositions) {
       if (!hasBreakpointPositions(getState(), source.id)) {
-        dispatch(setBreakpointPositions(cx, source.id));
+        dispatch(setBreakpointPositions(source.id));
       }
     }
 
-    dispatch(restoreBlackBoxedSources(cx, _newSources));
-    dispatch(loadSourceMaps(cx, _newSources));
+    dispatch(restoreBlackBoxedSources(_newSources));
+    dispatch(loadSourceMaps(_newSources));
   };
 }
--- a/devtools/client/debugger/new/src/actions/sources/prettyPrint.js
+++ b/devtools/client/debugger/new/src/actions/sources/prettyPrint.js
@@ -13,24 +13,24 @@ import { prettyPrint } from "../../worke
 import { getPrettySourceURL, isLoaded } from "../../utils/source";
 import { loadSourceText } from "./loadSourceText";
 import { mapFrames } from "../pause";
 import { selectSpecificLocation } from "../sources";
 
 import {
   getSource,
   getSourceFromId,
+  getSourceThreads,
   getSourceByURL,
-  getSelectedLocation,
-  getThreadContext
+  getSelectedLocation
 } from "../../selectors";
 
 import type { Action, ThunkArgs } from "../types";
 import { selectSource } from "./select";
-import type { JsSource, Source, Context } from "../../types";
+import type { JsSource, Source } from "../../types";
 
 export async function prettyPrintSource(
   sourceMaps: any,
   prettySource: Source,
   generatedSource: any
 ) {
   const url = getPrettySourceURL(generatedSource.url);
   const { code, mappings } = await prettyPrint({
@@ -46,17 +46,17 @@ export async function prettyPrintSource(
   }
   return {
     id: prettySource.id,
     text: code,
     contentType: "text/javascript"
   };
 }
 
-export function createPrettySource(cx: Context, sourceId: string) {
+export function createPrettySource(sourceId: string) {
   return async ({ dispatch, getState, sourceMaps }: ThunkArgs) => {
     const source = getSourceFromId(getState(), sourceId);
     const url = getPrettySourceURL(source.url);
     const id = await sourceMaps.generatedToOriginalId(sourceId, url);
 
     const prettySource: JsSource = {
       url,
       relativeUrl: url,
@@ -67,18 +67,18 @@ export function createPrettySource(cx: C
       contentType: "text/javascript",
       loadedState: "loading",
       introductionUrl: null,
       introductionType: undefined,
       isExtension: false,
       actors: []
     };
 
-    dispatch(({ type: "ADD_SOURCE", cx, source: prettySource }: Action));
-    await dispatch(selectSource(cx, prettySource.id));
+    dispatch(({ type: "ADD_SOURCE", source: prettySource }: Action));
+    await dispatch(selectSource(prettySource.id));
 
     return prettySource;
   };
 }
 
 /**
  * Toggle the pretty printing of a source's text. All subsequent calls to
  * |getText| will return the pretty-toggled text. Nothing will happen for
@@ -86,29 +86,29 @@ export function createPrettySource(cx: C
  *
  * @memberof actions/sources
  * @static
  * @param string id The source form from the RDP.
  * @returns Promise
  *          A promise that resolves to [aSource, prettyText] or rejects to
  *          [aSource, error].
  */
-export function togglePrettyPrint(cx: Context, sourceId: string) {
+export function togglePrettyPrint(sourceId: string) {
   return async ({ dispatch, getState, client, sourceMaps }: ThunkArgs) => {
     const source = getSource(getState(), sourceId);
     if (!source) {
       return {};
     }
 
     if (!source.isPrettyPrinted) {
       recordEvent("pretty_print");
     }
 
     if (!isLoaded(source)) {
-      await dispatch(loadSourceText(cx, source));
+      await dispatch(loadSourceText(source));
     }
 
     assert(
       sourceMaps.isGeneratedId(sourceId),
       "Pretty-printing only allowed on generated sources"
     );
 
     const selectedLocation = getSelectedLocation(getState());
@@ -118,31 +118,31 @@ export function togglePrettyPrint(cx: Co
     const options = {};
     if (selectedLocation) {
       options.location = await sourceMaps.getOriginalLocation(selectedLocation);
     }
 
     if (prettySource) {
       const _sourceId = prettySource.id;
       return dispatch(
-        selectSpecificLocation(cx, { ...options.location, sourceId: _sourceId })
+        selectSpecificLocation({ ...options.location, sourceId: _sourceId })
       );
     }
 
-    const newPrettySource = await dispatch(createPrettySource(cx, sourceId));
+    const newPrettySource = await dispatch(createPrettySource(sourceId));
 
-    await dispatch(remapBreakpoints(cx, sourceId));
+    await dispatch(remapBreakpoints(sourceId));
 
-    const threadcx = getThreadContext(getState());
-    await dispatch(mapFrames(threadcx));
+    const threads = getSourceThreads(getState(), source);
+    await Promise.all(threads.map(thread => dispatch(mapFrames(thread))));
 
-    await dispatch(setSymbols(cx, newPrettySource.id));
+    await dispatch(setSymbols(newPrettySource.id));
 
     dispatch(
-      selectSpecificLocation(cx, {
+      selectSpecificLocation({
         ...options.location,
         sourceId: newPrettySource.id
       })
     );
 
     return newPrettySource;
   };
 }
--- a/devtools/client/debugger/new/src/actions/sources/select.js
+++ b/devtools/client/debugger/new/src/actions/sources/select.js
@@ -30,116 +30,100 @@ import {
   getSource,
   getSourceByURL,
   getPrettySource,
   getActiveSearch,
   getSelectedLocation,
   getSelectedSource
 } from "../../selectors";
 
-import type {
-  SourceLocation,
-  PartialPosition,
-  Source,
-  Context
-} from "../../types";
+import type { SourceLocation, PartialPosition, Source } from "../../types";
 import type { ThunkArgs } from "../types";
 
 export const setSelectedLocation = (
-  cx: Context,
   source: Source,
   location: SourceLocation
 ) => ({
   type: "SET_SELECTED_LOCATION",
-  cx,
   source,
   location
 });
 
-export const setPendingSelectedLocation = (
-  cx: Context,
-  url: string,
-  options: Object
-) => ({
+export const setPendingSelectedLocation = (url: string, options: Object) => ({
   type: "SET_PENDING_SELECTED_LOCATION",
-  cx,
   url: url,
   line: options.location ? options.location.line : null
 });
 
-export const clearSelectedLocation = (cx: Context) => ({
-  type: "CLEAR_SELECTED_LOCATION",
-  cx
+export const clearSelectedLocation = () => ({
+  type: "CLEAR_SELECTED_LOCATION"
 });
 
 /**
  * Deterministically select a source that has a given URL. This will
  * work regardless of the connection status or if the source exists
  * yet.
  *
  * This exists mostly for external things to interact with the
  * debugger.
  *
  * @memberof actions/sources
  * @static
  */
 export function selectSourceURL(
-  cx: Context,
   url: string,
   options: PartialPosition = { line: 1 }
 ) {
   return async ({ dispatch, getState, sourceMaps }: ThunkArgs) => {
     const source = getSourceByURL(getState(), url);
     if (!source) {
-      return dispatch(setPendingSelectedLocation(cx, url, options));
+      return dispatch(setPendingSelectedLocation(url, options));
     }
 
     const sourceId = source.id;
     const location = createLocation({ ...options, sourceId });
-    return dispatch(selectLocation(cx, location));
+    return dispatch(selectLocation(location));
   };
 }
 
 /**
  * @memberof actions/sources
  * @static
  */
 export function selectSource(
-  cx: Context,
   sourceId: string,
   options: PartialPosition = { line: 1 }
 ) {
   return async ({ dispatch }: ThunkArgs) => {
     const location = createLocation({ ...options, sourceId });
-    return dispatch(selectSpecificLocation(cx, location));
+    return dispatch(selectSpecificLocation(location));
   };
 }
 
 /**
  * @memberof actions/sources
  * @static
  */
 export function selectLocation(
-  cx: Context,
   location: SourceLocation,
   { keepContext = true }: Object = {}
 ) {
   return async ({ dispatch, getState, sourceMaps, client }: ThunkArgs) => {
     const currentSource = getSelectedSource(getState());
 
     if (!client) {
       // No connection, do nothing. This happens when the debugger is
       // shut down too fast and it tries to display a default source.
       return;
     }
 
     let source = getSource(getState(), location.sourceId);
     if (!source) {
       // If there is no source we deselect the current selected source
-      return dispatch(clearSelectedLocation(cx));
+      return dispatch(clearSelectedLocation());
     }
 
     const activeSearch = getActiveSearch(getState());
     if (activeSearch && activeSearch !== "file") {
       dispatch(closeActiveSearch());
     }
 
     // Preserve the current source map context (original / generated)
@@ -154,74 +138,74 @@ export function selectLocation(
       source = getSourceFromId(getState(), location.sourceId);
     }
 
     const tabSources = getSourcesForTabs(getState());
     if (!tabSources.includes(source)) {
       dispatch(addTab(source));
     }
 
-    dispatch(setSelectedLocation(cx, source, location));
+    dispatch(setSelectedLocation(source, location));
 
-    await dispatch(loadSourceText(cx, source));
+    await dispatch(loadSourceText(source));
     const loadedSource = getSource(getState(), source.id);
 
     if (!loadedSource) {
       // If there was a navigation while we were loading the loadedSource
       return;
     }
 
     if (
       keepContext &&
       prefs.autoPrettyPrint &&
       !getPrettySource(getState(), loadedSource.id) &&
       shouldPrettyPrint(loadedSource) &&
       isMinified(loadedSource)
     ) {
-      await dispatch(togglePrettyPrint(cx, loadedSource.id));
-      dispatch(closeTab(cx, loadedSource));
+      await dispatch(togglePrettyPrint(loadedSource.id));
+      dispatch(closeTab(loadedSource));
     }
 
-    dispatch(setSymbols(cx, loadedSource.id));
-    dispatch(setOutOfScopeLocations(cx));
+    dispatch(setSymbols(loadedSource.id));
+    dispatch(setOutOfScopeLocations());
 
     // If a new source is selected update the file search results
     const newSource = getSelectedSource(getState());
     if (currentSource && currentSource !== newSource) {
-      dispatch(updateActiveFileSearch(cx));
+      dispatch(updateActiveFileSearch());
     }
   };
 }
 
 /**
  * @memberof actions/sources
  * @static
  */
-export function selectSpecificLocation(cx: Context, location: SourceLocation) {
-  return selectLocation(cx, location, { keepContext: false });
+export function selectSpecificLocation(location: SourceLocation) {
+  return selectLocation(location, { keepContext: false });
 }
 
 /**
  * @memberof actions/sources
  * @static
  */
-export function jumpToMappedLocation(cx: Context, location: SourceLocation) {
+export function jumpToMappedLocation(location: SourceLocation) {
   return async function({ dispatch, getState, client, sourceMaps }: ThunkArgs) {
     if (!client) {
       return;
     }
 
     const pairedLocation = await mapLocation(getState(), sourceMaps, location);
 
-    return dispatch(selectSpecificLocation(cx, { ...pairedLocation }));
+    return dispatch(selectSpecificLocation({ ...pairedLocation }));
   };
 }
 
-export function jumpToMappedSelectedLocation(cx: Context) {
+export function jumpToMappedSelectedLocation() {
   return async function({ dispatch, getState }: ThunkArgs) {
     const location = getSelectedLocation(getState());
     if (!location) {
       return;
     }
 
-    await dispatch(jumpToMappedLocation(cx, location));
+    await dispatch(jumpToMappedLocation(location));
   };
 }
--- a/devtools/client/debugger/new/src/actions/sources/symbols.js
+++ b/devtools/client/debugger/new/src/actions/sources/symbols.js
@@ -1,40 +1,39 @@
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at <http://mozilla.org/MPL/2.0/>. */
-import { getSourceFromId, getSymbols, getThreadContext } from "../../selectors";
+import { getSourceFromId, getSourceThreads, getSymbols } from "../../selectors";
 
 import { PROMISE } from "../utils/middleware/promise";
 import { mapFrames } from "../pause";
 import { updateTab } from "../tabs";
 
 import * as parser from "../../workers/parser";
 
 import { isLoaded } from "../../utils/source";
 
 import type { SourceId } from "../../types";
 import type { ThunkArgs } from "../types";
 
-export function setSymbols(cx: Context, sourceId: SourceId) {
+export function setSymbols(sourceId: SourceId) {
   return async ({ dispatch, getState, sourceMaps }: ThunkArgs) => {
     const source = getSourceFromId(getState(), sourceId);
 
     if (source.isWasm || getSymbols(getState(), source) || !isLoaded(source)) {
       return;
     }
 
     await dispatch({
       type: "SET_SYMBOLS",
-      cx,
       sourceId,
       [PROMISE]: parser.getSymbols(sourceId)
     });
 
-    const threadcx = getThreadContext(getState());
-    await dispatch(mapFrames(threadcx));
+    const threads = getSourceThreads(getState(), source);
+    await Promise.all(threads.map(thread => dispatch(mapFrames(thread))));
 
     const symbols = getSymbols(getState(), source);
     if (symbols.framework) {
       dispatch(updateTab(source, symbols.framework));
     }
   };
 }
--- a/devtools/client/debugger/new/src/actions/sources/tests/blackbox.spec.js
+++ b/devtools/client/debugger/new/src/actions/sources/tests/blackbox.spec.js
@@ -9,21 +9,21 @@ import {
   selectors,
   createStore,
   makeSource
 } from "../../../utils/test-head";
 
 describe("blackbox", () => {
   it("should blackbox a source", async () => {
     const store = createStore({ blackBox: async () => true });
-    const { dispatch, getState, cx } = store;
+    const { dispatch, getState } = store;
 
     const foo1Source = makeSource("foo1");
     await dispatch(actions.newSource(foo1Source));
-    await dispatch(actions.toggleBlackBox(cx, foo1Source));
+    await dispatch(actions.toggleBlackBox(foo1Source));
 
     const fooSource = selectors.getSource(getState(), "foo1");
 
     if (!fooSource) {
       throw new Error("foo should exist");
     }
 
     const thread = foo1Source.actors[0].thread;
--- a/devtools/client/debugger/new/src/actions/sources/tests/loadSource.spec.js
+++ b/devtools/client/debugger/new/src/actions/sources/tests/loadSource.spec.js
@@ -16,31 +16,31 @@ import {
   createSource,
   sourceThreadClient
 } from "../../tests/helpers/threadClient.js";
 import { getBreakpointsList } from "../../../selectors";
 
 describe("loadSourceText", () => {
   it("should load source text", async () => {
     const store = createStore(sourceThreadClient);
-    const { dispatch, getState, cx } = store;
+    const { dispatch, getState } = store;
 
     const foo1Source = makeSource("foo1");
     await dispatch(actions.newSource(foo1Source));
-    await dispatch(actions.loadSourceText(cx, foo1Source));
+    await dispatch(actions.loadSourceText(foo1Source));
     const fooSource = selectors.getSource(getState(), "foo1");
 
     if (!fooSource || typeof fooSource.text != "string") {
       throw new Error("bad fooSource");
     }
     expect(fooSource.text.indexOf("return foo1")).not.toBe(-1);
 
     const baseFoo2Source = makeSource("foo2");
     await dispatch(actions.newSource(baseFoo2Source));
-    await dispatch(actions.loadSourceText(cx, baseFoo2Source));
+    await dispatch(actions.loadSourceText(baseFoo2Source));
     const foo2Source = selectors.getSource(getState(), "foo2");
 
     if (!foo2Source || typeof foo2Source.text != "string") {
       throw new Error("bad fooSource");
     }
     expect(foo2Source.text.indexOf("return foo2")).not.toBe(-1);
   });
 
@@ -68,149 +68,149 @@ describe("loadSourceText", () => {
             sourceId: fooOrigSource.id
           })),
         getOriginalSourceText: async s => ({
           text: fooOrigContent.source,
           contentType: fooOrigContent.contentType
         })
       }
     );
-    const { cx, dispatch, getState } = store;
+    const { dispatch, getState } = store;
 
     await dispatch(actions.newSource(fooOrigSource));
     await dispatch(actions.newSource(fooGenSource));
 
     const location = {
       sourceId: fooOrigSource.id,
       line: 1,
       column: 0
     };
-    await dispatch(actions.addBreakpoint(cx, location, {}));
+    await dispatch(actions.addBreakpoint(location, {}));
     const breakpoint = selectors.getBreakpoint(getState(), location);
     if (!breakpoint) {
       throw new Error("no breakpoint");
     }
 
     expect(breakpoint.text).toBe("var fooGen = 42;");
     expect(breakpoint.originalText).toBe("var fooOrig = 42;");
 
-    await dispatch(actions.loadSourceText(cx, fooOrigSource));
+    await dispatch(actions.loadSourceText(fooOrigSource));
 
     const breakpoint1 = getBreakpointsList(getState())[0];
     expect(breakpoint1.text).toBe("var fooGen = 42;");
     expect(breakpoint1.originalText).toBe("var fooOrig = 42;");
 
-    await dispatch(actions.loadSourceText(cx, fooGenSource));
+    await dispatch(actions.loadSourceText(fooGenSource));
 
     const breakpoint2 = getBreakpointsList(getState())[0];
     expect(breakpoint2.text).toBe("var fooGen = 42;");
     expect(breakpoint2.originalText).toBe("var fooOrig = 42;");
   });
 
   it("loads two sources w/ one request", async () => {
     let resolve;
     let count = 0;
-    const { dispatch, getState, cx } = createStore({
+    const { dispatch, getState } = createStore({
       sourceContents: () =>
         new Promise(r => {
           count++;
           resolve = r;
         }),
       getBreakpointPositions: async () => ({})
     });
     const id = "foo";
     const baseSource = makeSource(id, { loadedState: "unloaded" });
 
     await dispatch(actions.newSource(baseSource));
 
     let source = selectors.getSource(getState(), id);
-    dispatch(actions.loadSourceText(cx, source));
+    dispatch(actions.loadSourceText(source));
 
     source = selectors.getSource(getState(), id);
-    const loading = dispatch(actions.loadSourceText(cx, source));
+    const loading = dispatch(actions.loadSourceText(source));
 
     if (!resolve) {
       throw new Error("no resolve");
     }
     resolve({ source: "yay", contentType: "text/javascript" });
     await loading;
     expect(count).toEqual(1);
 
     source = selectors.getSource(getState(), id);
     expect(source && source.text).toEqual("yay");
   });
 
   it("doesn't re-load loaded sources", async () => {
     let resolve;
     let count = 0;
-    const { dispatch, getState, cx } = createStore({
+    const { dispatch, getState } = createStore({
       sourceContents: () =>
         new Promise(r => {
           count++;
           resolve = r;
         }),
       getBreakpointPositions: async () => ({})
     });
     const id = "foo";
     const baseSource = makeSource(id, { loadedState: "unloaded" });
 
     await dispatch(actions.newSource(baseSource));
     let source = selectors.getSource(getState(), id);
-    const loading = dispatch(actions.loadSourceText(cx, source));
+    const loading = dispatch(actions.loadSourceText(source));
 
     if (!resolve) {
       throw new Error("no resolve");
     }
     resolve({ source: "yay", contentType: "text/javascript" });
     await loading;
 
     source = selectors.getSource(getState(), id);
-    await dispatch(actions.loadSourceText(cx, source));
+    await dispatch(actions.loadSourceText(source));
     expect(count).toEqual(1);
 
     source = selectors.getSource(getState(), id);
     expect(source && source.text).toEqual("yay");
   });
 
   it("should cache subsequent source text loads", async () => {
-    const { dispatch, getState, cx } = createStore(sourceThreadClient);
+    const { dispatch, getState } = createStore(sourceThreadClient);
 
     const source = makeSource("foo1");
-    await dispatch(actions.loadSourceText(cx, source));
+    await dispatch(actions.loadSourceText(source));
     const prevSource = selectors.getSource(getState(), "foo1");
 
-    await dispatch(actions.loadSourceText(cx, prevSource));
+    await dispatch(actions.loadSourceText(prevSource));
     const curSource = selectors.getSource(getState(), "foo1");
 
     expect(prevSource === curSource).toBeTruthy();
   });
 
   it("should indicate a loading source", async () => {
     const store = createStore(sourceThreadClient);
-    const { dispatch, cx } = store;
+    const { dispatch } = store;
 
     const source = makeSource("foo2");
     await dispatch(actions.newSource(source));
 
     const wasLoading = watchForState(store, state => {
       const fooSource = selectors.getSource(state, "foo2");
       return fooSource && fooSource.loadedState === "loading";
     });
 
-    await dispatch(actions.loadSourceText(cx, source));
+    await dispatch(actions.loadSourceText(source));
 
     expect(wasLoading()).toBe(true);
   });
 
   it("should indicate an errored source text", async () => {
-    const { dispatch, getState, cx } = createStore(sourceThreadClient);
+    const { dispatch, getState } = createStore(sourceThreadClient);
 
     const source = makeSource("bad-id");
     await dispatch(actions.newSource(source));
-    await dispatch(actions.loadSourceText(cx, source));
+    await dispatch(actions.loadSourceText(source));
     const badSource = selectors.getSource(getState(), "bad-id");
 
     if (!badSource || !badSource.error) {
       throw new Error("bad badSource");
     }
     expect(badSource.error.indexOf("unknown source")).not.toBe(-1);
   });
 });
--- a/devtools/client/debugger/new/src/actions/sources/tests/newSources.spec.js
+++ b/devtools/client/debugger/new/src/actions/sources/tests/newSources.spec.js
@@ -40,19 +40,19 @@ describe("sources - new sources", () => 
 
     await dispatch(actions.newSource(makeSource("base.js")));
     await dispatch(actions.newSource(makeSource("base.js")));
 
     expect(getSourceCount(getState())).toEqual(1);
   });
 
   it("should automatically select a pending source", async () => {
-    const { dispatch, getState, cx } = createStore(threadClient);
+    const { dispatch, getState } = createStore(threadClient);
     const baseSource = makeSource("base.js");
-    await dispatch(actions.selectSourceURL(cx, baseSource.url));
+    await dispatch(actions.selectSourceURL(baseSource.url));
 
     expect(getSelectedSource(getState())).toBe(undefined);
     await dispatch(actions.newSource(baseSource));
 
     const selected = getSelectedSource(getState());
     expect(selected && selected.url).toBe(baseSource.url);
   });
 
--- a/devtools/client/debugger/new/src/actions/sources/tests/prettyPrint.spec.js
+++ b/devtools/client/debugger/new/src/actions/sources/tests/prettyPrint.spec.js
@@ -9,37 +9,37 @@ import {
   selectors,
   createStore,
   makeSource
 } from "../../../utils/test-head";
 import { createPrettySource } from "../prettyPrint";
 import { sourceThreadClient } from "../../tests/helpers/threadClient.js";
 
 describe("sources - pretty print", () => {
-  const { dispatch, getState, cx } = createStore(sourceThreadClient);
+  const { dispatch, getState } = createStore(sourceThreadClient);
 
   it("returns a pretty source for a minified file", async () => {
     const url = "base.js";
     const source = makeSource(url);
     await dispatch(actions.newSource(source));
-    await dispatch(createPrettySource(cx, source.id));
+    await dispatch(createPrettySource(source.id));
 
     const prettyURL = `${source.url}:formatted`;
     const pretty = selectors.getSourceByURL(getState(), prettyURL);
     expect(pretty && pretty.contentType).toEqual("text/javascript");
     expect(pretty && pretty.url.includes(prettyURL)).toEqual(true);
     expect(pretty).toMatchSnapshot();
   });
 
   it("should create a source when first toggling pretty print", async () => {
     const source = makeSource("foobar.js", { loadedState: "loaded" });
-    await dispatch(actions.togglePrettyPrint(cx, source.id));
+    await dispatch(actions.togglePrettyPrint(source.id));
     expect(selectors.getSourceCount(getState())).toEqual(2);
   });
 
   it("should not make a second source when toggling pretty print", async () => {
     const source = makeSource("foobar.js", { loadedState: "loaded" });
-    await dispatch(actions.togglePrettyPrint(cx, source.id));
+    await dispatch(actions.togglePrettyPrint(source.id));
     expect(selectors.getSourceCount(getState())).toEqual(2);
-    await dispatch(actions.togglePrettyPrint(cx, source.id));
+    await dispatch(actions.togglePrettyPrint(source.id));
     expect(selectors.getSourceCount(getState())).toEqual(2);
   });
 });
--- a/devtools/client/debugger/new/src/actions/sources/tests/select.spec.js
+++ b/devtools/client/debugger/new/src/actions/sources/tests/select.spec.js
@@ -45,19 +45,18 @@ describe("sources", () => {
       actions.paused({
         thread: "FakeThread",
         why: { type: "debuggerStatement" },
         frame,
         frames: [frame]
       })
     );
 
-    const cx = selectors.getThreadContext(getState());
     await dispatch(
-      actions.selectLocation(cx, { sourceId: "foo1", line: 1, column: 5 })
+      actions.selectLocation({ sourceId: "foo1", line: 1, column: 5 })
     );
 
     const selectedSource = getSelectedSource(getState());
     if (!selectedSource) {
       throw new Error("bad selectedSource");
     }
     expect(selectedSource.id).toEqual("foo1");
 
@@ -68,93 +67,93 @@ describe("sources", () => {
     expect(source.id).toEqual("foo1");
 
     await waitForState(store, state => getOutOfScopeLocations(state));
     const locations = getOutOfScopeLocations(getState());
     expect(locations).toHaveLength(1);
   });
 
   it("should select next tab on tab closed if no previous tab", async () => {
-    const { dispatch, getState, cx } = createStore(sourceThreadClient);
+    const { dispatch, getState } = createStore(sourceThreadClient);
 
     const fooSource = makeSource("foo.js");
 
     await dispatch(actions.newSource(fooSource));
     await dispatch(actions.newSource(makeSource("bar.js")));
     await dispatch(actions.newSource(makeSource("baz.js")));
 
     // 3rd tab
-    await dispatch(actions.selectLocation(cx, initialLocation("foo.js")));
+    await dispatch(actions.selectLocation(initialLocation("foo.js")));
 
     // 2nd tab
-    await dispatch(actions.selectLocation(cx, initialLocation("bar.js")));
+    await dispatch(actions.selectLocation(initialLocation("bar.js")));
 
     // 1st tab
-    await dispatch(actions.selectLocation(cx, initialLocation("baz.js")));
+    await dispatch(actions.selectLocation(initialLocation("baz.js")));
 
     // 3rd tab is reselected
-    await dispatch(actions.selectLocation(cx, initialLocation("foo.js")));
+    await dispatch(actions.selectLocation(initialLocation("foo.js")));
 
     // closes the 1st tab, which should have no previous tab
-    await dispatch(actions.closeTab(cx, fooSource));
+    await dispatch(actions.closeTab(fooSource));
 
     const selected = getSelectedSource(getState());
     expect(selected && selected.id).toBe("bar.js");
     expect(getSourceTabs(getState())).toHaveLength(2);
   });
 
   it("should open a tab for the source", async () => {
-    const { dispatch, getState, cx } = createStore(sourceThreadClient);
+    const { dispatch, getState } = createStore(sourceThreadClient);
     await dispatch(actions.newSource(makeSource("foo.js")));
-    dispatch(actions.selectLocation(cx, initialLocation("foo.js")));
+    dispatch(actions.selectLocation(initialLocation("foo.js")));
 
     const tabs = getSourceTabs(getState());
     expect(tabs).toHaveLength(1);
     expect(tabs[0].url).toEqual("http://localhost:8000/examples/foo.js");
   });
 
   it("should select previous tab on tab closed", async () => {
-    const { dispatch, getState, cx } = createStore(sourceThreadClient);
+    const { dispatch, getState } = createStore(sourceThreadClient);
     await dispatch(actions.newSource(makeSource("foo.js")));
     await dispatch(actions.newSource(makeSource("bar.js")));
 
     const bazSource = makeSource("baz.js");
     await dispatch(actions.newSource(bazSource));
 
-    await dispatch(actions.selectLocation(cx, initialLocation("foo.js")));
-    await dispatch(actions.selectLocation(cx, initialLocation("bar.js")));
-    await dispatch(actions.selectLocation(cx, initialLocation("baz.js")));
-    await dispatch(actions.closeTab(cx, bazSource));
+    await dispatch(actions.selectLocation(initialLocation("foo.js")));
+    await dispatch(actions.selectLocation(initialLocation("bar.js")));
+    await dispatch(actions.selectLocation(initialLocation("baz.js")));
+    await dispatch(actions.closeTab(bazSource));
 
     const selected = getSelectedSource(getState());
     expect(selected && selected.id).toBe("bar.js");
     expect(getSourceTabs(getState())).toHaveLength(2);
   });
 
   it("should keep the selected source when other tab closed", async () => {
-    const { dispatch, getState, cx } = createStore(sourceThreadClient);
+    const { dispatch, getState } = createStore(sourceThreadClient);
 
     const bazSource = makeSource("baz.js");
 
     await dispatch(actions.newSource(makeSource("foo.js")));
     await dispatch(actions.newSource(makeSource("bar.js")));
     await dispatch(actions.newSource(bazSource));
 
     // 3rd tab
-    await dispatch(actions.selectLocation(cx, initialLocation("foo.js")));
+    await dispatch(actions.selectLocation(initialLocation("foo.js")));
 
     // 2nd tab
-    await dispatch(actions.selectLocation(cx, initialLocation("bar.js")));
+    await dispatch(actions.selectLocation(initialLocation("bar.js")));
 
     // 1st tab
-    await dispatch(actions.selectLocation(cx, initialLocation("baz.js")));
+    await dispatch(actions.selectLocation(initialLocation("baz.js")));
 
     // 3rd tab is reselected
-    await dispatch(actions.selectLocation(cx, initialLocation("foo.js")));
-    await dispatch(actions.closeTab(cx, bazSource));
+    await dispatch(actions.selectLocation(initialLocation("foo.js")));
+    await dispatch(actions.closeTab(bazSource));
 
     const selected = getSelectedSource(getState());
     expect(selected && selected.id).toBe("foo.js");
     expect(getSourceTabs(getState())).toHaveLength(2);
   });
 
   it("should not select new sources that lack a URL", async () => {
     const { dispatch, getState } = createStore(sourceThreadClient);
@@ -164,68 +163,68 @@ describe("sources", () => {
     await dispatch(actions.newSource(source));
 
     expect(getSourceCount(getState())).toEqual(1);
     const selectedLocation = getSelectedLocation(getState());
     expect(selectedLocation).toEqual(undefined);
   });
 
   it("sets and clears selected location correctly", () => {
-    const { dispatch, getState, cx } = createStore(sourceThreadClient);
+    const { dispatch, getState } = createStore(sourceThreadClient);
     const source = makeSource("testSource");
     const location = ({ test: "testLocation" }: any);
 
     // set value
-    dispatch(actions.setSelectedLocation(cx, source, location));
+    dispatch(actions.setSelectedLocation(source, location));
     expect(getSelectedLocation(getState())).toEqual({
       sourceId: source.id,
       ...location
     });
 
     // clear value
-    dispatch(actions.clearSelectedLocation(cx));
+    dispatch(actions.clearSelectedLocation());
     expect(getSelectedLocation(getState())).toEqual(null);
   });
 
   it("sets and clears pending selected location correctly", () => {
-    const { dispatch, getState, cx } = createStore(sourceThreadClient);
+    const { dispatch, getState } = createStore(sourceThreadClient);
     const url = "testURL";
     const options = { location: { line: "testLine" } };
 
     // set value
-    dispatch(actions.setPendingSelectedLocation(cx, url, options));
+    dispatch(actions.setPendingSelectedLocation(url, options));
     const setResult = getState().sources.pendingSelectedLocation;
     expect(setResult).toEqual({
       url,
       line: options.location.line
     });
 
     // clear value
-    dispatch(actions.clearSelectedLocation(cx));
+    dispatch(actions.clearSelectedLocation());
     const clearResult = getState().sources.pendingSelectedLocation;
     expect(clearResult).toEqual({ url: "" });
   });
 
   it("should keep the generated the viewing context", async () => {
     const store = createStore(sourceThreadClient);
-    const { dispatch, getState, cx } = store;
+    const { dispatch, getState } = store;
     const baseSource = makeSource("base.js");
     await dispatch(actions.newSource(baseSource));
 
     await dispatch(
-      actions.selectLocation(cx, { sourceId: baseSource.id, line: 1 })
+      actions.selectLocation({ sourceId: baseSource.id, line: 1 })
     );
 
     const selected = getSelectedSource(getState());
     expect(selected && selected.id).toBe(baseSource.id);
     await waitForState(store, state => getSymbols(state, baseSource));
   });
 
   it("should keep the original the viewing context", async () => {
-    const { dispatch, getState, cx } = createStore(
+    const { dispatch, getState } = createStore(
       sourceThreadClient,
       {},
       {
         getOriginalLocation: async location => ({ ...location, line: 12 }),
         getOriginalLocations: async items => items,
         getGeneratedLocation: async location => ({ ...location, line: 12 }),
         getOriginalSourceText: async () => ({ source: "" }),
         getGeneratedRangesForOriginal: async () => []
@@ -233,62 +232,60 @@ describe("sources", () => {
     );
 
     const baseSource = makeSource("base.js");
     await dispatch(actions.newSource(baseSource));
 
     const originalBaseSource = makeOriginalSource("base.js");
     await dispatch(actions.newSource(originalBaseSource));
 
-    await dispatch(actions.selectSource(cx, originalBaseSource.id));
+    await dispatch(actions.selectSource(originalBaseSource.id));
 
     const fooSource = makeSource("foo.js");
     await dispatch(actions.newSource(fooSource));
-    await dispatch(
-      actions.selectLocation(cx, { sourceId: fooSource.id, line: 1 })
-    );
+    await dispatch(actions.selectLocation({ sourceId: fooSource.id, line: 1 }));
 
     const selected = getSelectedLocation(getState());
     expect(selected && selected.line).toBe(12);
   });
 
   it("should change the original the viewing context", async () => {
-    const { dispatch, getState, cx } = createStore(
+    const { dispatch, getState } = createStore(
       sourceThreadClient,
       {},
       {
         getOriginalLocation: async location => ({ ...location, line: 12 }),
         getOriginalLocations: async items => items,
         getGeneratedRangesForOriginal: async () => [],
         getOriginalSourceText: async () => ({ source: "" })
       }
     );
 
     await dispatch(actions.newSource(makeSource("base.js")));
     const baseSource = makeOriginalSource("base.js");
 
     await dispatch(actions.newSource(baseSource));
-    await dispatch(actions.selectSource(cx, baseSource.id));
+    await dispatch(actions.selectSource(baseSource.id));
 
     await dispatch(
-      actions.selectSpecificLocation(cx, {
+      actions.selectSpecificLocation({
         sourceId: baseSource.id,
         line: 1
       })
     );
 
     const selected = getSelectedLocation(getState());
     expect(selected && selected.line).toBe(1);
   });
 
   describe("selectSourceURL", () => {
     it("should automatically select a pending source", async () => {
-      const { dispatch, getState, cx } = createStore(sourceThreadClient);
+      const { dispatch, getState } = createStore(sourceThreadClient);
       const baseSource = makeSource("base.js");
-      await dispatch(actions.selectSourceURL(cx, baseSource.url));
+      await dispatch(actions.selectSourceURL(baseSource.url));
 
       expect(getSelectedSource(getState())).toBe(undefined);
       await dispatch(actions.newSource(baseSource));
 
       const selected = getSelectedSource(getState());
       expect(selected && selected.url).toBe(baseSource.url);
     });
   });
--- a/devtools/client/debugger/new/src/actions/tabs.js
+++ b/devtools/client/debugger/new/src/actions/tabs.js
@@ -18,17 +18,17 @@ import {
   getSourceTabs,
   getSourceByURL,
   getNewSelectedSourceId,
   removeSourceFromTabList,
   removeSourcesFromTabList
 } from "../selectors";
 
 import type { Action, ThunkArgs } from "./types";
-import type { Source, Context } from "../types";
+import type { Source } from "../types";
 
 export function updateTab(source: Source, framework: string): Action {
   const { url, id: sourceId } = source;
   const isOriginal = isOriginalId(source.id);
 
   return {
     type: "UPDATE_TAB",
     url,
@@ -57,39 +57,39 @@ export function moveTab(url: string, tab
     tabIndex
   };
 }
 
 /**
  * @memberof actions/tabs
  * @static
  */
-export function closeTab(cx: Context, source: Source) {
+export function closeTab(source: Source) {
   return ({ dispatch, getState, client }: ThunkArgs) => {
     const { id, url } = source;
 
     removeDocument(id);
 
     const tabs = removeSourceFromTabList(getSourceTabs(getState()), source);
     const sourceId = getNewSelectedSourceId(getState(), tabs);
     dispatch(({ type: "CLOSE_TAB", url, tabs }: Action));
-    dispatch(selectSource(cx, sourceId));
+    dispatch(selectSource(sourceId));
   };
 }
 
 /**
  * @memberof actions/tabs
  * @static
  */
-export function closeTabs(cx: Context, urls: string[]) {
+export function closeTabs(urls: string[]) {
   return ({ dispatch, getState, client }: ThunkArgs) => {
     const sources = urls
       .map(url => getSourceByURL(getState(), url))
       .filter(Boolean);
     sources.map(source => removeDocument(source.id));
 
     const tabs = removeSourcesFromTabList(getSourceTabs(getState()), sources);
     dispatch(({ type: "CLOSE_TABS", sources, tabs }: Action));
 
     const sourceId = getNewSelectedSourceId(getState(), tabs);
-    dispatch(selectSource(cx, sourceId));
+    dispatch(selectSource(sourceId));
   };
 }
--- a/devtools/client/debugger/new/src/actions/tests/ast.spec.js
+++ b/devtools/client/debugger/new/src/actions/tests/ast.spec.js
@@ -62,21 +62,21 @@ const evaluationResult = {
   this: { actor: "this", preview: {} }
 };
 
 describe("ast", () => {
   describe("setSymbols", () => {
     describe("when the source is loaded", () => {
       it("should be able to set symbols", async () => {
         const store = createStore(threadClient);
-        const { dispatch, getState, cx } = store;
+        const { dispatch, getState } = store;
         const base = makeSource("base.js");
         await dispatch(actions.newSource(base));
-        await dispatch(actions.loadSourceText(cx, base));
-        await dispatch(actions.setSymbols(cx, "base.js"));
+        await dispatch(actions.loadSourceText(base));
+        await dispatch(actions.setSymbols("base.js"));
         await waitForState(store, state => !isSymbolsLoading(state, base));
 
         const baseSymbols = getSymbols(getState(), base);
         expect(baseSymbols).toMatchSnapshot();
       });
     });
 
     describe("when the source is not loaded", () => {
@@ -96,92 +96,85 @@ describe("ast", () => {
         const baseSymbols = getSymbols(getState());
         expect(baseSymbols).toEqual(null);
       });
     });
 
     describe("frameworks", () => {
       it("should detect react components", async () => {
         const store = createStore(threadClient, {}, sourceMaps);
-        const { cx, dispatch, getState } = store;
+        const { dispatch, getState } = store;
         const source = makeOriginalSource("reactComponent.js");
 
         await dispatch(actions.newSource(makeSource("reactComponent.js")));
 
         await dispatch(actions.newSource(source));
 
         await dispatch(
-          actions.loadSourceText(cx, getSource(getState(), source.id))
+          actions.loadSourceText(getSource(getState(), source.id))
         );
-        await dispatch(actions.setSymbols(cx, source.id));
+        await dispatch(actions.setSymbols(source.id));
 
         expect(getFramework(getState(), source)).toBe("React");
       });
 
       it("should not give false positive on non react components", async () => {
         const store = createStore(threadClient);
-        const { cx, dispatch, getState } = store;
+        const { dispatch, getState } = store;
         const base = makeSource("base.js");
         await dispatch(actions.newSource(base));
-        await dispatch(actions.loadSourceText(cx, base));
-        await dispatch(actions.setSymbols(cx, "base.js"));
+        await dispatch(actions.loadSourceText(base));
+        await dispatch(actions.setSymbols("base.js"));
 
         expect(getFramework(getState(), base)).toBe(undefined);
       });
     });
   });
 
   describe("getOutOfScopeLocations", () => {
     beforeEach(async () => {
       prefs.autoPrettyPrint = false;
     });
 
     it("with selected line", async () => {
       const store = createStore(threadClient);
-      const { dispatch, getState, cx } = store;
+      const { dispatch, getState } = store;
       const source = makeSource("scopes.js");
       await dispatch(actions.newSource(source));
 
       await dispatch(
-        actions.selectLocation(cx, { sourceId: "scopes.js", line: 5 })
+        actions.selectLocation({ sourceId: "scopes.js", line: 5 })
       );
 
-      // Make sure the state has finished updating before pausing.
-      await waitForState(store, state => {
-        const symbols = getSymbols(state, source);
-        return symbols && !symbols.loading && getOutOfScopeLocations(state);
-      });
-
       const frame = makeFrame({ id: "1", sourceId: "scopes.js" });
       await dispatch(
         actions.paused({
           thread: "FakeThread",
           why: { type: "debuggerStatement" },
           frame,
           frames: [frame]
         })
       );
 
-      const ncx = selectors.getThreadContext(getState());
-      await dispatch(actions.setOutOfScopeLocations(ncx));
+      await dispatch(actions.setOutOfScopeLocations());
 
       await waitForState(store, state => getOutOfScopeLocations(state));
 
       const locations = getOutOfScopeLocations(getState());
       const lines = getInScopeLines(getState());
 
       expect(locations).toMatchSnapshot();
       expect(lines).toMatchSnapshot();
     });
 
     it("without a selected line", async () => {
-      const { dispatch, getState, cx } = createStore(threadClient);
+      const { dispatch, getState } = createStore(threadClient);
       const base = makeSource("base.js");
       await dispatch(actions.newSource(base));
-      await dispatch(actions.selectSource(cx, "base.js"));
+      await dispatch(actions.selectSource("base.js"));
 
       const locations = getOutOfScopeLocations(getState());
       // const lines = getInScopeLines(getState());
 
       expect(locations).toEqual(null);
 
       // This check is disabled as locations that are in/out of scope may not
       // have completed yet when the selectSource promise finishes.
--- a/devtools/client/debugger/new/src/actions/tests/expressions.spec.js
+++ b/devtools/client/debugger/new/src/actions/tests/expressions.spec.js
@@ -45,126 +45,123 @@ const mockThreadClient = {
         matchProp: "to"
       });
     });
   }
 };
 
 describe("expressions", () => {
   it("should add an expression", async () => {
-    const { dispatch, getState, cx } = createStore(mockThreadClient);
+    const { dispatch, getState } = createStore(mockThreadClient);
 
-    await dispatch(actions.addExpression(cx, "foo"));
+    await dispatch(actions.addExpression("foo"));
     expect(selectors.getExpressions(getState()).size).toBe(1);
   });
 
   it("should not add empty expressions", () => {
-    const { dispatch, getState, cx } = createStore(mockThreadClient);
+    const { dispatch, getState } = createStore(mockThreadClient);
 
-    dispatch(actions.addExpression(cx, (undefined: any)));
-    dispatch(actions.addExpression(cx, ""));
+    dispatch(actions.addExpression((undefined: any)));
+    dispatch(actions.addExpression(""));
 
     expect(selectors.getExpressions(getState()).size).toBe(0);
   });
 
   it("should not add invalid expressions", async () => {
-    const { dispatch, getState, cx } = createStore(mockThreadClient);
-    await dispatch(actions.addExpression(cx, "foo#"));
+    const { dispatch, getState } = createStore(mockThreadClient);
+    await dispatch(actions.addExpression("foo#"));
     const state = getState();
     expect(selectors.getExpressions(state).size).toBe(0);
     expect(selectors.getExpressionError(state)).toBe(true);
   });
 
   it("should update an expression", async () => {
-    const { dispatch, getState, cx } = createStore(mockThreadClient);
+    const { dispatch, getState } = createStore(mockThreadClient);
 
-    await dispatch(actions.addExpression(cx, "foo"));
+    await dispatch(actions.addExpression("foo"));
     const expression = selectors.getExpression(getState(), "foo");
-    await dispatch(actions.updateExpression(cx, "bar", expression));
+    await dispatch(actions.updateExpression("bar", expression));
 
     expect(selectors.getExpression(getState(), "bar").input).toBe("bar");
   });
 
   it("should not update an expression w/ invalid code", async () => {
-    const { dispatch, getState, cx } = createStore(mockThreadClient);
+    const { dispatch, getState } = createStore(mockThreadClient);
 
-    await dispatch(actions.addExpression(cx, "foo"));
+    await dispatch(actions.addExpression("foo"));
     const expression = selectors.getExpression(getState(), "foo");
-    await dispatch(actions.updateExpression(cx, "#bar", expression));
+    await dispatch(actions.updateExpression("#bar", expression));
     expect(selectors.getExpression(getState(), "bar")).toBeUndefined();
   });
 
   it("should delete an expression", async () => {
-    const { dispatch, getState, cx } = createStore(mockThreadClient);
+    const { dispatch, getState } = createStore(mockThreadClient);
 
-    await dispatch(actions.addExpression(cx, "foo"));
-    await dispatch(actions.addExpression(cx, "bar"));
+    await dispatch(actions.addExpression("foo"));
+    await dispatch(actions.addExpression("bar"));
 
     expect(selectors.getExpressions(getState()).size).toBe(2);
 
     const expression = selectors.getExpression(getState(), "foo");
     dispatch(actions.deleteExpression(expression));
 
     expect(selectors.getExpressions(getState()).size).toBe(1);
     expect(selectors.getExpression(getState(), "bar").input).toBe("bar");
   });
 
   it("should evaluate expressions global scope", async () => {
-    const { dispatch, getState, cx } = createStore(mockThreadClient);
+    const { dispatch, getState } = createStore(mockThreadClient);
 
-    await dispatch(actions.addExpression(cx, "foo"));
-    await dispatch(actions.addExpression(cx, "bar"));
+    await dispatch(actions.addExpression("foo"));
+    await dispatch(actions.addExpression("bar"));
 
     expect(selectors.getExpression(getState(), "foo").value).toBe("bla");
     expect(selectors.getExpression(getState(), "bar").value).toBe("bla");
 
-    await dispatch(actions.evaluateExpressions(cx));
+    await dispatch(actions.evaluateExpressions());
 
     expect(selectors.getExpression(getState(), "foo").value).toBe("bla");
     expect(selectors.getExpression(getState(), "bar").value).toBe("bla");
   });
 
   it("should evaluate expressions in specific scope", async () => {
     const { dispatch, getState } = createStore(mockThreadClient);
-    await createFrames(getState, dispatch);
+    await createFrames(dispatch);
 
     await dispatch(actions.newSource(makeSource("source")));
 
-    const cx = selectors.getThreadContext(getState());
-    await dispatch(actions.addExpression(cx, "foo"));
-    await dispatch(actions.addExpression(cx, "bar"));
+    await dispatch(actions.addExpression("foo"));
+    await dispatch(actions.addExpression("bar"));
 
     expect(selectors.getExpression(getState(), "foo").value).toBe("boo");
     expect(selectors.getExpression(getState(), "bar").value).toBe("boo");
 
-    await dispatch(actions.evaluateExpressions(cx));
+    await dispatch(actions.evaluateExpressions());
 
     expect(selectors.getExpression(getState(), "foo").value).toBe("boo");
     expect(selectors.getExpression(getState(), "bar").value).toBe("boo");
   });
 
   it("should get the autocomplete matches for the input", async () => {
-    const { dispatch, getState, cx } = createStore(mockThreadClient);
+    const { dispatch, getState } = createStore(mockThreadClient);
 
-    await dispatch(actions.autocomplete(cx, "to", 2));
+    await dispatch(actions.autocomplete("to", 2));
 
     expect(selectors.getAutocompleteMatchset(getState())).toMatchSnapshot();
   });
 });
 
-async function createFrames(getState, dispatch) {
+async function createFrames(dispatch) {
   const frame = makeMockFrame();
 
   await dispatch(actions.newSource(makeSource("example.js")));
 
   await dispatch(
     actions.paused({
-      thread: "FakeThread",
+      thread: "UnknownThread",
       frame,
       frames: [frame],
       why: { type: "just because" }
     })
   );
 
-  await dispatch(
-    actions.selectFrame(selectors.getThreadContext(getState()), frame)
-  );
+  await dispatch(actions.selectFrame(frame));
 }
--- a/devtools/client/debugger/new/src/actions/tests/file-search.spec.js
+++ b/devtools/client/debugger/new/src/actions/tests/file-search.spec.js
@@ -9,55 +9,55 @@ import { createStore, selectors, actions
 const {
   getFileSearchQuery,
   getFileSearchModifiers,
   getFileSearchResults
 } = selectors;
 
 describe("file text search", () => {
   it("should update search results", () => {
-    const { dispatch, getState, cx } = createStore();
+    const { dispatch, getState } = createStore();
     expect(getFileSearchResults(getState())).toEqual({
       matches: [],
       matchIndex: -1,
       index: -1,
       count: 0
     });
 
     const matches = [{ line: 1, ch: 3 }, { line: 3, ch: 2 }];
-    dispatch(actions.updateSearchResults(cx, 2, 3, matches));
+    dispatch(actions.updateSearchResults(2, 3, matches));
 
     expect(getFileSearchResults(getState())).toEqual({
       count: 2,
       index: 2,
       matchIndex: 1,
       matches: matches
     });
   });
 
   it("should update the file search query", () => {
-    const { dispatch, getState, cx } = createStore();
+    const { dispatch, getState } = createStore();
     let fileSearchQueryState = getFileSearchQuery(getState());
     expect(fileSearchQueryState).toBe("");
-    dispatch(actions.setFileSearchQuery(cx, "foobar"));
+    dispatch(actions.setFileSearchQuery("foobar"));
     fileSearchQueryState = getFileSearchQuery(getState());
     expect(fileSearchQueryState).toBe("foobar");
   });
 
   it("should toggle a file search modifier", () => {
-    const { dispatch, getState, cx } = createStore();
+    const { dispatch, getState } = createStore();
     let fileSearchModState = getFileSearchModifiers(getState());
     expect(fileSearchModState.get("caseSensitive")).toBe(false);
-    dispatch(actions.toggleFileSearchModifier(cx, "caseSensitive"));
+    dispatch(actions.toggleFileSearchModifier("caseSensitive"));
     fileSearchModState = getFileSearchModifiers(getState());
     expect(fileSearchModState.get("caseSensitive")).toBe(true);
   });
 
   it("should toggle a file search query cleaning", () => {
-    const { dispatch, getState, cx } = createStore();
-    dispatch(actions.setFileSearchQuery(cx, "foobar"));
+    const { dispatch, getState } = createStore();
+    dispatch(actions.setFileSearchQuery("foobar"));
     let fileSearchQueryState = getFileSearchQuery(getState());
     expect(fileSearchQueryState).toBe("foobar");
-    dispatch(actions.setFileSearchQuery(cx, ""));
+    dispatch(actions.setFileSearchQuery(""));
     fileSearchQueryState = getFileSearchQuery(getState());
     expect(fileSearchQueryState).toBe("");
   });
 });
--- a/devtools/client/debugger/new/src/actions/tests/navigation.spec.js
+++ b/devtools/client/debugger/new/src/actions/tests/navigation.spec.js
@@ -43,21 +43,21 @@ describe("navigation", () => {
         "actor",
         false
       )
     );
     expect(selectors.getDebuggeeUrl(getState())).toEqual("http://test.com/foo");
   });
 
   it("navigation closes project-search", async () => {
-    const { dispatch, getState, cx } = createStore(threadClient);
+    const { dispatch, getState } = createStore(threadClient);
     const mockQuery = "foo";
 
     await dispatch(actions.newSource(makeSource("foo1")));
-    await dispatch(actions.searchSources(cx, mockQuery));
+    await dispatch(actions.searchSources(mockQuery));
 
     let results = getTextSearchResults(getState());
     expect(results).toHaveLength(1);
     expect(selectors.getTextSearchQuery(getState())).toEqual("foo");
     expect(getTextSearchStatus(getState())).toEqual("DONE");
 
     await dispatch(actions.willNavigate("will-navigate"));
 
@@ -72,31 +72,31 @@ describe("navigation", () => {
     dispatch(actions.setActiveSearch("project"));
     expect(getActiveSearch(getState())).toBe("project");
 
     await dispatch(actions.willNavigate("will-navigate"));
     expect(getActiveSearch(getState())).toBe(null);
   });
 
   it("navigation clears the file-search query", async () => {
-    const { dispatch, getState, cx } = createStore(threadClient);
+    const { dispatch, getState } = createStore(threadClient);
 
-    dispatch(actions.setFileSearchQuery(cx, "foobar"));
+    dispatch(actions.setFileSearchQuery("foobar"));
     expect(getFileSearchQuery(getState())).toBe("foobar");
 
     await dispatch(actions.willNavigate("will-navigate"));
 
     expect(getFileSearchQuery(getState())).toBe("");
   });
 
   it("navigation clears the file-search results", async () => {
-    const { dispatch, getState, cx } = createStore(threadClient);
+    const { dispatch, getState } = createStore(threadClient);
 
     const searchResults = [{ line: 1, ch: 3 }, { line: 3, ch: 2 }];
-    dispatch(actions.updateSearchResults(cx, 2, 3, searchResults));
+    dispatch(actions.updateSearchResults(2, 3, searchResults));
     expect(getFileSearchResults(getState())).toEqual({
       count: 2,
       index: 2,
       matchIndex: 1,
       matches: searchResults
     });
 
     await dispatch(actions.willNavigate("will-navigate"));
--- a/devtools/client/debugger/new/src/actions/tests/pending-breakpoints.spec.js
+++ b/devtools/client/debugger/new/src/actions/tests/pending-breakpoints.spec.js
@@ -64,31 +64,31 @@ function mockSourceMaps() {
       { start: { line: 0, column: 0 }, end: { line: 10, column: 10 } }
     ],
     getOriginalLocations: async items => items
   };
 }
 
 describe("when adding breakpoints", () => {
   it("a corresponding pending breakpoint should be added", async () => {
-    const { dispatch, getState, cx } = createStore(
+    const { dispatch, getState } = createStore(
       mockClient({ "5": [1] }),
       loadInitialState(),
       mockSourceMaps()
     );
 
     const source = makeSource("foo.js");
     await dispatch(actions.newSource(source));
     await dispatch(actions.newSource(makeSource("foo.js")));
-    await dispatch(actions.loadSourceText(cx, source));
+    await dispatch(actions.loadSourceText(source));
 
     const bp = generateBreakpoint("foo.js", 5, 1);
     const id = makePendingLocationId(bp.location);
 
-    await dispatch(actions.addBreakpoint(cx, bp.location));
+    await dispatch(actions.addBreakpoint(bp.location));
     const pendingBps = selectors.getPendingBreakpoints(getState());
 
     expect(selectors.getPendingBreakpointList(getState())).toHaveLength(2);
     expect(pendingBps[id]).toMatchSnapshot();
   });
 
   describe("adding and deleting breakpoints", () => {
     let breakpoint1;
@@ -99,160 +99,160 @@ describe("when adding breakpoints", () =
     beforeEach(() => {
       breakpoint1 = generateBreakpoint("foo");
       breakpoint2 = generateBreakpoint("foo2");
       breakpointLocationId1 = makePendingLocationId(breakpoint1.location);
       breakpointLocationId2 = makePendingLocationId(breakpoint2.location);
     });
 
     it("add a corresponding pendingBreakpoint for each addition", async () => {
-      const { dispatch, getState, cx } = createStore(
+      const { dispatch, getState } = createStore(
         mockClient({ "5": [0] }),
         loadInitialState(),
         mockSourceMaps()
       );
 
       const source1 = makeSource("foo");
       const source2 = makeSource("foo2");
 
       await dispatch(actions.newSource(makeSource("foo")));
       await dispatch(actions.newSource(makeSource("foo2")));
 
       await dispatch(actions.newSource(source1));
       await dispatch(actions.newSource(source2));
 
-      await dispatch(actions.loadSourceText(cx, source1));
-      await dispatch(actions.loadSourceText(cx, source2));
+      await dispatch(actions.loadSourceText(source1));
+      await dispatch(actions.loadSourceText(source2));
 
-      await dispatch(actions.addBreakpoint(cx, breakpoint1.location));
-      await dispatch(actions.addBreakpoint(cx, breakpoint2.location));
+      await dispatch(actions.addBreakpoint(breakpoint1.location));
+      await dispatch(actions.addBreakpoint(breakpoint2.location));
 
       const pendingBps = selectors.getPendingBreakpoints(getState());
 
       // NOTE the sourceId should be `foo2/originalSource`, but is `foo2`
       // because we do not have a real source map for `getOriginalLocation`
       // to map.
       expect(pendingBps[breakpointLocationId1]).toMatchSnapshot();
       expect(pendingBps[breakpointLocationId2]).toMatchSnapshot();
     });
 
     it("hidden breakponts do not create pending bps", async () => {
-      const { dispatch, getState, cx } = createStore(
+      const { dispatch, getState } = createStore(
         mockClient({ "5": [0] }),
         loadInitialState(),
         mockSourceMaps()
       );
 
       const source = makeSource("foo");
       await dispatch(actions.newSource(makeSource("foo")));
       await dispatch(actions.newSource(source));
-      await dispatch(actions.loadSourceText(cx, source));
+      await dispatch(actions.loadSourceText(source));
 
       await dispatch(
-        actions.addBreakpoint(cx, breakpoint1.location, { hidden: true })
+        actions.addBreakpoint(breakpoint1.location, { hidden: true })
       );
       const pendingBps = selectors.getPendingBreakpoints(getState());
 
       expect(pendingBps[breakpointLocationId1]).toBeUndefined();
     });
 
     it("remove a corresponding pending breakpoint when deleting", async () => {
-      const { dispatch, getState, cx } = createStore(
+      const { dispatch, getState } = createStore(
         mockClient({ "5": [0] }),
         loadInitialState(),
         mockSourceMaps()
       );
 
       await dispatch(actions.newSource(makeSource("foo")));
       await dispatch(actions.newSource(makeSource("foo2")));
 
       const source1 = makeSource("foo");
       const source2 = makeSource("foo2");
 
       await dispatch(actions.newSource(source1));
       await dispatch(actions.newSource(source2));
 
-      await dispatch(actions.loadSourceText(cx, source1));
-      await dispatch(actions.loadSourceText(cx, source2));
+      await dispatch(actions.loadSourceText(source1));
+      await dispatch(actions.loadSourceText(source2));
 
-      await dispatch(actions.addBreakpoint(cx, breakpoint1.location));
-      await dispatch(actions.addBreakpoint(cx, breakpoint2.location));
-      await dispatch(actions.removeBreakpoint(cx, breakpoint1));
+      await dispatch(actions.addBreakpoint(breakpoint1.location));
+      await dispatch(actions.addBreakpoint(breakpoint2.location));
+      await dispatch(actions.removeBreakpoint(breakpoint1));
 
       const pendingBps = selectors.getPendingBreakpoints(getState());
       expect(pendingBps.hasOwnProperty(breakpointLocationId1)).toBe(false);
       expect(pendingBps.hasOwnProperty(breakpointLocationId2)).toBe(true);
     });
   });
 });
 
 describe("when changing an existing breakpoint", () => {
   it("updates corresponding pendingBreakpoint", async () => {
-    const { dispatch, getState, cx } = createStore(
+    const { dispatch, getState } = createStore(
       mockClient({ "5": [0] }),
       loadInitialState(),
       mockSourceMaps()
     );
     const bp = generateBreakpoint("foo");
     const id = makePendingLocationId(bp.location);
 
     const source = makeSource("foo");
     await dispatch(actions.newSource(source));
     await dispatch(actions.newSource(makeSource("foo")));
-    await dispatch(actions.loadSourceText(cx, source));
+    await dispatch(actions.loadSourceText(source));
 
-    await dispatch(actions.addBreakpoint(cx, bp.location));
+    await dispatch(actions.addBreakpoint(bp.location));
     await dispatch(
-      actions.setBreakpointOptions(cx, bp.location, { condition: "2" })
+      actions.setBreakpointOptions(bp.location, { condition: "2" })
     );
     const bps = selectors.getPendingBreakpoints(getState());
     const breakpoint = bps[id];
     expect(breakpoint.options.condition).toBe("2");
   });
 
   it("if disabled, updates corresponding pendingBreakpoint", async () => {
-    const { dispatch, getState, cx } = createStore(
+    const { dispatch, getState } = createStore(
       mockClient({ "5": [0] }),
       loadInitialState(),
       mockSourceMaps()
     );
     const bp = generateBreakpoint("foo");
     const id = makePendingLocationId(bp.location);
 
     await dispatch(actions.newSource(makeSource("foo")));
 
     const source = makeSource("foo");
     await dispatch(actions.newSource(source));
-    await dispatch(actions.loadSourceText(cx, source));
+    await dispatch(actions.loadSourceText(source));
 
-    await dispatch(actions.addBreakpoint(cx, bp.location));
-    await dispatch(actions.disableBreakpoint(cx, bp));
+    await dispatch(actions.addBreakpoint(bp.location));
+    await dispatch(actions.disableBreakpoint(bp));
     const bps = selectors.getPendingBreakpoints(getState());
     const breakpoint = bps[id];
     expect(breakpoint.disabled).toBe(true);
   });
 
   it("does not delete the pre-existing pendingBreakpoint", async () => {
-    const { dispatch, getState, cx } = createStore(
+    const { dispatch, getState } = createStore(
       mockClient({ "5": [0] }),
       loadInitialState(),
       mockSourceMaps()
     );
     const bp = generateBreakpoint("foo.js");
 
     const source = makeSource("foo.js");
     await dispatch(actions.newSource(source));
     await dispatch(actions.newSource(makeSource("foo.js")));
-    await dispatch(actions.loadSourceText(cx, source));
+    await dispatch(actions.loadSourceText(source));
 
     const id = makePendingLocationId(bp.location);
 
-    await dispatch(actions.addBreakpoint(cx, bp.location));
+    await dispatch(actions.addBreakpoint(bp.location));
     await dispatch(
-      actions.setBreakpointOptions(cx, bp.location, { condition: "2" })
+      actions.setBreakpointOptions(bp.location, { condition: "2" })
     );
     const bps = selectors.getPendingBreakpoints(getState());
     const breakpoint = bps[id];
     expect(breakpoint.options.condition).toBe("2");
   });
 });
 
 describe("initializing when pending breakpoints exist in prefs", () => {
@@ -262,68 +262,68 @@ describe("initializing when pending brea
       loadInitialState(),
       mockSourceMaps()
     );
     const bps = selectors.getPendingBreakpoints(getState());
     expect(bps).toMatchSnapshot();
   });
 
   it("re-adding breakpoints update existing pending breakpoints", async () => {
-    const { dispatch, getState, cx } = createStore(
+    const { dispatch, getState } = createStore(
       mockClient({ "5": [1, 2] }),
       loadInitialState(),
       mockSourceMaps()
     );
     const bar = generateBreakpoint("bar.js", 5, 1);
 
     await dispatch(actions.newSource(makeSource("bar.js")));
 
     const source = makeSource("bar.js");
     await dispatch(actions.newSource(source));
-    await dispatch(actions.loadSourceText(cx, source));
-    await dispatch(actions.addBreakpoint(cx, bar.location));
+    await dispatch(actions.loadSourceText(source));
+    await dispatch(actions.addBreakpoint(bar.location));
 
     const bps = selectors.getPendingBreakpointList(getState());
     expect(bps).toHaveLength(2);
   });
 
   it("adding bps doesn't remove existing pending breakpoints", async () => {
-    const { dispatch, getState, cx } = createStore(
+    const { dispatch, getState } = createStore(
       mockClient({ "5": [0] }),
       loadInitialState(),
       mockSourceMaps()
     );
     const bp = generateBreakpoint("foo.js");
 
     const source = makeSource("foo.js");
     await dispatch(actions.newSource(source));
     await dispatch(actions.newSource(makeSource("foo.js")));
-    await dispatch(actions.loadSourceText(cx, source));
+    await dispatch(actions.loadSourceText(source));
 
-    await dispatch(actions.addBreakpoint(cx, bp.location));
+    await dispatch(actions.addBreakpoint(bp.location));
 
     const bps = selectors.getPendingBreakpointList(getState());
     expect(bps).toHaveLength(2);
   });
 });
 
 describe("initializing with disabled pending breakpoints in prefs", () => {
   it("syncs breakpoints with pending breakpoints", async () => {
     const store = createStore(
       mockClient({ "5": [2] }),
       loadInitialState({ disabled: true }),
       mockSourceMaps()
     );
 
-    const { getState, dispatch, cx } = store;
+    const { getState, dispatch } = store;
     const source = makeSource("bar.js");
 
     await dispatch(actions.newSource(makeSource("bar.js")));
     await dispatch(actions.newSource(source));
-    await dispatch(actions.loadSourceText(cx, source));
+    await dispatch(actions.loadSourceText(source));
 
     await waitForState(store, state => {
       const bps = selectors.getBreakpointsForSource(state, source.id);
       return bps && Object.values(bps).length > 0;
     });
 
     const bp = selectors.getBreakpointForLocation(getState(), {
       line: 5,
@@ -341,25 +341,25 @@ describe("initializing with disabled pen
 
 describe("adding sources", () => {
   it("corresponding breakpoints are added for a single source", async () => {
     const store = createStore(
       mockClient({ "5": [2] }),
       loadInitialState({ disabled: true }),
       mockSourceMaps()
     );
-    const { getState, dispatch, cx } = store;
+    const { getState, dispatch } = store;
 
     expect(selectors.getBreakpointCount(getState())).toEqual(0);
 
     const source = makeSource("bar.js");
 
     await dispatch(actions.newSource(makeSource("bar.js")));
     await dispatch(actions.newSource(source));
-    await dispatch(actions.loadSourceText(cx, source));
+    await dispatch(actions.loadSourceText(source));
 
     await waitForState(store, state => selectors.getBreakpointCount(state) > 0);
 
     expect(selectors.getBreakpointCount(getState())).toEqual(1);
   });
 
   it("corresponding breakpoints are added to the original source", async () => {
     const source = makeSource("bar.js", { sourceMapURL: "foo" });
@@ -391,24 +391,24 @@ describe("adding sources", () => {
   });
 
   it("add corresponding breakpoints for multiple sources", async () => {
     const store = createStore(
       mockClient({ "5": [2] }),
       loadInitialState({ disabled: true }),
       mockSourceMaps()
     );
-    const { getState, dispatch, cx } = store;
+    const { getState, dispatch } = store;
 
     expect(selectors.getBreakpointCount(getState())).toEqual(0);
 
     const source1 = makeSource("bar.js");
     const source2 = makeSource("foo.js");
     await dispatch(actions.newSource(makeSource("bar.js")));
     await dispatch(actions.newSource(makeSource("foo.js")));
     await dispatch(actions.newSources([source1, source2]));
-    await dispatch(actions.loadSourceText(cx, source1));
-    await dispatch(actions.loadSourceText(cx, source2));
+    await dispatch(actions.loadSourceText(source1));
+    await dispatch(actions.loadSourceText(source2));
 
     await waitForState(store, state => selectors.getBreakpointCount(state) > 0);
     expect(selectors.getBreakpointCount(getState())).toEqual(1);
   });
 });
--- a/devtools/client/debugger/new/src/actions/tests/project-text-search.spec.js
+++ b/devtools/client/debugger/new/src/actions/tests/project-text-search.spec.js
@@ -39,34 +39,34 @@ const sources = {
 
 const threadClient = {
   sourceContents: async ({ source }) => sources[source],
   getBreakpointPositions: async () => ({})
 };
 
 describe("project text search", () => {
   it("should add a project text search query", () => {
-    const { dispatch, getState, cx } = createStore();
+    const { dispatch, getState } = createStore();
     const mockQuery = "foo";
 
-    dispatch(actions.addSearchQuery(cx, mockQuery));
+    dispatch(actions.addSearchQuery(mockQuery));
 
     expect(getTextSearchQuery(getState())).toEqual(mockQuery);
   });
 
   it("should search all the loaded sources based on the query", async () => {
-    const { dispatch, getState, cx } = createStore(threadClient);
+    const { dispatch, getState } = createStore(threadClient);
     const mockQuery = "foo";
     const source1 = makeSource("foo1");
     const source2 = makeSource("foo2");
 
     await dispatch(actions.newSource(source1));
     await dispatch(actions.newSource(source2));
 
-    await dispatch(actions.searchSources(cx, mockQuery));
+    await dispatch(actions.searchSources(mockQuery));
 
     const results = getTextSearchResults(getState());
     expect(results).toMatchSnapshot();
   });
 
   it("should ignore sources with minified versions", async () => {
     const source1 = makeSource("bar", { sourceMapURL: "bar:formatted" });
     const source2 = makeSource("bar:formatted");
@@ -76,82 +76,82 @@ describe("project text search", () => {
         source: "function bla(x, y) {\n const bar = 4; return 2;\n}",
         contentType: "text/javascript"
       }),
       getOriginalURLs: async () => [source2.url],
       getGeneratedRangesForOriginal: async () => [],
       getOriginalLocations: async items => items
     };
 
-    const { dispatch, getState, cx } = createStore(threadClient, {}, mockMaps);
+    const { dispatch, getState } = createStore(threadClient, {}, mockMaps);
     const mockQuery = "bla";
 
     await dispatch(actions.newSource(source1));
     await dispatch(actions.newSource(source2));
 
-    await dispatch(actions.searchSources(cx, mockQuery));
+    await dispatch(actions.searchSources(mockQuery));
 
     const results = getTextSearchResults(getState());
     expect(results).toMatchSnapshot();
   });
 
   it("should search a specific source", async () => {
-    const { dispatch, getState, cx } = createStore(threadClient);
+    const { dispatch, getState } = createStore(threadClient);
 
     const source = makeSource("bar");
     await dispatch(actions.newSource(source));
-    await dispatch(actions.loadSourceText(cx, source));
+    await dispatch(actions.loadSourceText(source));
 
-    dispatch(actions.addSearchQuery(cx, "bla"));
+    dispatch(actions.addSearchQuery("bla"));
 
     const barSource = getSource(getState(), "bar");
     if (!barSource) {
       throw new Error("no barSource");
     }
     const sourceId = barSource.id;
 
-    await dispatch(actions.searchSource(cx, sourceId, "bla"), "bla");
+    await dispatch(actions.searchSource(sourceId, "bla"), "bla");
 
     const results = getTextSearchResults(getState());
 
     expect(results).toMatchSnapshot();
     expect(results).toHaveLength(1);
   });
 
   it("should clear all the search results", async () => {
-    const { dispatch, getState, cx } = createStore(threadClient);
+    const { dispatch, getState } = createStore(threadClient);
     const mockQuery = "foo";
 
     await dispatch(actions.newSource(makeSource("foo1")));
-    await dispatch(actions.searchSources(cx, mockQuery));
+    await dispatch(actions.searchSources(mockQuery));
 
     expect(getTextSearchResults(getState())).toMatchSnapshot();
 
-    await dispatch(actions.clearSearchResults(cx));
+    await dispatch(actions.clearSearchResults());
 
     expect(getTextSearchResults(getState())).toMatchSnapshot();
   });
 
   it("should set the status properly", () => {
-    const { dispatch, getState, cx } = createStore();
+    const { dispatch, getState } = createStore();
     const mockStatus = "Fetching";
-    dispatch(actions.updateSearchStatus(cx, mockStatus));
+    dispatch(actions.updateSearchStatus(mockStatus));
     expect(getTextSearchStatus(getState())).toEqual(mockStatus);
   });
 
   it("should close project search", async () => {
-    const { dispatch, getState, cx } = createStore(threadClient);
+    const { dispatch, getState } = createStore(threadClient);
     const mockQuery = "foo";
 
     await dispatch(actions.newSource(makeSource("foo1")));
-    await dispatch(actions.searchSources(cx, mockQuery));
+    await dispatch(actions.searchSources(mockQuery));
 
     expect(getTextSearchResults(getState())).toMatchSnapshot();
 
-    dispatch(actions.closeProjectSearch(cx));
+    dispatch(actions.closeProjectSearch());
 
     expect(getTextSearchQuery(getState())).toEqual("");
 
     const results = getTextSearchResults(getState());
 
     expect(results).toMatchSnapshot();
     expect(results).toHaveLength(0);
     const status = getTextSearchStatus(getState());
--- a/devtools/client/debugger/new/src/actions/tests/setProjectDirectoryRoot.spec.js
+++ b/devtools/client/debugger/new/src/actions/tests/setProjectDirectoryRoot.spec.js
@@ -12,67 +12,67 @@ import {
 } from "../../utils/test-head";
 
 import type { Source } from "../../types";
 
 const { getProjectDirectoryRoot, getDisplayedSources } = selectors;
 
 describe("setProjectDirectoryRoot", () => {
   it("should set domain directory as root", async () => {
-    const { dispatch, getState, cx } = createStore();
-    dispatch(actions.setProjectDirectoryRoot(cx, "example.com"));
+    const { dispatch, getState } = createStore();
+    dispatch(actions.setProjectDirectoryRoot("example.com"));
     expect(getProjectDirectoryRoot(getState())).toBe("example.com");
   });
 
   it("should set a directory as root directory", async () => {
-    const { dispatch, getState, cx } = createStore();
-    dispatch(actions.setProjectDirectoryRoot(cx, "/example.com/foo"));
+    const { dispatch, getState } = createStore();
+    dispatch(actions.setProjectDirectoryRoot("/example.com/foo"));
     expect(getProjectDirectoryRoot(getState())).toBe("/example.com/foo");
   });
 
   it("should add to the directory ", () => {
-    const { dispatch, getState, cx } = createStore();
-    dispatch(actions.setProjectDirectoryRoot(cx, "/example.com/foo"));
-    dispatch(actions.setProjectDirectoryRoot(cx, "/foo/bar"));
+    const { dispatch, getState } = createStore();
+    dispatch(actions.setProjectDirectoryRoot("/example.com/foo"));
+    dispatch(actions.setProjectDirectoryRoot("/foo/bar"));
     expect(getProjectDirectoryRoot(getState())).toBe("/example.com/foo/bar");
   });
 
   it("should update the directory ", () => {
-    const { dispatch, getState, cx } = createStore();
-    dispatch(actions.setProjectDirectoryRoot(cx, "/example.com/foo"));
-    dispatch(actions.clearProjectDirectoryRoot(cx));
-    dispatch(actions.setProjectDirectoryRoot(cx, "/example.com/bar"));
+    const { dispatch, getState } = createStore();
+    dispatch(actions.setProjectDirectoryRoot("/example.com/foo"));
+    dispatch(actions.clearProjectDirectoryRoot());
+    dispatch(actions.setProjectDirectoryRoot("/example.com/bar"));
     expect(getProjectDirectoryRoot(getState())).toBe("/example.com/bar");
   });
 
   it("should filter sources", async () => {
     const store = createStore({});
-    const { dispatch, getState, cx } = store;
+    const { dispatch, getState } = store;
     await dispatch(actions.newSource(makeSource("js/scopes.js")));
     await dispatch(actions.newSource(makeSource("lib/vendor.js")));
 
-    dispatch(actions.setProjectDirectoryRoot(cx, "localhost:8000/examples/js"));
+    dispatch(actions.setProjectDirectoryRoot("localhost:8000/examples/js"));
 
     const filteredSourcesByThread = getDisplayedSources(getState());
     const filteredSources = Object.values(filteredSourcesByThread)[0];
     const firstSource: Source = (Object.values(filteredSources)[0]: any);
 
     expect(firstSource.url).toEqual(
       "http://localhost:8000/examples/js/scopes.js"
     );
 
     expect(firstSource.relativeUrl).toEqual("scopes.js");
   });
 
   it("should update the child directory ", () => {
-    const { dispatch, getState, cx } = createStore();
-    dispatch(actions.setProjectDirectoryRoot(cx, "example.com"));
-    dispatch(actions.setProjectDirectoryRoot(cx, "example.com/foo/bar"));
+    const { dispatch, getState } = createStore();
+    dispatch(actions.setProjectDirectoryRoot("example.com"));
+    dispatch(actions.setProjectDirectoryRoot("example.com/foo/bar"));
     expect(getProjectDirectoryRoot(getState())).toBe("example.com/foo/bar");
   });
 
   it("should update the child directory when domain name is Webpack://", () => {
-    const { dispatch, getState, cx } = createStore();
-    dispatch(actions.setProjectDirectoryRoot(cx, "webpack://"));
-    dispatch(actions.setProjectDirectoryRoot(cx, "webpack:///app"));
+    const { dispatch, getState } = createStore();
+    dispatch(actions.setProjectDirectoryRoot("webpack://"));
+    dispatch(actions.setProjectDirectoryRoot("webpack:///app"));
     expect(getProjectDirectoryRoot(getState())).toBe("webpack:///app");
   });
 });
--- a/devtools/client/debugger/new/src/actions/tests/tabs.spec.js
+++ b/devtools/client/debugger/new/src/actions/tests/tabs.spec.js
@@ -11,125 +11,121 @@ import {
   makeSource
 } from "../../utils/test-head";
 const { getSelectedSource, getSourceTabs } = selectors;
 
 import { sourceThreadClient as threadClient } from "./helpers/threadClient.js";
 
 describe("closing tabs", () => {
   it("closing a tab", async () => {
-    const { dispatch, getState, cx } = createStore(threadClient);
+    const { dispatch, getState } = createStore(threadClient);
 
     const fooSource = makeSource("foo.js");
     await dispatch(actions.newSource(fooSource));
-    await dispatch(actions.selectLocation(cx, { sourceId: "foo.js", line: 1 }));
-    dispatch(actions.closeTab(cx, fooSource));
+    await dispatch(actions.selectLocation({ sourceId: "foo.js", line: 1 }));
+    dispatch(actions.closeTab(fooSource));
 
     expect(getSelectedSource(getState())).toBe(undefined);
     expect(getSourceTabs(getState())).toHaveLength(0);
   });
 
   it("closing the inactive tab", async () => {
-    const { dispatch, getState, cx } = createStore(threadClient);
+    const { dispatch, getState } = createStore(threadClient);
 
     const fooSource = makeSource("foo.js");
     await dispatch(actions.newSource(fooSource));
     await dispatch(actions.newSource(makeSource("bar.js")));
-    await dispatch(actions.selectLocation(cx, { sourceId: "foo.js", line: 1 }));
-    await dispatch(actions.selectLocation(cx, { sourceId: "bar.js", line: 1 }));
-    dispatch(actions.closeTab(cx, fooSource));
+    await dispatch(actions.selectLocation({ sourceId: "foo.js", line: 1 }));
+    await dispatch(actions.selectLocation({ sourceId: "bar.js", line: 1 }));
+    dispatch(actions.closeTab(fooSource));
 
     const selected = getSelectedSource(getState());
     expect(selected && selected.id).toBe("bar.js");
     expect(getSourceTabs(getState())).toHaveLength(1);
   });
 
   it("closing the only tab", async () => {
-    const { dispatch, getState, cx } = createStore(threadClient);
+    const { dispatch, getState } = createStore(threadClient);
 
     const fooSource = makeSource("foo.js");
     await dispatch(actions.newSource(fooSource));
-    await dispatch(actions.selectLocation(cx, { sourceId: "foo.js", line: 1 }));
-    dispatch(actions.closeTab(cx, fooSource));
+    await dispatch(actions.selectLocation({ sourceId: "foo.js", line: 1 }));
+    dispatch(actions.closeTab(fooSource));
 
     expect(getSelectedSource(getState())).toBe(undefined);
     expect(getSourceTabs(getState())).toHaveLength(0);
   });
 
   it("closing the active tab", async () => {
-    const { dispatch, getState, cx } = createStore(threadClient);
+    const { dispatch, getState } = createStore(threadClient);
 
     const barSource = makeSource("bar.js");
     await dispatch(actions.newSource(makeSource("foo.js")));
     await dispatch(actions.newSource(barSource));
-    await dispatch(actions.selectLocation(cx, { sourceId: "foo.js", line: 1 }));
-    await dispatch(actions.selectLocation(cx, { sourceId: "bar.js", line: 1 }));
-    await dispatch(actions.closeTab(cx, barSource));
+    await dispatch(actions.selectLocation({ sourceId: "foo.js", line: 1 }));
+    await dispatch(actions.selectLocation({ sourceId: "bar.js", line: 1 }));
+    await dispatch(actions.closeTab(barSource));
 
     const selected = getSelectedSource(getState());
     expect(selected && selected.id).toBe("foo.js");
     expect(getSourceTabs(getState())).toHaveLength(1);
   });
 
   it("closing many inactive tabs", async () => {
-    const { dispatch, getState, cx } = createStore(threadClient);
+    const { dispatch, getState } = createStore(threadClient);
 
     const fooSource = makeSource("foo.js");
     const barSource = makeSource("bar.js");
     await dispatch(actions.newSource(fooSource));
     await dispatch(actions.newSource(barSource));
     await dispatch(actions.newSource(makeSource("bazz.js")));
-    await dispatch(actions.selectLocation(cx, { sourceId: "foo.js", line: 1 }));
-    await dispatch(actions.selectLocation(cx, { sourceId: "bar.js", line: 1 }));
-    await dispatch(
-      actions.selectLocation(cx, { sourceId: "bazz.js", line: 1 })
-    );
+    await dispatch(actions.selectLocation({ sourceId: "foo.js", line: 1 }));
+    await dispatch(actions.selectLocation({ sourceId: "bar.js", line: 1 }));
+    await dispatch(actions.selectLocation({ sourceId: "bazz.js", line: 1 }));
 
     const tabs = [
       "http://localhost:8000/examples/foo.js",
       "http://localhost:8000/examples/bar.js"
     ];
-    dispatch(actions.closeTabs(cx, tabs));
+    dispatch(actions.closeTabs(tabs));
 
     const selected = getSelectedSource(getState());
     expect(selected && selected.id).toBe("bazz.js");
     expect(getSourceTabs(getState())).toHaveLength(1);
   });
 
   it("closing many tabs including the active tab", async () => {
-    const { dispatch, getState, cx } = createStore(threadClient);
+    const { dispatch, getState } = createStore(threadClient);
 
     await dispatch(actions.newSource(makeSource("foo.js")));
     await dispatch(actions.newSource(makeSource("bar.js")));
     await dispatch(actions.newSource(makeSource("bazz.js")));
-    await dispatch(actions.selectLocation(cx, { sourceId: "foo.js", line: 1 }));
-    await dispatch(actions.selectLocation(cx, { sourceId: "bar.js", line: 1 }));
-    await dispatch(
-      actions.selectLocation(cx, { sourceId: "bazz.js", line: 1 })
-    );
+    await dispatch(actions.selectLocation({ sourceId: "foo.js", line: 1 }));
+    await dispatch(actions.selectLocation({ sourceId: "bar.js", line: 1 }));
+    await dispatch(actions.selectLocation({ sourceId: "bazz.js", line: 1 }));
     const tabs = [
       "http://localhost:8000/examples/bar.js",
       "http://localhost:8000/examples/bazz.js"
     ];
-    await dispatch(actions.closeTabs(cx, tabs));
+    await dispatch(actions.closeTabs(tabs));
 
     const selected = getSelectedSource(getState());
     expect(selected && selected.id).toBe("foo.js");
     expect(getSourceTabs(getState())).toHaveLength(1);
   });
 
   it("closing all the tabs", async () => {
-    const { dispatch, getState, cx } = createStore(threadClient);
+    const { dispatch, getState } = createStore(threadClient);
 
     await dispatch(actions.newSource(makeSource("foo.js")));
     await dispatch(actions.newSource(makeSource("bar.js")));
-    await dispatch(actions.selectLocation(cx, { sourceId: "foo.js", line: 1 }));
-    await dispatch(actions.selectLocation(cx, { sourceId: "bar.js", line: 1 }));
+    await dispatch(actions.selectLocation({ sourceId: "foo.js", line: 1 }));
+    await dispatch(actions.selectLocation({ sourceId: "bar.js", line: 1 }));
     await dispatch(
-      actions.closeTabs(cx, [
+      actions.closeTabs([
         "http://localhost:8000/examples/foo.js",
         "http://localhost:8000/examples/bar.js"
       ])
     );
 
     expect(getSelectedSource(getState())).toBe(undefined);
     expect(getSourceTabs(getState())).toHaveLength(0);
   });
--- a/devtools/client/debugger/new/src/actions/tests/ui.spec.js
+++ b/devtools/client/debugger/new/src/actions/tests/ui.spec.js
@@ -80,67 +80,67 @@ describe("ui", () => {
     dispatch(actions.highlightLineRange(range));
     dispatch(actions.clearHighlightLineRange());
     expect(getHighlightedLineRange(getState())).toEqual({});
   });
 });
 
 describe("setProjectDirectoryRoot", () => {
   it("should set domain directory as root", () => {
-    const { dispatch, getState, cx } = createStore();
-    dispatch(actions.setProjectDirectoryRoot(cx, "example.com"));
+    const { dispatch, getState } = createStore();
+    dispatch(actions.setProjectDirectoryRoot("example.com"));
     expect(getProjectDirectoryRoot(getState())).toBe("example.com");
   });
 
   it("should set a directory as root directory", () => {
-    const { dispatch, getState, cx } = createStore();
-    dispatch(actions.setProjectDirectoryRoot(cx, "/example.com/foo"));
+    const { dispatch, getState } = createStore();
+    dispatch(actions.setProjectDirectoryRoot("/example.com/foo"));
     expect(getProjectDirectoryRoot(getState())).toBe("/example.com/foo");
   });
 
   it("should add to the directory ", () => {
-    const { dispatch, getState, cx } = createStore();
-    dispatch(actions.setProjectDirectoryRoot(cx, "/example.com/foo"));
-    dispatch(actions.setProjectDirectoryRoot(cx, "/foo/bar"));
+    const { dispatch, getState } = createStore();
+    dispatch(actions.setProjectDirectoryRoot("/example.com/foo"));
+    dispatch(actions.setProjectDirectoryRoot("/foo/bar"));
     expect(getProjectDirectoryRoot(getState())).toBe("/example.com/foo/bar");
   });
 
   it("should update the directory ", () => {
-    const { dispatch, getState, cx } = createStore();
-    dispatch(actions.setProjectDirectoryRoot(cx, "/example.com/foo"));
-    dispatch(actions.clearProjectDirectoryRoot(cx));
-    dispatch(actions.setProjectDirectoryRoot(cx, "/example.com/bar"));
+    const { dispatch, getState } = createStore();
+    dispatch(actions.setProjectDirectoryRoot("/example.com/foo"));
+    dispatch(actions.clearProjectDirectoryRoot());
+    dispatch(actions.setProjectDirectoryRoot("/example.com/bar"));
     expect(getProjectDirectoryRoot(getState())).toBe("/example.com/bar");
   });
 
   it("should filter sources", async () => {
     const store = createStore({});
-    const { dispatch, getState, cx } = store;
+    const { dispatch, getState } = store;
     await dispatch(actions.newSource(makeSource("js/scopes.js")));
     await dispatch(actions.newSource(makeSource("lib/vendor.js")));
 
-    dispatch(actions.setProjectDirectoryRoot(cx, "localhost:8000/examples/js"));
+    dispatch(actions.setProjectDirectoryRoot("localhost:8000/examples/js"));
 
     const filteredSourcesByThread = getDisplayedSources(getState());
     const filteredSources = Object.values(filteredSourcesByThread)[0];
     const firstSource: Source = (Object.values(filteredSources)[0]: any);
 
     expect(firstSource.url).toEqual(
       "http://localhost:8000/examples/js/scopes.js"
     );
 
     expect(firstSource.relativeUrl).toEqual("scopes.js");
   });
 
   it("should update the child directory ", () => {
-    const { dispatch, getState, cx } = createStore();
-    dispatch(actions.setProjectDirectoryRoot(cx, "example.com"));
-    dispatch(actions.setProjectDirectoryRoot(cx, "example.com/foo/bar"));
+    const { dispatch, getState } = createStore();
+    dispatch(actions.setProjectDirectoryRoot("example.com"));
+    dispatch(actions.setProjectDirectoryRoot("example.com/foo/bar"));
     expect(getProjectDirectoryRoot(getState())).toBe("example.com/foo/bar");
   });
 
   it("should update the child directory when domain name is Webpack://", () => {
-    const { dispatch, getState, cx } = createStore();
-    dispatch(actions.setProjectDirectoryRoot(cx, "webpack://"));
-    dispatch(actions.setProjectDirectoryRoot(cx, "webpack:///app"));
+    const { dispatch, getState } = createStore();
+    dispatch(actions.setProjectDirectoryRoot("webpack://"));
+    dispatch(actions.setProjectDirectoryRoot("webpack:///app"));
     expect(getProjectDirectoryRoot(getState())).toBe("webpack:///app");
   });
 });
--- a/devtools/client/debugger/new/src/actions/types/ASTAction.js
+++ b/devtools/client/debugger/new/src/actions/types/ASTAction.js
@@ -1,46 +1,40 @@
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at <http://mozilla.org/MPL/2.0/>. */
 
 // @flow
 
 import type { SymbolDeclarations, AstLocation } from "../../workers/parser";
 import type { PromiseAction } from "../utils/middleware/promise";
-import type { Context } from "../../types";
 
 export type ASTAction =
   | PromiseAction<
       {|
         +type: "SET_SYMBOLS",
-        +cx: Context,
         +sourceId: string
       |},
       SymbolDeclarations
     >
   | {|
       +type: "OUT_OF_SCOPE_LOCATIONS",
-      +cx: Context,
       +locations: ?(AstLocation[])
     |}
   | {|
       +type: "IN_SCOPE_LINES",
-      +cx: Context,
       +lines: number[]
     |}
   | PromiseAction<
       {|
-        +type: "SET_PREVIEW",
-        +cx: Context
+        +type: "SET_PREVIEW"
       |},
       {
         expression: string,
         result: any,
         location: AstLocation,
         tokenPos: any,
         cursorPos: any
       }
     >
   | {|
-      +type: "CLEAR_SELECTION",
-      +cx: Context
+      +type: "CLEAR_SELECTION"
     |};
--- a/devtools/client/debugger/new/src/actions/types/BreakpointAction.js
+++ b/devtools/client/debugger/new/src/actions/types/BreakpointAction.js
@@ -4,18 +4,17 @@
 
 // @flow
 
 import type {
   Breakpoint,
   SourceLocation,
   XHRBreakpoint,
   Source,
-  BreakpointPositions,
-  Context
+  BreakpointPositions
 } from "../../types";
 
 import type { PromiseAction } from "../utils/middleware/promise";
 
 export type BreakpointAction =
   | PromiseAction<{|
       +type: "SET_XHR_BREAKPOINT",
       +breakpoint: XHRBreakpoint
@@ -37,22 +36,19 @@ export type BreakpointAction =
     |}>
   | PromiseAction<{|
       +type: "REMOVE_XHR_BREAKPOINT",
       +index: number,
       +breakpoint: XHRBreakpoint
     |}>
   | {|
       +type: "SET_BREAKPOINT",
-      +cx: Context,
       +breakpoint: Breakpoint
     |}
   | {|
       +type: "REMOVE_BREAKPOINT",
-      +cx: Context,
       +location: SourceLocation
     |}
   | {|
       type: "ADD_BREAKPOINT_POSITIONS",
-      +cx: Context,
       positions: BreakpointPositions,
       source: Source
     |};
--- a/devtools/client/debugger/new/src/actions/types/PauseAction.js
+++ b/devtools/client/debugger/new/src/actions/types/PauseAction.js
@@ -1,151 +1,130 @@
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at <http://mozilla.org/MPL/2.0/>. */
 
 // @flow
 
 import type { Command } from "../../reducers/types";
-import type {
-  Expression,
-  LoadedObject,
-  Frame,
-  Scope,
-  Why,
-  ThreadContext
-} from "../../types";
+import type { Expression, LoadedObject, Frame, Scope, Why } from "../../types";
 
 import type { PromiseAction } from "../utils/middleware/promise";
 
 export type PauseAction =
   | {|
       +type: "BREAK_ON_NEXT",
-      +cx: ThreadContext,
       +thread: string,
       +value: boolean
     |}
   | {|
-      // Note: Do not include cx, as this action is triggered by the server.
       +type: "RESUME",
       +thread: string,
       +value: void,
       +wasStepping: boolean
     |}
   | {|
-      // Note: Do not include cx, as this action is triggered by the server.
       +type: "PAUSED",
       +thread: string,
       +why: Why,
       +scopes: Scope,
       +frames: Frame[],
       +selectedFrameId: string,
       +loadedObjects: LoadedObject[]
     |}
   | {|
       +type: "PAUSE_ON_EXCEPTIONS",
       +shouldPauseOnExceptions: boolean,
       +shouldPauseOnCaughtExceptions: boolean
     |}
   | PromiseAction<{|
       +type: "COMMAND",
-      +cx: ThreadContext,
       +thread: string,
       +command: Command
     |}>
   | {|
       +type: "SELECT_FRAME",
-      +cx: ThreadContext,
       +thread: string,
       +frame: Frame
     |}
   | {|
       +type: "SELECT_COMPONENT",
       +thread: string,
       +componentIndex: number
     |}
   | {|
       +type: "SET_POPUP_OBJECT_PROPERTIES",
-      +cx: ThreadContext,
       +thread: string,
       +objectId: string,
       +properties: Object
     |}
   | {|
       +type: "ADD_EXPRESSION",
-      +cx: ThreadContext,
       +thread: string,
       +id: number,
       +input: string,
       +value: string,
       +expressionError: ?string
     |}
   | PromiseAction<
       {|
         +type: "EVALUATE_EXPRESSION",
-        +cx: ThreadContext,
         +thread: string,
         +input: string
       |},
       Object
     >
   | PromiseAction<{|
       +type: "EVALUATE_EXPRESSIONS",
-      +cx: ThreadContext,
       +results: Expression[],
       +inputs: string[]
     |}>
   | {|
       +type: "UPDATE_EXPRESSION",
-      +cx: ThreadContext,
       +expression: Expression,
       +input: string,
       +expressionError: ?string
     |}
   | {|
       +type: "DELETE_EXPRESSION",
       +input: string
     |}
   | {|
       +type: "CLEAR_AUTOCOMPLETE"
     |}
   | {|
       +type: "CLEAR_EXPRESSION_ERROR"
     |}
   | {|
       +type: "AUTOCOMPLETE",
-      +cx: ThreadContext,
       +input: string,
       +result: Object
     |}
   | PromiseAction<
       {|
         +type: "MAP_SCOPES",
-        +cx: ThreadContext,
         +thread: string,
         +frame: Frame
       |},
       {
         scope: Scope,
         mappings: {
           [string]: string | null
         }
       }
     >
   | {|
       +type: "MAP_FRAMES",
-      +cx: ThreadContext,
       +thread: string,
       +frames: Frame[],
       +selectedFrameId: string
     |}
   | PromiseAction<
       {|
         +type: "ADD_SCOPES",
-        +cx: ThreadContext,
         +thread: string,
         +frame: Frame
       |},
       Scope
     >
   | {|
       +type: "TOGGLE_SKIP_PAUSING",
       +thread: string,
--- a/devtools/client/debugger/new/src/actions/types/SourceAction.js
+++ b/devtools/client/debugger/new/src/actions/types/SourceAction.js
@@ -1,61 +1,54 @@
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at <http://mozilla.org/MPL/2.0/>. */
 
 // @flow
 
-import type { Source, SourceLocation, Context } from "../../types";
+import type { Source, SourceLocation } from "../../types";
 import type { PromiseAction } from "../utils/middleware/promise";
 
 export type LoadSourceAction = PromiseAction<
   {|
     +type: "LOAD_SOURCE_TEXT",
-    +cx: Context,
     +sourceId: string,
     +epoch: number
   |},
   Source
 >;
 export type SourceAction =
   | LoadSourceAction
   | {|
       +type: "ADD_SOURCE",
-      +cx: Context,
       +source: Source
     |}
   | {|
       +type: "ADD_SOURCES",
-      +cx: Context,
       +sources: Array<Source>
     |}
   | {|
       +type: "UPDATE_SOURCE",
-      +cx: Context,
       +source: Source
     |}
   | {|
       +type: "SET_SELECTED_LOCATION",
-      +cx: Context,
       +source: Source,
       +location?: SourceLocation
     |}
   | {|
       +type: "SET_PENDING_SELECTED_LOCATION",
-      +cx: Context,
       +url: string,
       +line?: number,
       +column?: number
     |}
-  | {| type: "CLEAR_SELECTED_LOCATION", +cx: Context |}
+  | {| type: "CLEAR_SELECTED_LOCATION" |}
   | PromiseAction<
       {|
         +type: "BLACKBOX",
-        +cx: Context,
         +source: Source
       |},
       {|
         +isBlackBoxed: boolean
       |}
     >
   | {|
       +type: "MOVE_TAB",
--- a/devtools/client/debugger/new/src/actions/types/UIAction.js
+++ b/devtools/client/debugger/new/src/actions/types/UIAction.js
@@ -1,20 +1,15 @@
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at <http://mozilla.org/MPL/2.0/>. */
 
 // @flow
 
-import type {
-  Source,
-  PartialRange,
-  SourceLocation,
-  Context
-} from "../../types";
+import type { Source, PartialRange, SourceLocation } from "../../types";
 
 import type {
   ActiveSearchType,
   OrientationType,
   SelectedPrimaryPaneTabType
 } from "../../reducers/ui";
 
 export type panelPositionType = "start" | "end";
@@ -64,17 +59,16 @@ export type UIAction =
       +location: SourceLocation,
       +log: boolean
     |}
   | {|
       +type: "CLOSE_CONDITIONAL_PANEL"
     |}
   | {|
       +type: "SET_PROJECT_DIRECTORY_ROOT",
-      +cx: Context,
       +url: string
     |}
   | {|
       +type: "SET_PRIMARY_PANE_TAB",
       +tabName: SelectedPrimaryPaneTabType
     |}
   | {|
       +type: "CLOSE_PROJECT_SEARCH"
--- a/devtools/client/debugger/new/src/actions/types/index.js
+++ b/devtools/client/debugger/new/src/actions/types/index.js
@@ -1,15 +1,15 @@
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at <http://mozilla.org/MPL/2.0/>. */
 
 // @flow
 
-import type { WorkerList, MainThread, Context } from "../../types";
+import type { WorkerList, MainThread } from "../../types";
 import type { State } from "../../reducers/types";
 import type { MatchedLocations } from "../../reducers/file-search";
 import type { TreeNode } from "../../utils/sources-tree/types";
 import type { SearchOperation } from "../../reducers/project-text-search";
 
 import type { BreakpointAction } from "./BreakpointAction";
 import type { SourceAction } from "./SourceAction";
 import type { UIAction } from "./UIAction";
@@ -70,76 +70,66 @@ type NavigateAction =
 
 export type FocusItem = {
   thread: string,
   item: TreeNode
 };
 
 export type SourceTreeAction =
   | {| +type: "SET_EXPANDED_STATE", +thread: string, +expanded: any |}
-  | {| +type: "SET_FOCUSED_SOURCE_ITEM", +cx: Context, item: FocusItem |};
+  | {| +type: "SET_FOCUSED_SOURCE_ITEM", item: FocusItem |};
 
 export type ProjectTextSearchAction =
-  | {| +type: "ADD_QUERY", +cx: Context, +query: string |}
+  | {| +type: "ADD_QUERY", +query: string |}
   | {|
       +type: "ADD_SEARCH_RESULT",
-      +cx: Context,
       +result: ProjectTextSearchResult
     |}
-  | {| +type: "UPDATE_STATUS", +cx: Context, +status: string |}
-  | {| +type: "CLEAR_SEARCH_RESULTS", +cx: Context |}
-  | {|
-      +type: "ADD_ONGOING_SEARCH",
-      +cx: Context,
-      +ongoingSearch: SearchOperation
-    |}
-  | {| +type: "CLEAR_SEARCH", +cx: Context |};
+  | {| +type: "UPDATE_STATUS", +status: string |}
+  | {| +type: "CLEAR_SEARCH_RESULTS" |}
+  | {| +type: "ADD_ONGOING_SEARCH", +ongoingSearch: SearchOperation |}
+  | {| +type: "CLEAR_SEARCH" |};
 
 export type FileTextSearchModifier =
   | "caseSensitive"
   | "wholeWord"
   | "regexMatch";
 
 export type FileTextSearchAction =
   | {|
       +type: "TOGGLE_FILE_SEARCH_MODIFIER",
-      +cx: Context,
       +modifier: FileTextSearchModifier
     |}
   | {|
       +type: "UPDATE_FILE_SEARCH_QUERY",
-      +cx: Context,
       +query: string
     |}
   | {|
       +type: "UPDATE_SEARCH_RESULTS",
-      +cx: Context,
       +results: {
         matches: MatchedLocations[],
         matchIndex: number,
         count: number,
         index: number
       }
     |};
 
 export type QuickOpenAction =
   | {| +type: "SET_QUICK_OPEN_QUERY", +query: string |}
   | {| +type: "OPEN_QUICK_OPEN", +query?: string |}
   | {| +type: "CLOSE_QUICK_OPEN" |};
 
-export type DebuggeeAction =
+export type DebugeeAction =
   | {|
       +type: "SET_WORKERS",
-      +cx: Context,
       +workers: WorkerList,
       +mainThread: string
     |}
   | {|
       +type: "SELECT_THREAD",
-      +cx: Context,
       +thread: string
     |};
 
 export type {
   StartPromiseAction,
   DonePromiseAction,
   ErrorPromiseAction
 } from "../utils/middleware/promise";
@@ -161,10 +151,10 @@ export type Action =
   | BreakpointAction
   | PauseAction
   | NavigateAction
   | UIAction
   | ASTAction
   | QuickOpenAction
   | FileTextSearchAction
   | ProjectTextSearchAction
-  | DebuggeeAction
+  | DebugeeAction
   | SourceTreeAction;
--- a/devtools/client/debugger/new/src/actions/ui.js
+++ b/devtools/client/debugger/new/src/actions/ui.js
@@ -12,17 +12,17 @@ import {
   getFileSearchQuery,
   getProjectDirectoryRoot
 } from "../selectors";
 import { selectSource } from "../actions/sources/select";
 import type { ThunkArgs, panelPositionType } from "./types";
 import { getEditor, getLocationsInViewport } from "../utils/editor";
 import { searchContents } from "./file-search";
 
-import type { SourceLocation, Context } from "../types";
+import type { SourceLocation } from "../types";
 import type {
   ActiveSearchType,
   OrientationType,
   SelectedPrimaryPaneTabType
 } from "../reducers/ui";
 
 export function setPrimaryPaneTab(tabName: SelectedPrimaryPaneTabType) {
   return { type: "SET_PRIMARY_PANE_TAB", tabName };
@@ -48,37 +48,37 @@ export function setActiveSearch(activeSe
 
     dispatch({
       type: "TOGGLE_ACTIVE_SEARCH",
       value: activeSearch
     });
   };
 }
 
-export function updateActiveFileSearch(cx: Context) {
+export function updateActiveFileSearch() {
   return ({ dispatch, getState }: ThunkArgs) => {
     const isFileSearchOpen = getActiveSearch(getState()) === "file";
     const fileSearchQuery = getFileSearchQuery(getState());
     if (isFileSearchOpen && fileSearchQuery) {
       const editor = getEditor();
-      dispatch(searchContents(cx, fileSearchQuery, editor));
+      dispatch(searchContents(fileSearchQuery, editor));
     }
   };
 }
 
 export function toggleFrameworkGrouping(toggleValue: boolean) {
   return ({ dispatch, getState }: ThunkArgs) => {
     dispatch({
       type: "TOGGLE_FRAMEWORK_GROUPING",
       value: toggleValue
     });
   };
 }
 
-export function showSource(cx: Context, sourceId: string) {
+export function showSource(sourceId: string) {
   return ({ dispatch, getState }: ThunkArgs) => {
     const source = getSource(getState(), sourceId);
     if (!source) {
       return;
     }
 
     if (getPaneCollapse(getState(), "start")) {
       dispatch({
@@ -86,17 +86,17 @@ export function showSource(cx: Context, 
         position: "start",
         paneCollapsed: false
       });
     }
 
     dispatch(setPrimaryPaneTab("sources"));
 
     dispatch({ type: "SHOW_SOURCE", source: null });
-    dispatch(selectSource(cx, source.id));
+    dispatch(selectSource(source.id));
     dispatch({ type: "SHOW_SOURCE", source });
   };
 }
 
 export function togglePaneCollapse(
   position: panelPositionType,
   paneCollapsed: boolean
 ) {
@@ -166,42 +166,40 @@ export function openConditionalPanel(
 }
 
 export function closeConditionalPanel() {
   return {
     type: "CLOSE_CONDITIONAL_PANEL"
   };
 }
 
-export function clearProjectDirectoryRoot(cx: Context) {
+export function clearProjectDirectoryRoot() {
   return {
     type: "SET_PROJECT_DIRECTORY_ROOT",
-    cx,
     url: ""
   };
 }
 
-export function setProjectDirectoryRoot(cx: Context, newRoot: string) {
+export function setProjectDirectoryRoot(newRoot: string) {
   return ({ dispatch, getState }: ThunkArgs) => {
     const curRoot = getProjectDirectoryRoot(getState());
     if (newRoot && curRoot) {
       const newRootArr = newRoot.replace(/\/+/g, "/").split("/");
       const curRootArr = curRoot
         .replace(/^\//, "")
         .replace(/\/+/g, "/")
         .split("/");
       if (newRootArr[0] !== curRootArr[0]) {
         newRootArr.splice(0, 2);
         newRoot = `${curRoot}/${newRootArr.join("/")}`;
       }
     }
 
     dispatch({
       type: "SET_PROJECT_DIRECTORY_ROOT",
-      cx,
       url: newRoot
     });
   };
 }
 
 export function updateViewport() {
   return {
     type: "SET_VIEWPORT",
--- a/devtools/client/debugger/new/src/actions/utils/create-store.js
+++ b/devtools/client/debugger/new/src/actions/utils/create-store.js
@@ -13,17 +13,16 @@
 
 import { createStore, applyMiddleware } from "redux";
 import { waitUntilService } from "./middleware/wait-service";
 import { log } from "./middleware/log";
 import { history } from "./middleware/history";
 import { promise } from "./middleware/promise";
 import { thunk } from "./middleware/thunk";
 import { timing } from "./middleware/timing";
-import { context } from "./middleware/context";
 
 /**
  * @memberof utils/create-store
  * @static
  */
 type ReduxStoreOptions = {
   makeThunkArgs?: Function,
   history?: Array<Object>,
@@ -43,17 +42,16 @@ type ReduxStoreOptions = {
  *                   used in tests.
  *        - middleware: array of middleware to be included in the redux store
  * @memberof utils/create-store
  * @static
  */
 const configureStore = (opts: ReduxStoreOptions = {}) => {
   const middleware = [
     thunk(opts.makeThunkArgs),
-    context,
     promise,
 
     // Order is important: services must go last as they always
     // operate on "already transformed" actions. Actions going through
     // them shouldn't have any special fields like promises, they
     // should just be normal JSON objects.
     waitUntilService
   ];
deleted file mode 100644
--- a/devtools/client/debugger/new/src/actions/utils/middleware/context.js
+++ /dev/null
@@ -1,37 +0,0 @@
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at <http://mozilla.org/MPL/2.0/>. */
-
-// @flow
-
-import {
-  validateNavigateContext,
-  validateContext
-} from "../../../utils/context";
-
-import type { ThunkArgs } from "../../types";
-
-function validateActionContext(getState, action) {
-  if (action.type == "COMMAND" && action.status == "done") {
-    // The thread will have resumed execution since the action was initiated,
-    // so just make sure we haven't navigated.
-    validateNavigateContext(getState(), action.cx);
-    return;
-  }
-
-  // Validate using all available information in the context.
-  validateContext(getState(), action.cx);
-}
-
-// Middleware which looks for actions that have a cx property and ignores
-// them if the context is no longer valid.
-function context({ dispatch, getState }: ThunkArgs) {
-  return (next: Function) => (action: Object) => {
-    if ("cx" in action) {
-      validateActionContext(getState, action);
-    }
-    return next(action);
-  };
-}
-
-export { context };
--- a/devtools/client/debugger/new/src/actions/utils/middleware/moz.build
+++ b/devtools/client/debugger/new/src/actions/utils/middleware/moz.build
@@ -3,16 +3,15 @@
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
 DIRS += [
 
 ]
 
 CompiledModules(
-    'context.js',
     'history.js',
     'log.js',
     'promise.js',
     'thunk.js',
     'timing.js',
     'wait-service.js',
 )
--- a/devtools/client/debugger/new/src/components/Editor/Breakpoint.js
+++ b/devtools/client/debugger/new/src/components/Editor/Breakpoint.js
@@ -12,27 +12,22 @@ import Svg from "../shared/Svg";
 import { getDocument, toEditorLine } from "../../utils/editor";
 import { getSelectedLocation } from "../../utils/source-maps";
 import { features } from "../../utils/prefs";
 import { showMenu } from "devtools-contextmenu";
 import { breakpointItems } from "./menus/breakpoints";
 import type { BreakpointItemActions } from "./menus/breakpoints";
 import type { EditorItemActions } from "./menus/editor";
 
-import type {
-  Source,
-  Breakpoint as BreakpointType,
-  ThreadContext
-} from "../../types";
+import type { Source, Breakpoint as BreakpointType } from "../../types";
 
 const breakpointSvg = document.createElement("div");
 ReactDOM.render(<Svg name="breakpoint" />, breakpointSvg);
 
 type Props = {
-  cx: ThreadContext,
   breakpoint: BreakpointType,
   selectedSource: Source,
   editor: Object,
   breakpointActions: BreakpointItemActions,
   editorActions: EditorItemActions
 };
 
 class Breakpoint extends PureComponent<Props> {
@@ -62,60 +57,57 @@ class Breakpoint extends PureComponent<P
     // NOTE: flow does not know about oncontextmenu
     (bp: any).oncontextmenu = this.onContextMenu;
 
     return bp;
   }
 
   onClick = (event: MouseEvent) => {
     const {
-      cx,
       breakpointActions,
       editorActions,
       breakpoint,
       selectedSource
     } = this.props;
 
     // ignore right clicks
     if ((event.ctrlKey && event.button === 0) || event.button === 2) {
       return;
     }
 
     event.stopPropagation();
     event.preventDefault();
 
     const selectedLocation = getSelectedLocation(breakpoint, selectedSource);
     if (event.metaKey) {
-      return editorActions.continueToHere(cx, selectedLocation.line);
+      return editorActions.continueToHere(selectedLocation.line);
     }
 
     if (event.shiftKey) {
       if (features.columnBreakpoints) {
         return breakpointActions.toggleBreakpointsAtLine(
-          cx,
           !breakpoint.disabled,
           selectedLocation.line
         );
       }
 
-      return breakpointActions.toggleDisabledBreakpoint(cx, breakpoint);
+      return breakpointActions.toggleDisabledBreakpoint(breakpoint);
     }
 
     return breakpointActions.removeBreakpointsAtLine(
-      cx,
       selectedLocation.sourceId,
       selectedLocation.line
     );
   };
 
   onContextMenu = (event: MouseEvent) => {
-    const { cx, breakpoint, breakpointActions } = this.props;
+    const { breakpoint, breakpointActions } = this.props;
     event.stopPropagation();
     event.preventDefault();
-    showMenu(event, breakpointItems(cx, breakpoint, breakpointActions));
+    showMenu(event, breakpointItems(breakpoint, breakpointActions));
   };
 
   addBreakpoint(props: Props) {
     const { breakpoint, editor, selectedSource } = props;
     const selectedLocation = getSelectedLocation(breakpoint, selectedSource);
 
     // Hidden Breakpoints are never rendered on the client
     if (breakpoint.options.hidden) {
--- a/devtools/client/debugger/new/src/components/Editor/Breakpoints.js
+++ b/devtools/client/debugger/new/src/components/Editor/Breakpoints.js
@@ -9,52 +9,45 @@ import Breakpoint from "./Breakpoint";
 import { getSelectedSource, getFirstVisibleBreakpoints } from "../../selectors";
 import { makeBreakpointId } from "../../utils/breakpoint";
 import { connect } from "../../utils/connect";
 import { breakpointItemActions } from "./menus/breakpoints";
 import { editorItemActions } from "./menus/editor";
 
 import type { BreakpointItemActions } from "./menus/breakpoints";
 import type { EditorItemActions } from "./menus/editor";
-import type {
-  Breakpoint as BreakpointType,
-  Source,
-  ThreadContext
-} from "../../types";
+import type { Breakpoint as BreakpointType, Source } from "../../types";
 
 type Props = {
-  cx: ThreadContext,
   selectedSource: Source,
   breakpoints: BreakpointType[],
   editor: Object,
   breakpointActions: BreakpointItemActions,
   editorActions: EditorItemActions
 };
 
 class Breakpoints extends Component<Props> {
   render() {
     const {
-      cx,
       breakpoints,
       selectedSource,
       editor,
       breakpointActions,
       editorActions
     } = this.props;
 
     if (!breakpoints || selectedSource.isBlackBoxed) {
       return null;
     }
 
     return (
       <div>
         {breakpoints.map(bp => {
           return (
             <Breakpoint
-              cx={cx}
               key={makeBreakpointId(bp.location)}
               breakpoint={bp}
               selectedSource={selectedSource}
               editor={editor}
               breakpointActions={breakpointActions}
               editorActions={editorActions}
             />
           );
--- a/devtools/client/debugger/new/src/components/Editor/ColumnBreakpoint.js
+++ b/devtools/client/debugger/new/src/components/Editor/ColumnBreakpoint.js
@@ -9,24 +9,23 @@ import classnames from "classnames";
 import { getDocument } from "../../utils/editor";
 import Svg from "../shared/Svg";
 import { showMenu } from "devtools-contextmenu";
 import { breakpointItems, createBreakpointItems } from "./menus/breakpoints";
 
 // eslint-disable-next-line max-len
 import type { ColumnBreakpoint as ColumnBreakpointType } from "../../selectors/visibleColumnBreakpoints";
 import type { BreakpointItemActions } from "./menus/breakpoints";
-import type { Source, Context } from "../../types";
+import type { Source } from "../../types";
 
 type Bookmark = {
   clear: Function
 };
 
 type Props = {
-  cx: Context,
   editor: Object,
   source: Source,
   columnBreakpoint: ColumnBreakpointType,
   breakpointActions: BreakpointItemActions
 };
 
 const breakpointImg = document.createElement("button");
 ReactDOM.render(<Svg name={"column-marker"} />, breakpointImg);
@@ -84,36 +83,35 @@ export default class ColumnBreakpoint ex
       this.bookmark.clear();
       this.bookmark = null;
     }
   };
 
   onClick = (event: MouseEvent) => {
     event.stopPropagation();
     event.preventDefault();
-    const { cx, columnBreakpoint, breakpointActions } = this.props;
+    const { columnBreakpoint, breakpointActions } = this.props;
     if (columnBreakpoint.breakpoint) {
-      breakpointActions.removeBreakpoint(cx, columnBreakpoint.breakpoint);
+      breakpointActions.removeBreakpoint(columnBreakpoint.breakpoint);
     } else {
-      breakpointActions.addBreakpoint(cx, columnBreakpoint.location);
+      breakpointActions.addBreakpoint(columnBreakpoint.location);
     }
   };
 
   onContextMenu = (event: MouseEvent) => {
     event.stopPropagation();
     event.preventDefault();
     const {
-      cx,
       columnBreakpoint: { breakpoint, location },
       breakpointActions
     } = this.props;
 
     const items = breakpoint
-      ? breakpointItems(cx, breakpoint, breakpointActions)
-      : createBreakpointItems(cx, location, breakpointActions);
+      ? breakpointItems(breakpoint, breakpointActions)
+      : createBreakpointItems(location, breakpointActions);
 
     showMenu(event, items);
   };
 
   componentDidMount() {
     this.addColumnBreakpoint();
   }
 
--- a/devtools/client/debugger/new/src/components/Editor/ColumnBreakpoints.js
+++ b/devtools/client/debugger/new/src/components/Editor/ColumnBreakpoints.js
@@ -3,74 +3,66 @@
  * file, You can obtain one at <http://mozilla.org/MPL/2.0/>. */
 
 // @flow
 
 import React, { Component } from "react";
 
 import ColumnBreakpoint from "./ColumnBreakpoint";
 
-import {
-  getSelectedSource,
-  visibleColumnBreakpoints,
-  getContext
-} from "../../selectors";
+import { getSelectedSource, visibleColumnBreakpoints } from "../../selectors";
 import { connect } from "../../utils/connect";
 import { makeBreakpointId } from "../../utils/breakpoint";
 import { breakpointItemActions } from "./menus/breakpoints";
 import type { BreakpointItemActions } from "./menus/breakpoints";
 
-import type { Source, Context } from "../../types";
+import type { Source } from "../../types";
 // eslint-disable-next-line max-len
 import type { ColumnBreakpoint as ColumnBreakpointType } from "../../selectors/visibleColumnBreakpoints";
 
 type Props = {
-  cx: Context,
   editor: Object,
   selectedSource: Source,
   columnBreakpoints: ColumnBreakpointType[],
   breakpointActions: BreakpointItemActions
 };
 
 class ColumnBreakpoints extends Component<Props> {
   props: Props;
 
   render() {
     const {
-      cx,
       editor,
       columnBreakpoints,
       selectedSource,
       breakpointActions
     } = this.props;
 
     if (!selectedSource || selectedSource.isBlackBoxed) {
       return null;
     }
 
     let breakpoints;
     editor.codeMirror.operation(() => {
       breakpoints = columnBreakpoints.map(breakpoint => (
         <ColumnBreakpoint
-          cx={cx}
           key={makeBreakpointId(breakpoint.location)}
           columnBreakpoint={breakpoint}
           editor={editor}
           source={selectedSource}
           breakpointActions={breakpointActions}
         />
       ));
     });
     return <div>{breakpoints}</div>;
   }
 }
 
 const mapStateToProps = state => {
   return {
-    cx: getContext(state),
     selectedSource: getSelectedSource(state),
     columnBreakpoints: visibleColumnBreakpoints(state)
   };
 };
 
 export default connect(
   mapStateToProps,
   dispatch => ({ breakpointActions: breakpointItemActions(dispatch) })
--- a/devtools/client/debugger/new/src/components/Editor/ConditionalPanel.js
+++ b/devtools/client/debugger/new/src/components/Editor/ConditionalPanel.js
@@ -9,26 +9,24 @@ import { connect } from "../../utils/con
 import classNames from "classnames";
 import "./ConditionalPanel.css";
 import { toEditorLine } from "../../utils/editor";
 import actions from "../../actions";
 
 import {
   getBreakpointForLocation,
   getConditionalPanelLocation,
-  getLogPointStatus,
-  getContext
+  getLogPointStatus
 } from "../../selectors";
 
-import type { SourceLocation, Context } from "../../types";
+import type { SourceLocation } from "../../types";
 
 type Props = {
-  cx: Context,
   breakpoint: ?Object,
-  setBreakpointOptions: typeof actions.setBreakpointOptions,
+  setBreakpointOptions: Function,
   location: SourceLocation,
   log: boolean,
   editor: Object,
   openConditionalPanel: typeof actions.openConditionalPanel,
   closeConditionalPanel: typeof actions.closeConditionalPanel
 };
 
 export class ConditionalPanel extends PureComponent<Props> {
@@ -60,20 +58,20 @@ export class ConditionalPanel extends Pu
     if (e.key === "Enter") {
       this.saveAndClose();
     } else if (e.key === "Escape") {
       this.props.closeConditionalPanel();
     }
   };
 
   setBreakpoint(value: string) {
-    const { cx, location, log, breakpoint } = this.props;
+    const { location, log, breakpoint } = this.props;
     const options = breakpoint ? breakpoint.options : {};
     const type = log ? "logValue" : "condition";
-    return this.props.setBreakpointOptions(cx, location, {
+    return this.props.setBreakpointOptions(location, {
       ...options,
       [type]: value
     });
   }
 
   clearConditionalPanel() {
     if (this.cbPanel) {
       this.cbPanel.clear();
@@ -196,17 +194,16 @@ export class ConditionalPanel extends Pu
     return null;
   }
 }
 
 const mapStateToProps = state => {
   const location = getConditionalPanelLocation(state);
   const log = getLogPointStatus(state);
   return {
-    cx: getContext(state),
     breakpoint: getBreakpointForLocation(state, location),
     location,
     log
   };
 };
 
 const {
   setBreakpointOptions,
--- a/devtools/client/debugger/new/src/components/Editor/EditorMenu.js
+++ b/devtools/client/debugger/new/src/components/Editor/EditorMenu.js
@@ -7,28 +7,26 @@
 import { Component } from "react";
 import { connect } from "../../utils/connect";
 import { showMenu } from "devtools-contextmenu";
 
 import { getSourceLocationFromMouseEvent } from "../../utils/editor";
 import {
   getPrettySource,
   getIsPaused,
-  getCurrentThread,
-  getThreadContext
+  getCurrentThread
 } from "../../selectors";
 
 import { editorMenuItems, editorItemActions } from "./menus/editor";
 
-import type { Source, ThreadContext } from "../../types";
+import type { Source } from "../../types";
 import type { EditorItemActions } from "./menus/editor";
 import type SourceEditor from "../../utils/editor/source-editor";
 
 type Props = {
-  cx: ThreadContext,
   contextMenu: ?MouseEvent,
   editorActions: EditorItemActions,
   clearContextMenu: () => void,
   editor: SourceEditor,
   hasPrettySource: boolean,
   isPaused: boolean,
   selectedSource: Source
 };
@@ -40,17 +38,16 @@ class EditorMenu extends Component<Props
     this.props.clearContextMenu();
     if (nextProps.contextMenu) {
       this.showMenu(nextProps);
     }
   }
 
   showMenu(props) {
     const {
-      cx,
       editor,
       selectedSource,
       editorActions,
       hasPrettySource,
       isPaused,
       contextMenu: event
     } = props;
 
@@ -59,17 +56,16 @@ class EditorMenu extends Component<Props
       selectedSource,
       // Use a coercion, as contextMenu is optional
       (event: any)
     );
 
     showMenu(
       event,
       editorMenuItems({
-        cx,
         editorActions,
         selectedSource,
         hasPrettySource,
         location,
         isPaused,
         selectionText: editor.codeMirror.getSelection().trim(),
         isTextSelected: editor.codeMirror.somethingSelected()
       })
@@ -77,17 +73,16 @@ class EditorMenu extends Component<Props
   }
 
   render() {
     return null;
   }
 }
 
 const mapStateToProps = (state, props) => ({
-  cx: getThreadContext(state),
   isPaused: getIsPaused(state, getCurrentThread(state)),
   hasPrettySource: !!getPrettySource(state, props.selectedSource.id)
 });
 
 const mapDispatchToProps = dispatch => ({
   editorActions: editorItemActions(dispatch)
 });
 
--- a/devtools/client/debugger/new/src/components/Editor/Footer.js
+++ b/devtools/client/debugger/new/src/components/Editor/Footer.js
@@ -5,45 +5,43 @@
 // @flow
 import React, { PureComponent } from "react";
 import { connect } from "../../utils/connect";
 import classnames from "classnames";
 import actions from "../../actions";
 import {
   getSelectedSource,
   getPrettySource,
-  getPaneCollapse,
-  getContext
+  getPaneCollapse
 } from "../../selectors";
 
 import {
   isPretty,
   isLoaded,
   getFilename,
   isOriginal,
   isLoading,
   shouldBlackbox
 } from "../../utils/source";
 import { getGeneratedSource } from "../../reducers/sources";
 import { shouldShowPrettyPrint } from "../../utils/editor";
 
 import { PaneToggleButton } from "../shared/Button";
 import AccessibleImage from "../shared/AccessibleImage";
 
-import type { Source, Context } from "../../types";
+import type { Source } from "../../types";
 
 import "./Footer.css";
 
 type CursorPosition = {
   line: number,
   column: number
 };
 
 type Props = {
-  cx: Context,
   selectedSource: Source,
   mappedSource: Source,
   endPanelCollapsed: boolean,
   horizontal: boolean,
   togglePrettyPrint: typeof actions.togglePrettyPrint,
   toggleBlackBox: typeof actions.toggleBlackBox,
   jumpToMappedLocation: typeof actions.jumpToMappedLocation,
   togglePaneCollapse: typeof actions.togglePaneCollapse
@@ -80,17 +78,17 @@ class SourceFooter extends PureComponent
     if (toggle === true) {
       eventDoc.CodeMirror.on("cursorActivity", this.onCursorChange);
     } else {
       eventDoc.CodeMirror.off("cursorActivity", this.onCursorChange);
     }
   }
 
   prettyPrintButton() {
-    const { cx, selectedSource, togglePrettyPrint } = this.props;
+    const { selectedSource, togglePrettyPrint } = this.props;
 
     if (!selectedSource) {
       return;
     }
 
     if (isLoading(selectedSource) && selectedSource.isPrettyPrinted) {
       return (
         <div className="loader" key="pretty-loader">
@@ -104,32 +102,32 @@ class SourceFooter extends PureComponent
     }
 
     const tooltip = L10N.getStr("sourceTabs.prettyPrint");
     const sourceLoaded = selectedSource && isLoaded(selectedSource);
 
     const type = "prettyPrint";
     return (
       <button
-        onClick={() => togglePrettyPrint(cx, selectedSource.id)}
+        onClick={() => togglePrettyPrint(selectedSource.id)}
         className={classnames("action", type, {
           active: sourceLoaded,
           pretty: isPretty(selectedSource)
         })}
         key={type}
         title={tooltip}
         aria-label={tooltip}
       >
         <AccessibleImage className={type} />
       </button>
     );
   }
 
   blackBoxButton() {
-    const { cx, selectedSource, toggleBlackBox } = this.props;
+    const { selectedSource, toggleBlackBox } = this.props;
     const sourceLoaded = selectedSource && isLoaded(selectedSource);
 
     if (!selectedSource) {
       return;
     }
 
     if (!shouldBlackbox(selectedSource)) {
       return;
@@ -140,17 +138,17 @@ class SourceFooter extends PureComponent
     const tooltip = blackboxed
       ? L10N.getStr("sourceFooter.unblackbox")
       : L10N.getStr("sourceFooter.blackbox");
 
     const type = "black-box";
 
     return (
       <button
-        onClick={() => toggleBlackBox(cx, selectedSource)}
+        onClick={() => toggleBlackBox(selectedSource)}
         className={classnames("action", type, {
           active: sourceLoaded,
           blackboxed: blackboxed
         })}
         key={type}
         title={tooltip}
         aria-label={tooltip}
       >
@@ -179,22 +177,17 @@ class SourceFooter extends PureComponent
     const commands = [this.blackBoxButton(), this.prettyPrintButton()].filter(
       Boolean
     );
 
     return commands.length ? <div className="commands">{commands}</div> : null;
   }
 
   renderSourceSummary() {
-    const {
-      cx,
-      mappedSource,
-      jumpToMappedLocation,
-      selectedSource
-    } = this.props;
+    const { mappedSource, jumpToMappedLocation, selectedSource } = this.props;
 
     if (!mappedSource || !isOriginal(selectedSource)) {
       return null;
     }
 
     const filename = getFilename(mappedSource);
     const tooltip = L10N.getFormatStr(
       "sourceFooter.mappedSourceTooltip",
@@ -204,17 +197,17 @@ class SourceFooter extends PureComponent
     const mappedSourceLocation = {
       sourceId: selectedSource.id,
       line: 1,
       column: 1
     };
     return (
       <button
         className="mapped-source"
-        onClick={() => jumpToMappedLocation(cx, mappedSourceLocation)}
+        onClick={() => jumpToMappedLocation(mappedSourceLocation)}
         title={tooltip}
       >
         <span>{title}</span>
       </button>
     );
   }
 
   onCursorChange = event => {
@@ -257,17 +250,16 @@ class SourceFooter extends PureComponent
     );
   }
 }
 
 const mapStateToProps = state => {
   const selectedSource = getSelectedSource(state);
 
   return {
-    cx: getContext(state),
     selectedSource,
     mappedSource: getGeneratedSource(state, selectedSource),
     prettySource: getPrettySource(
       state,
       selectedSource ? selectedSource.id : null
     ),
     endPanelCollapsed: getPaneCollapse(state, "end")
   };
--- a/devtools/client/debugger/new/src/components/Editor/Preview/Popup.js
+++ b/devtools/client/debugger/new/src/components/Editor/Preview/Popup.js
@@ -19,34 +19,31 @@ const { ObjectInspector, utils } = objec
 const {
   node: { createNode, getChildren, getValue, nodeIsPrimitive },
   loadProperties: { loadItemProperties }
 } = utils;
 
 import actions from "../../../actions";
 import {
   getAllPopupObjectProperties,
-  getCurrentThread,
-  getThreadContext
+  getCurrentThread
 } from "../../../selectors";
 import Popover from "../../shared/Popover";
 import PreviewFunction from "../../shared/PreviewFunction";
 
 import AccessibleImage from "../../shared/AccessibleImage";
 import { createObjectClient } from "../../../client/firefox";
 
 import "./Popup.css";
 
 import type { EditorRange } from "../../../utils/editor/types";
 import type { Coords } from "../../shared/Popover";
-import type { ThreadContext } from "../../../types";
 
 type PopupValue = Object | null;
 type Props = {
-  cx: ThreadContext,
   popupObjectProperties: Object,
   popoverPos: Object,
   value: PopupValue,
   expression: string,
   onClose: () => void,
   range: EditorRange,
   editor: any,
   editorRef: ?HTMLDivElement,
@@ -88,34 +85,33 @@ export class Popup extends Component<Pro
     super(props);
     this.state = {
       top: 0
     };
   }
 
   async componentWillMount() {
     const {
-      cx,
       value,
       setPopupObjectProperties,
       popupObjectProperties
     } = this.props;
 
     const root = this.getRoot();
 
     if (
       !nodeIsPrimitive(root) &&
       value &&
       value.actor &&
       !popupObjectProperties[value.actor]
     ) {
       const onLoadItemProperties = loadItemProperties(root, createObjectClient);
       if (onLoadItemProperties !== null) {
         const properties = await onLoadItemProperties;
-        setPopupObjectProperties(cx, root.contents.value, properties);
+        setPopupObjectProperties(root.contents.value, properties);
       }
     }
   }
 
   onMouseLeave = (e: SyntheticMouseEvent<HTMLDivElement>) => {
     const relatedTarget: Element = (e.relatedTarget: any);
 
     if (!relatedTarget) {
@@ -178,29 +174,27 @@ export class Popup extends Component<Pro
     const { editorRef } = this.props;
     if (!editorRef) {
       return "auto";
     }
     return editorRef.getBoundingClientRect().height - this.state.top;
   };
 
   renderFunctionPreview() {
-    const { cx, selectSourceURL, value } = this.props;
+    const { selectSourceURL, value } = this.props;
 
     if (!value) {
       return null;
     }
 
     const { location } = value;
     return (
       <div
         className="preview-popup"
-        onClick={() =>
-          selectSourceURL(cx, location.url, { line: location.line })
-        }
+        onClick={() => selectSourceURL(location.url, { line: location.line })}
       >
         <PreviewFunction func={value} />
       </div>
     );
   }
 
   renderReact(react: Object) {
     const reactHeader = react.displayName || "React Component";
@@ -322,17 +316,16 @@ export class Popup extends Component<Pro
       >
         {this.renderPreview()}
       </Popover>
     );
   }
 }
 
 const mapStateToProps = state => ({
-  cx: getThreadContext(state),
   popupObjectProperties: getAllPopupObjectProperties(
     state,
     getCurrentThread(state)
   )
 });
 
 const {
   addExpression,
--- a/devtools/client/debugger/new/src/components/Editor/Preview/index.js
+++ b/devtools/client/debugger/new/src/components/Editor/Preview/index.js
@@ -7,31 +7,32 @@
 import React, { PureComponent } from "react";
 import { connect } from "../../../utils/connect";
 
 import Popup from "./Popup";
 
 import {
   getPreview,
   getSelectedSource,
-  getThreadContext
+  getIsPaused,
+  getCurrentThread
 } from "../../../selectors";
 import actions from "../../../actions";
 import { toEditorRange } from "../../../utils/editor";
 
-import type { Source, ThreadContext } from "../../../types";
+import type { Source } from "../../../types";
 
 import type { Preview as PreviewType } from "../../../reducers/ast";
 
 type Props = {
-  cx: ThreadContext,
   editor: any,
   editorRef: ?HTMLDivElement,
   selectedSource: Source,
   preview: PreviewType,
+  isPaused: boolean,
   clearPreview: typeof actions.clearPreview,
   setPopupObjectProperties: typeof actions.setPopupObjectProperties,
   addExpression: typeof actions.addExpression,
   updatePreview: typeof actions.updatePreview
 };
 
 type State = {
   selecting: boolean
@@ -107,51 +108,50 @@ class Preview extends PureComponent<Prop
 
     if (prevProps.preview && !prevProps.preview.updating) {
       const target = getElementFromPos(prevProps.preview.cursorPos);
       target && target.classList.remove("preview-selection");
     }
   }
 
   onTokenEnter = ({ target, tokenPos }) => {
-    const { cx, updatePreview, editor } = this.props;
-    if (cx.isPaused) {
-      updatePreview(cx, target, tokenPos, editor.codeMirror);
+    if (this.props.isPaused) {
+      this.props.updatePreview(target, tokenPos, this.props.editor.codeMirror);
     }
   };
 
   onTokenLeave = e => {
-    if (this.props.cx.isPaused && !inPopup(e)) {
-      this.props.clearPreview(this.props.cx);
+    if (this.props.isPaused && !inPopup(e)) {
+      this.props.clearPreview();
     }
   };
 
   onMouseUp = () => {
-    if (this.props.cx.isPaused) {
+    if (this.props.isPaused) {
       this.setState({ selecting: false });
       return true;
     }
   };
 
   onMouseDown = () => {
-    if (this.props.cx.isPaused) {
+    if (this.props.isPaused) {
       this.setState({ selecting: true });
       return true;
     }
   };
 
   onScroll = () => {
-    if (this.props.cx.isPaused) {
-      this.props.clearPreview(this.props.cx);
+    if (this.props.isPaused) {
+      this.props.clearPreview();
     }
   };
 
   onClose = e => {
-    if (this.props.cx.isPaused) {
-      this.props.clearPreview(this.props.cx);
+    if (this.props.isPaused) {
+      this.props.clearPreview();
     }
   };
 
   render() {
     const { selectedSource, preview } = this.props;
     if (!this.props.editor || !selectedSource || this.state.selecting) {
       return null;
     }
@@ -178,18 +178,18 @@ class Preview extends PureComponent<Prop
         popoverPos={cursorPos}
         onClose={this.onClose}
       />
     );
   }
 }
 
 const mapStateToProps = state => ({
-  cx: getThreadContext(state),
   preview: getPreview(state),
+  isPaused: getIsPaused(state, getCurrentThread(state)),
   selectedSource: getSelectedSource(state)
 });
 
 export default connect(
   mapStateToProps,
   {
     clearPreview: actions.clearPreview,
     setPopupObjectProperties: actions.setPopupObjectProperties,
--- a/devtools/client/debugger/new/src/components/Editor/SearchBar.js
+++ b/devtools/client/debugger/new/src/components/Editor/SearchBar.js
@@ -12,26 +12,25 @@ import AccessibleImage from "../shared/A
 import actions from "../../actions";
 import {
   getActiveSearch,
   getSelectedSource,
   getSelectedLocation,
   getFileSearchQuery,
   getFileSearchModifiers,
   getFileSearchResults,
-  getHighlightedLineRange,
-  getContext
+  getHighlightedLineRange
 } from "../../selectors";
 
 import { removeOverlay } from "../../utils/editor";
 
 import { scrollList } from "../../utils/result-list";
 import classnames from "classnames";
 
-import type { Source, Context } from "../../types";
+import type { Source } from "../../types";
 import type { Modifiers, SearchResults } from "../../reducers/file-search";
 
 import SearchInput from "../shared/SearchInput";
 import { debounce } from "lodash";
 import "./SearchBar.css";
 
 import type SourceEditor from "../../utils/editor/source-editor";
 
@@ -51,17 +50,16 @@ type State = {
   query: string,
   selectedResultIndex: number,
   count: number,
   index: number,
   inputFocused: boolean
 };
 
 type Props = {
-  cx: Context,
   editor: SourceEditor,
   selectedSource?: Source,
   searchOn: boolean,
   searchResults: SearchResults,
   modifiers: Modifiers,
   query: string,
   showClose?: boolean,
   size?: string,
@@ -134,20 +132,20 @@ class SearchBar extends Component<Props,
     const { editor: ed, query } = this.props;
     if (ed) {
       const ctx = { ed, cm: ed.codeMirror };
       removeOverlay(ctx, query);
     }
   };
 
   closeSearch = (e: SyntheticEvent<HTMLElement>) => {
-    const { cx, closeFileSearch, editor, searchOn } = this.props;
+    const { closeFileSearch, editor, searchOn } = this.props;
     if (editor && searchOn) {
       this.clearSearch();
-      closeFileSearch(cx, editor);
+      closeFileSearch(editor);
       e.stopPropagation();
       e.preventDefault();
     }
     this.setState({ query: "", inputFocused: false });
   };
 
   toggleSearch = (e: SyntheticKeyboardEvent<HTMLElement>) => {
     e.stopPropagation();
@@ -166,33 +164,33 @@ class SearchBar extends Component<Props,
         this.doSearch(query);
       } else {
         this.setState({ query: "", inputFocused: true });
       }
     }
   };
 
   doSearch = (query: string) => {
-    const { cx, selectedSource } = this.props;
+    const { selectedSource } = this.props;
     if (!selectedSource || !selectedSource.text) {
       return;
     }
 
-    this.props.doSearch(cx, query, this.props.editor);
+    this.props.doSearch(query, this.props.editor);
   };
 
   traverseResults = (e: SyntheticEvent<HTMLElement>, rev: boolean) => {
     e.stopPropagation();
     e.preventDefault();
     const editor = this.props.editor;
 
     if (!editor) {
       return;
     }
-    this.props.traverseResults(this.props.cx, rev, editor);
+    this.props.traverseResults(rev, editor);
   };
 
   // Handlers
 
   onChange = (e: SyntheticInputEvent<HTMLElement>) => {
     this.setState({ query: e.target.value });
 
     return this.doSearch(e.target.value);
@@ -239,33 +237,33 @@ class SearchBar extends Component<Props,
     if (index == -1) {
       return L10N.getFormatStr("sourceSearch.resultsSummary1", count);
     }
 
     return L10N.getFormatStr("editor.searchResults", matchIndex + 1, count);
   }
 
   renderSearchModifiers = () => {
-    const { cx, modifiers, toggleFileSearchModifier, query } = this.props;
+    const { modifiers, toggleFileSearchModifier, query } = this.props;
     const { doSearch } = this;
 
     function SearchModBtn({ modVal, className, svgName, tooltip }) {
       const preppedClass = classnames(className, {
         active: modifiers && modifiers.get(modVal)
       });
       return (
         <button
           className={preppedClass}
           onMouseDown={() => {
-            toggleFileSearchModifier(cx, modVal);
+            toggleFileSearchModifier(modVal);
             doSearch(query);
           }}
           onKeyDown={(e: any) => {
             if (e.key === "Enter") {
-              toggleFileSearchModifier(cx, modVal);
+              toggleFileSearchModifier(modVal);
               doSearch(query);
             }
           }}
           title={tooltip}
         >
           <AccessibleImage className={svgName} />
         </button>
       );
@@ -354,17 +352,16 @@ class SearchBar extends Component<Props,
   }
 }
 
 SearchBar.contextTypes = {
   shortcuts: PropTypes.object
 };
 
 const mapStateToProps = state => ({
-  cx: getContext(state),
   searchOn: getActiveSearch(state) === "file",
   selectedSource: getSelectedSource(state),
   selectedLocation: getSelectedLocation(state),
   query: getFileSearchQuery(state),
   modifiers: getFileSearchModifiers(state),
   highlightedLineRange: getHighlightedLineRange(state),
   searchResults: getFileSearchResults(state)
 });
--- a/devtools/client/debugger/new/src/components/Editor/Tab.js
+++ b/devtools/client/debugger/new/src/components/Editor/Tab.js
@@ -8,17 +8,17 @@ import React, { PureComponent } from "re
 import { connect } from "../../utils/connect";
 
 import { showMenu, buildMenu } from "devtools-contextmenu";
 
 import SourceIcon from "../shared/SourceIcon";
 import { CloseButton } from "../shared/Button";
 
 import type { List } from "immutable";
-import type { Source, Context } from "../../types";
+import type { Source } from "../../types";
 
 import actions from "../../actions";
 
 import {
   getDisplayPath,
   getFileURL,
   getRawSourceURL,
   getSourceQueryString,
@@ -28,27 +28,25 @@ import {
 } from "../../utils/source";
 import { copyToTheClipboard } from "../../utils/clipboard";
 import { getTabMenuItems } from "../../utils/tabs";
 
 import {
   getSelectedSource,
   getActiveSearch,
   getSourcesForTabs,
-  getHasSiblingOfSameName,
-  getContext
+  getHasSiblingOfSameName
 } from "../../selectors";
 import type { ActiveSearchType } from "../../selectors";
 
 import classnames from "classnames";
 
 type SourcesList = List<Source>;
 
 type Props = {
-  cx: Context,
   tabSources: SourcesList,
   selectedSource: Source,
   source: Source,
   activeSearch: ActiveSearchType,
   hasSiblingOfSameName: boolean,
   selectSource: typeof actions.selectSource,
   closeTab: typeof actions.closeTab,
   closeTabs: typeof actions.closeTabs,
@@ -60,17 +58,16 @@ type Props = {
 class Tab extends PureComponent<Props> {
   onTabContextMenu = (event, tab: string) => {
     event.preventDefault();
     this.showContextMenu(event, tab);
   };
 
   showContextMenu(e, tab: string) {
     const {
-      cx,
       closeTab,
       closeTabs,
       tabSources,
       showSource,
       toggleBlackBox,
       togglePrettyPrint,
       selectedSource,
       source
@@ -86,43 +83,40 @@ class Tab extends PureComponent<Props> {
       return;
     }
 
     const tabMenuItems = getTabMenuItems();
     const items = [
       {
         item: {
           ...tabMenuItems.closeTab,
-          click: () => closeTab(cx, sourceTab)
+          click: () => closeTab(sourceTab)
         }
       },
       {
         item: {
           ...tabMenuItems.closeOtherTabs,
-          click: () => closeTabs(cx, otherTabURLs),
+          click: () => closeTabs(otherTabURLs),
           disabled: otherTabURLs.length === 0
         }
       },
       {
         item: {
           ...tabMenuItems.closeTabsToEnd,
           click: () => {
             const tabIndex = tabSources.findIndex(t => t.id == tab);
-            closeTabs(cx, tabURLs.filter((t, i) => i > tabIndex));
+            closeTabs(tabURLs.filter((t, i) => i > tabIndex));
           },
           disabled:
             tabCount === 1 ||
             tabSources.some((t, i) => t === tab && tabCount - 1 === i)
         }
       },
       {
-        item: {
-          ...tabMenuItems.closeAllTabs,
-          click: () => closeTabs(cx, tabURLs)
-        }
+        item: { ...tabMenuItems.closeAllTabs, click: () => closeTabs(tabURLs) }
       },
       { item: { type: "separator" } },
       {
         item: {
           ...tabMenuItems.copyToClipboard,
           disabled: selectedSource.id !== tab,
           click: () => copyToTheClipboard(sourceTab.text)
         }
@@ -133,33 +127,33 @@ class Tab extends PureComponent<Props> {
           disabled: !selectedSource.url,
           click: () => copyToTheClipboard(getRawSourceURL(sourceTab.url))
         }
       },
       {
         item: {
           ...tabMenuItems.showSource,
           disabled: !selectedSource.url,
-          click: () => showSource(cx, tab)
+          click: () => showSource(tab)
         }
       },
       {
         item: {
           ...tabMenuItems.toggleBlackBox,
           label: source.isBlackBoxed
             ? L10N.getStr("sourceFooter.unblackbox")
             : L10N.getStr("sourceFooter.blackbox"),
           disabled: !shouldBlackbox(source),
-          click: () => toggleBlackBox(cx, source)
+          click: () => toggleBlackBox(source)
         }
       },
       {
         item: {
           ...tabMenuItems.prettyPrint,
-          click: () => togglePrettyPrint(cx, tab),
+          click: () => togglePrettyPrint(tab),
           disabled: isPretty(sourceTab)
         }
       }
     ];
 
     showMenu(e, buildMenu(items));
   }
 
@@ -168,57 +162,56 @@ class Tab extends PureComponent<Props> {
   }
 
   isSourceSearchEnabled() {
     return this.props.activeSearch === "source";
   }
 
   render() {
     const {
-      cx,
       selectedSource,
       selectSource,
       closeTab,
       source,
       tabSources,
       hasSiblingOfSameName
     } = this.props;
     const sourceId = source.id;
     const active =
       selectedSource &&
       sourceId == selectedSource.id &&
       (!this.isProjectSearchEnabled() && !this.isSourceSearchEnabled());
     const isPrettyCode = isPretty(source);
 
     function onClickClose(e) {
       e.stopPropagation();
-      closeTab(cx, source);
+      closeTab(source);
     }
 
     function handleTabClick(e) {
       e.preventDefault();
       e.stopPropagation();
-      return selectSource(cx, sourceId);
+      return selectSource(sourceId);
     }
 
     const className = classnames("source-tab", {
       active,
       pretty: isPrettyCode
     });
 
     const path = getDisplayPath(source, tabSources);
     const query = hasSiblingOfSameName ? getSourceQueryString(source) : "";
 
     return (
       <div
         className={className}
         key={sourceId}
         onClick={handleTabClick}
         // Accommodate middle click to close tab
-        onMouseUp={e => e.button === 1 && closeTab(cx, source)}
+        onMouseUp={e => e.button === 1 && closeTab(source)}
         onContextMenu={e => this.onTabContextMenu(e, sourceId)}
         title={getFileURL(source, false)}
       >
         <SourceIcon
           source={source}
           shouldHide={icon => ["file", "javascript"].includes(icon)}
         />
         <div className="filename">
@@ -233,17 +226,16 @@ class Tab extends PureComponent<Props> {
     );
   }
 }
 
 const mapStateToProps = (state, { source }) => {
   const selectedSource = getSelectedSource(state);
 
   return {
-    cx: getContext(state),
     tabSources: getSourcesForTabs(state),
     selectedSource: selectedSource,
     activeSearch: getActiveSearch(state),
     hasSiblingOfSameName: getHasSiblingOfSameName(state, source)
   };
 };
 
 export default connect(
--- a/devtools/client/debugger/new/src/components/Editor/Tabs.js
+++ b/devtools/client/debugger/new/src/components/Editor/Tabs.js
@@ -6,40 +6,38 @@
 
 import React, { PureComponent } from "react";
 import { connect } from "../../utils/connect";
 
 import {
   getSelectedSource,
   getSourcesForTabs,
   getIsPaused,
-  getCurrentThread,
-  getContext
+  getCurrentThread
 } from "../../selectors";
 import { isVisible } from "../../utils/ui";
 
 import { getHiddenTabs } from "../../utils/tabs";
 import { getFilename, isPretty } from "../../utils/source";
 import actions from "../../actions";
 
 import { debounce } from "lodash";
 import "./Tabs.css";
 
 import Tab from "./Tab";
 import { PaneToggleButton } from "../shared/Button";
 import Dropdown from "../shared/Dropdown";
 import AccessibleImage from "../shared/AccessibleImage";
 import CommandBar from "../SecondaryPanes/CommandBar";
 
-import type { Source, Context } from "../../types";
+import type { Source } from "../../types";
 
 type SourcesList = Source[];
 
 type Props = {
-  cx: Context,
   tabSources: SourcesList,
   selectedSource: ?Source,
   horizontal: boolean,
   startPanelCollapsed: boolean,
   endPanelCollapsed: boolean,
   moveTab: typeof actions.moveTab,
   closeTab: typeof actions.closeTab,
   togglePaneCollapse: typeof actions.togglePaneCollapse,
@@ -133,20 +131,20 @@ class Tabs extends PureComponent<Props, 
     }
     if (source.isBlackBoxed) {
       return "blackBox";
     }
     return "file";
   }
 
   renderDropdownSource = (source: Source) => {
-    const { cx, selectSource } = this.props;
+    const { selectSource } = this.props;
     const filename = getFilename(source);
 
-    const onClick = () => selectSource(cx, source.id);
+    const onClick = () => selectSource(source.id);
     return (
       <li key={source.id} onClick={onClick}>
         <AccessibleImage
           className={`dropdown-icon ${this.getIconClass(source)}`}
         />
         <span className="dropdown-label">{filename}</span>
       </li>
     );
@@ -223,17 +221,16 @@ class Tabs extends PureComponent<Props, 
         {this.renderEndPanelToggleButton()}
         {this.renderCommandBar()}
       </div>
     );
   }
 }
 
 const mapStateToProps = state => ({
-  cx: getContext(state),
   selectedSource: getSelectedSource(state),
   tabSources: getSourcesForTabs(state),
   isPaused: getIsPaused(state, getCurrentThread(state))
 });
 
 export default connect(
   mapStateToProps,
   {
--- a/devtools/client/debugger/new/src/components/Editor/index.js
+++ b/devtools/client/debugger/new/src/components/Editor/index.js
@@ -30,18 +30,17 @@ import type { EditorItemActions } from "
 
 import {
   getActiveSearch,
   getSelectedLocation,
   getSelectedSource,
   getConditionalPanelLocation,
   getSymbols,
   getIsPaused,
-  getCurrentThread,
-  getThreadContext
+  getCurrentThread
 } from "../../selectors";
 
 // Redux actions
 import actions from "../../actions";
 
 import SearchBar from "./SearchBar";
 import HighlightLines from "./HighlightLines";
 import Preview from "./Preview";
@@ -76,24 +75,23 @@ import {
 import { resizeToggleButton, resizeBreakpointGutter } from "../../utils/ui";
 
 import "./Editor.css";
 import "./Breakpoints.css";
 import "./Highlight.css";
 
 import type SourceEditor from "../../utils/editor/source-editor";
 import type { SymbolDeclarations } from "../../workers/parser";
-import type { SourceLocation, Source, ThreadContext } from "../../types";
+import type { SourceLocation, Source } from "../../types";
 
 const cssVars = {
   searchbarHeight: "var(--editor-searchbar-height)"
 };
 
 export type Props = {
-  cx: ThreadContext,
   selectedLocation: ?SourceLocation,
   selectedSource: ?Source,
   searchOn: boolean,
   startPanelSize: number,
   endPanelSize: number,
   conditionalPanelLocation: SourceLocation,
   symbols: SymbolDeclarations,
   isPaused: boolean,
@@ -228,21 +226,21 @@ class Editor extends PureComponent<Props
     );
     shortcuts.on(L10N.getStr("sourceTabs.closeTab.key"), this.onClosePress);
     shortcuts.on("Esc", this.onEscape);
     shortcuts.on(searchAgainPrevKey, this.onSearchAgain);
     shortcuts.on(searchAgainKey, this.onSearchAgain);
   }
 
   onClosePress = (key, e: KeyboardEvent) => {
-    const { cx, selectedSource } = this.props;
+    const { selectedSource } = this.props;
     if (selectedSource) {
       e.preventDefault();
       e.stopPropagation();
-      this.props.closeTab(cx, selectedSource);
+      this.props.closeTab(selectedSource);
     }
   };
 
   componentWillUnmount() {
     if (this.state.editor) {
       this.state.editor.destroy();
       this.state.editor.codeMirror.off("scroll", this.onEditorScroll);
       this.setState({ editor: (null: any) });
@@ -296,17 +294,17 @@ class Editor extends PureComponent<Props
     e.preventDefault();
     e.stopPropagation();
 
     const line = this.getCurrentLine();
     if (typeof line !== "number") {
       return;
     }
 
-    this.props.toggleBreakpointAtLine(this.props.cx, line);
+    this.props.toggleBreakpointAtLine(line);
   };
 
   onToggleConditionalPanel = (key, e: KeyboardEvent) => {
     e.stopPropagation();
     e.preventDefault();
     const line = this.getCurrentLine();
 
     if (typeof line !== "number") {
@@ -350,25 +348,24 @@ class Editor extends PureComponent<Props
     const { codeMirror } = this.state.editor;
     if (codeMirror.listSelections().length > 1) {
       codeMirror.execCommand("singleSelection");
       e.preventDefault();
     }
   };
 
   onSearchAgain = (_, e: KeyboardEvent) => {
-    this.props.traverseResults(this.props.cx, e.shiftKey, this.state.editor);
+    this.props.traverseResults(e.shiftKey, this.state.editor);
   };
 
   openMenu(event: MouseEvent) {
     event.stopPropagation();
     event.preventDefault();
 
     const {
-      cx,
       selectedSource,
       breakpointActions,
       editorActions,
       isPaused
     } = this.props;
     const { editor } = this.state;
     if (!selectedSource || !editor) {
       return;
@@ -381,19 +378,19 @@ class Editor extends PureComponent<Props
     if (typeof line != "number") {
       return;
     }
 
     const location = { line, column: undefined, sourceId };
 
     if (target.classList.contains("CodeMirror-linenumber")) {
       return showMenu(event, [
-        ...createBreakpointItems(cx, location, breakpointActions),
+        ...createBreakpointItems(location, breakpointActions),
         { type: "separator" },
-        continueToHereItem(cx, location, isPaused, editorActions)
+        continueToHereItem(location, isPaused, editorActions)
       ]);
     }
 
     if (target.getAttribute("id") === "columnmarker") {
       return;
     }
 
     this.setState({ contextMenu: event });
@@ -405,17 +402,16 @@ class Editor extends PureComponent<Props
 
   onGutterClick = (
     cm: Object,
     line: number,
     gutter: string,
     ev: MouseEvent
   ) => {
     const {
-      cx,
       selectedSource,
       conditionalPanelLocation,
       closeConditionalPanel,
       addBreakpointAtLine,
       continueToHere
     } = this.props;
 
     // ignore right clicks in the gutter
@@ -437,36 +433,36 @@ class Editor extends PureComponent<Props
     }
 
     const sourceLine = toSourceLine(selectedSource.id, line);
     if (typeof sourceLine !== "number") {
       return;
     }
 
     if (ev.metaKey) {
-      return continueToHere(cx, sourceLine);
+      return continueToHere(sourceLine);
     }
 
-    return addBreakpointAtLine(cx, sourceLine);
+    return addBreakpointAtLine(sourceLine);
   };
 
   onGutterContextMenu = (event: MouseEvent) => {
     return this.openMenu(event);
   };
 
   onClick(e: MouseEvent) {
-    const { cx, selectedSource, jumpToMappedLocation } = this.props;
+    const { selectedSource, jumpToMappedLocation } = this.props;
 
     if (selectedSource && e.metaKey && e.altKey) {
       const sourceLocation = getSourceLocationFromMouseEvent(
         this.state.editor,
         selectedSource,
         e
       );
-      jumpToMappedLocation(cx, sourceLocation);
+      jumpToMappedLocation(sourceLocation);
     }
   }
 
   toggleConditionalPanel = (line, log: boolean = false) => {
     const {
       conditionalPanelLocation,
       closeConditionalPanel,
       openConditionalPanel,
@@ -596,29 +592,29 @@ class Editor extends PureComponent<Props
     }
 
     return {
       height: "100%"
     };
   }
 
   renderItems() {
-    const { cx, selectedSource, conditionalPanelLocation } = this.props;
+    const { selectedSource, conditionalPanelLocation } = this.props;
     const { editor, contextMenu } = this.state;
 
     if (!selectedSource || !editor || !getDocument(selectedSource.id)) {
       return null;
     }
 
     return (
       <div>
         <DebugLine editor={editor} />
         <HighlightLine />
         <EmptyLines editor={editor} />
-        <Breakpoints editor={editor} cx={cx} />
+        <Breakpoints editor={editor} />
         <Preview editor={editor} editorRef={this.$editorWrapper} />
         <HighlightLines editor={editor} />
         {
           <EditorMenu
             editor={editor}
             contextMenu={contextMenu}
             clearContextMenu={this.clearContextMenu}
             selectedSource={selectedSource}
@@ -665,17 +661,16 @@ class Editor extends PureComponent<Props
 Editor.contextTypes = {
   shortcuts: PropTypes.object
 };
 
 const mapStateToProps = state => {
   const selectedSource = getSelectedSource(state);
 
   return {
-    cx: getThreadContext(state),
     selectedLocation: getSelectedLocation(state),
     selectedSource,
     searchOn: getActiveSearch(state) === "file",
     conditionalPanelLocation: getConditionalPanelLocation(state),
     symbols: getSymbols(state, selectedSource),
     isPaused: getIsPaused(state, getCurrentThread(state))
   };
 };
--- a/devtools/client/debugger/new/src/components/Editor/menus/breakpoints.js
+++ b/devtools/client/debugger/new/src/components/Editor/menus/breakpoints.js
@@ -1,42 +1,40 @@
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at <http://mozilla.org/MPL/2.0/>. */
 
 // @flow
 
 import actions from "../../../actions";
 import { bindActionCreators } from "redux";
-import type { SourceLocation, Breakpoint, Context } from "../../../types";
+import type { SourceLocation, Breakpoint } from "../../../types";
 import { features } from "../../../utils/prefs";
 
 export const addBreakpointItem = (
-  cx: Context,
   location: SourceLocation,
   breakpointActions: BreakpointItemActions
 ) => ({
   id: "node-menu-add-breakpoint",
   label: L10N.getStr("editor.addBreakpoint"),
   accesskey: L10N.getStr("shortcuts.toggleBreakpoint.accesskey"),
   disabled: false,
-  click: () => breakpointActions.addBreakpoint(cx, location),
+  click: () => breakpointActions.addBreakpoint(location),
   accelerator: L10N.getStr("toggleBreakpoint.key")
 });
 
 export const removeBreakpointItem = (
-  cx: Context,
   breakpoint: Breakpoint,
   breakpointActions: BreakpointItemActions
 ) => ({
   id: "node-menu-remove-breakpoint",
   label: L10N.getStr("editor.removeBreakpoint"),
   accesskey: L10N.getStr("shortcuts.toggleBreakpoint.accesskey"),
   disabled: false,
-  click: () => breakpointActions.removeBreakpoint(cx, breakpoint),
+  click: () => breakpointActions.removeBreakpoint(breakpoint),
   accelerator: L10N.getStr("toggleBreakpoint.key")
 });
 
 export const addConditionalBreakpointItem = (
   location: SourceLocation,
   breakpointActions: BreakpointItemActions
 ) => ({
   id: "node-menu-add-conditional-breakpoint",
@@ -105,140 +103,114 @@ export const logPointItem = (
     location
   } = breakpoint;
   return logValue
     ? editLogPointItem(location, breakpointActions)
     : addLogPointItem(location, breakpointActions);
 };
 
 export const toggleDisabledBreakpointItem = (
-  cx: Context,
   breakpoint: Breakpoint,
   breakpointActions: BreakpointItemActions
 ) => {
   return {
     accesskey: L10N.getStr("editor.disableBreakpoint.accesskey"),
     disabled: false,
-    click: () => breakpointActions.toggleDisabledBreakpoint(cx, breakpoint),
+    click: () => breakpointActions.toggleDisabledBreakpoint(breakpoint),
     ...(breakpoint.disabled
       ? {
           id: "node-menu-enable-breakpoint",
           label: L10N.getStr("editor.enableBreakpoint")
         }
       : {
           id: "node-menu-disable-breakpoint",
           label: L10N.getStr("editor.disableBreakpoint")
         })
   };
 };
 
 export function breakpointItems(
-  cx: Context,
   breakpoint: Breakpoint,
   breakpointActions: BreakpointItemActions
 ) {
   const items = [
-    removeBreakpointItem(cx, breakpoint, breakpointActions),
-    toggleDisabledBreakpointItem(cx, breakpoint, breakpointActions)
+    removeBreakpointItem(breakpoint, breakpointActions),
+    toggleDisabledBreakpointItem(breakpoint, breakpointActions)
   ];
 
   if (features.columnBreakpoints) {
     items.push(
       { type: "separator" },
-      removeBreakpointsOnLineItem(cx, breakpoint.location, breakpointActions),
+      removeBreakpointsOnLineItem(breakpoint.location, breakpointActions),
       breakpoint.disabled
-        ? enableBreakpointsOnLineItem(
-            cx,
-            breakpoint.location,
-            breakpointActions
-          )
-        : disableBreakpointsOnLineItem(
-            cx,
-            breakpoint.location,
-            breakpointActions
-          ),
+        ? enableBreakpointsOnLineItem(breakpoint.location, breakpointActions)
+        : disableBreakpointsOnLineItem(breakpoint.location, breakpointActions),
       { type: "separator" }
     );
   }
 
   items.push(conditionalBreakpointItem(breakpoint, breakpointActions));
 
   if (features.logPoints) {
     items.push(logPointItem(breakpoint, breakpointActions));
   }
 
   return items;
 }
 
 export function createBreakpointItems(
-  cx: Context,
   location: SourceLocation,
   breakpointActions: BreakpointItemActions
 ) {
   const items = [
-    addBreakpointItem(cx, location, breakpointActions),
+    addBreakpointItem(location, breakpointActions),
     addConditionalBreakpointItem(location, breakpointActions)
   ];
 
   if (features.logPoints) {
     items.push(addLogPointItem(location, breakpointActions));
   }
   return items;
 }
 
 // ToDo: Only enable if there are more than one breakpoints on a line?
 export const removeBreakpointsOnLineItem = (
-  cx: Context,
   location: SourceLocation,
   breakpointActions: BreakpointItemActions
 ) => ({
   id: "node-menu-remove-breakpoints-on-line",
   label: L10N.getStr("breakpointMenuItem.removeAllAtLine.label"),
   accesskey: L10N.getStr("breakpointMenuItem.removeAllAtLine.accesskey"),
   disabled: false,
   click: () =>
-    breakpointActions.removeBreakpointsAtLine(
-      cx,
-      location.sourceId,
-      location.line
-    )
+    breakpointActions.removeBreakpointsAtLine(location.sourceId, location.line)
 });
 
 export const enableBreakpointsOnLineItem = (
-  cx: Context,
   location: SourceLocation,
   breakpointActions: BreakpointItemActions
 ) => ({
   id: "node-menu-remove-breakpoints-on-line",
   label: L10N.getStr("breakpointMenuItem.enableAllAtLine.label"),
   accesskey: L10N.getStr("breakpointMenuItem.enableAllAtLine.accesskey"),
   disabled: false,
   click: () =>
-    breakpointActions.enableBreakpointsAtLine(
-      cx,
-      location.sourceId,
-      location.line
-    )
+    breakpointActions.enableBreakpointsAtLine(location.sourceId, location.line)
 });
 
 export const disableBreakpointsOnLineItem = (
-  cx: Context,
   location: SourceLocation,
   breakpointActions: BreakpointItemActions
 ) => ({
   id: "node-menu-remove-breakpoints-on-line",
   label: L10N.getStr("breakpointMenuItem.disableAllAtLine.label"),
   accesskey: L10N.getStr("breakpointMenuItem.disableAllAtLine.accesskey"),
   disabled: false,
   click: () =>
-    breakpointActions.disableBreakpointsAtLine(
-      cx,
-      location.sourceId,
-      location.line
-    )
+    breakpointActions.disableBreakpointsAtLine(location.sourceId, location.line)
 });
 
 export type BreakpointItemActions = {
   addBreakpoint: typeof actions.addBreakpoint,
   removeBreakpoint: typeof actions.removeBreakpoint,
   removeBreakpointsAtLine: typeof actions.removeBreakpointsAtLine,
   enableBreakpointsAtLine: typeof actions.enableBreakpointsAtLine,
   disableBreakpointsAtLine: typeof actions.disableBreakpointsAtLine,
--- a/devtools/client/debugger/new/src/components/Editor/menus/editor.js
+++ b/devtools/client/debugger/new/src/components/Editor/menus/editor.js
@@ -14,36 +14,30 @@ import {
   getFilename,
   shouldBlackbox
 } from "../../../utils/source";
 
 import { downloadFile } from "../../../utils/utils";
 
 import actions from "../../../actions";
 
-import type {
-  Source,
-  SourceLocation,
-  Context,
-  ThreadContext
-} from "../../../types";
+import type { Source, SourceLocation } from "../../../types";
 
 function isMapped(selectedSource) {
   return isOriginalId(selectedSource.id) || !!selectedSource.sourceMapURL;
 }
 
 export const continueToHereItem = (
-  cx: ThreadContext,
   location: SourceLocation,
   isPaused: boolean,
   editorActions: EditorItemActions
 ) => ({
   accesskey: L10N.getStr("editor.continueToHere.accesskey"),
   disabled: !isPaused,
-  click: () => editorActions.continueToHere(cx, location.line, location.column),
+  click: () => editorActions.continueToHere(location.line, location.column),
   id: "node-menu-continue-to-here",
   label: L10N.getStr("editor.continueToHere.label")
 });
 
 // menu items
 
 const copyToClipboardItem = (
   selectedSource: Source,
@@ -86,71 +80,67 @@ const copySourceUri2Item = (
   id: "node-menu-copy-source-url",
   label: L10N.getStr("copySourceUri2"),
   accesskey: L10N.getStr("copySourceUri2.accesskey"),
   disabled: !selectedSource.url,
   click: () => copyToTheClipboard(getRawSourceURL(selectedSource.url))
 });
 
 const jumpToMappedLocationItem = (
-  cx: Context,
   selectedSource: Source,
   location: SourceLocation,
   hasPrettySource: boolean,
   editorActions: EditorItemActions
 ) => ({
   id: "node-menu-jump",
   label: L10N.getFormatStr(
     "editor.jumpToMappedLocation1",
     isOriginalId(selectedSource.id)
       ? L10N.getStr("generated")
       : L10N.getStr("original")
   ),
   accesskey: L10N.getStr("editor.jumpToMappedLocation1.accesskey"),
   disabled:
     (!isMapped(selectedSource) && !isPretty(selectedSource)) || hasPrettySource,
-  click: () => editorActions.jumpToMappedLocation(cx, location)
+  click: () => editorActions.jumpToMappedLocation(location)
 });
 
 const showSourceMenuItem = (
-  cx: Context,
   selectedSource: Source,
   editorActions: EditorItemActions
 ) => ({
   id: "node-menu-show-source",
   label: L10N.getStr("sourceTabs.revealInTree"),
   accesskey: L10N.getStr("sourceTabs.revealInTree.accesskey"),
   disabled: !selectedSource.url,
-  click: () => editorActions.showSource(cx, selectedSource.id)
+  click: () => editorActions.showSource(selectedSource.id)
 });
 
 const blackBoxMenuItem = (
-  cx: Context,
   selectedSource: Source,
   editorActions: EditorItemActions
 ) => ({
   id: "node-menu-blackbox",
   label: selectedSource.isBlackBoxed
     ? L10N.getStr("sourceFooter.unblackbox")
     : L10N.getStr("sourceFooter.blackbox"),
   accesskey: L10N.getStr("sourceFooter.blackbox.accesskey"),
   disabled: !shouldBlackbox(selectedSource),
-  click: () => editorActions.toggleBlackBox(cx, selectedSource)
+  click: () => editorActions.toggleBlackBox(selectedSource)
 });
 
 const watchExpressionItem = (
-  cx: ThreadContext,
   selectedSource: Source,
   selectionText: string,
   editorActions: EditorItemActions
 ) => ({
   id: "node-menu-add-watch-expression",
   label: L10N.getStr("expressions.label"),
   accesskey: L10N.getStr("expressions.accesskey"),
-  click: () => editorActions.addExpression(cx, selectionText)
+  click: () => editorActions.addExpression(selectionText)
 });
 
 const evaluateInConsoleItem = (
   selectedSource: Source,
   selectionText: string,
   editorActions: EditorItemActions
 ) => ({
   id: "node-menu-evaluate-in-console",
@@ -166,59 +156,56 @@ const downloadFileItem = (
     id: "node-menu-download-file",
     label: L10N.getStr("downloadFile.label"),
     accesskey: L10N.getStr("downloadFile.accesskey"),
     click: () => downloadFile(selectedSource, getFilename(selectedSource))
   };
 };
 
 export function editorMenuItems({
-  cx,
   editorActions,
   selectedSource,
   location,
   selectionText,
   hasPrettySource,
   isTextSelected,
   isPaused
 }: {
-  cx: ThreadContext,
   editorActions: EditorItemActions,
   selectedSource: Source,
   location: SourceLocation,
   selectionText: string,
   hasPrettySource: boolean,
   isTextSelected: boolean,
   isPaused: boolean
 }) {
   const items = [];
 
   items.push(
     jumpToMappedLocationItem(
-      cx,
       selectedSource,
       location,
       hasPrettySource,
       editorActions
     ),
-    continueToHereItem(cx, location, isPaused, editorActions),
+    continueToHereItem(location, isPaused, editorActions),
     { type: "separator" },
     copyToClipboardItem(selectedSource, editorActions),
     copySourceItem(selectedSource, selectionText, editorActions),
     copySourceUri2Item(selectedSource, editorActions),
     downloadFileItem(selectedSource, editorActions),
     { type: "separator" },
-    showSourceMenuItem(cx, selectedSource, editorActions),
-    blackBoxMenuItem(cx, selectedSource, editorActions)
+    showSourceMenuItem(selectedSource, editorActions),
+    blackBoxMenuItem(selectedSource, editorActions)
   );
 
   if (isTextSelected) {
     items.push(
       { type: "separator" },
-      watchExpressionItem(cx, selectedSource, selectionText, editorActions),
+      watchExpressionItem(selectedSource, selectionText, editorActions),
       evaluateInConsoleItem(selectedSource, selectionText, editorActions)
     );
   }
 
   return items;
 }
 
 export type EditorItemActions = {
--- a/devtools/client/debugger/new/src/components/Editor/tests/SearchBar.spec.js
+++ b/devtools/client/debugger/new/src/components/Editor/tests/SearchBar.spec.js
@@ -62,17 +62,17 @@ describe("SearchBar", () => {
 
 describe("doSearch", () => {
   it("should complete a search", async () => {
     const { component, props } = render();
     component
       .find("SearchInput")
       .simulate("change", { target: { value: "query" } });
 
-    const doSearchArgs = props.doSearch.mock.calls[0][1];
+    const doSearchArgs = props.doSearch.mock.calls[0][0];
     expect(doSearchArgs).toMatchSnapshot();
   });
 });
 
 describe("showErrorEmoji", () => {
   it("true if query + no results", () => {
     const { component } = render({
       query: "test",
--- a/devtools/client/debugger/new/src/components/PrimaryPanes/Outline.js
+++ b/devtools/client/debugger/new/src/components/PrimaryPanes/Outline.js
@@ -11,35 +11,33 @@ import { score as fuzzaldrinScore } from
 
 import { copyToTheClipboard } from "../../utils/clipboard";
 import { findFunctionText } from "../../utils/function";
 
 import actions from "../../actions";
 import {
   getSelectedSource,
   getSymbols,
-  getSelectedLocation,
-  getContext
+  getSelectedLocation
 } from "../../selectors";
 
 import OutlineFilter from "./OutlineFilter";
 import "./Outline.css";
 import PreviewFunction from "../shared/PreviewFunction";
 import { uniq, sortBy } from "lodash";
 
 import type {
   AstLocation,
   SymbolDeclarations,
   SymbolDeclaration,
   FunctionDeclaration
 } from "../../workers/parser";
-import type { Source, Context } from "../../types";
+import type { Source } from "../../types";
 
 type Props = {
-  cx: Context,
   symbols: SymbolDeclarations,
   selectedSource: ?Source,
   alphabetizeOutline: boolean,
   onAlphabetizeClick: Function,
   selectedLocation: any,
   getFunctionText: Function,
   selectLocation: typeof actions.selectLocation,
   flashLineRange: typeof actions.flashLineRange
@@ -69,22 +67,22 @@ const filterOutlineItem = (name: string,
 export class Outline extends Component<Props, State> {
   constructor(props: Props) {
     super(props);
     (this: any).updateFilter = this.updateFilter.bind(this);
     this.state = { filter: "" };
   }
 
   selectItem(location: AstLocation) {
-    const { cx, selectedSource, selectLocation } = this.props;
+    const { selectedSource, selectLocation } = this.props;
     if (!selectedSource) {
       return;
     }
 
-    selectLocation(cx, {
+    selectLocation({
       sourceId: selectedSource.id,
       line: location.start.line,
       column: location.start.column
     });
   }
 
   onContextMenu(event: SyntheticEvent<HTMLElement>, func: SymbolDeclaration) {
     event.stopPropagation();
@@ -261,17 +259,16 @@ export class Outline extends Component<P
   }
 }
 
 const mapStateToProps = state => {
   const selectedSource = getSelectedSource(state);
   const symbols = selectedSource ? getSymbols(state, selectedSource) : null;
 
   return {
-    cx: getContext(state),
     symbols,
     selectedSource,
     selectedLocation: getSelectedLocation(state),
     getFunctionText: line => {
       if (selectedSource) {
         return findFunctionText(line, selectedSource, symbols);
       }
 
--- a/devtools/client/debugger/new/src/components/PrimaryPanes/SourcesTree.js
+++ b/devtools/client/debugger/new/src/components/PrimaryPanes/SourcesTree.js
@@ -14,18 +14,17 @@ import {
   getShownSource,
   getSelectedSource,
   getDebuggeeUrl,
   getExpandedState,
   getProjectDirectoryRoot,
   getDisplayedSourcesForThread,
   getFocusedSourceItem,
   getWorkerByThread,
-  getWorkerCount,
-  getContext
+  getWorkerCount
 } from "../../selectors";
 
 import { getGeneratedSourceByURL } from "../../reducers/sources";
 
 // Actions
 import actions from "../../actions";
 
 // Components
@@ -47,22 +46,21 @@ import { getRawSourceURL } from "../../u
 import { getDisplayName } from "../../utils/workers";
 import { features } from "../../utils/prefs";
 
 import type {
   TreeNode,
   TreeDirectory,
   ParentMap
 } from "../../utils/sources-tree/types";
-import type { Worker, Source, Context } from "../../types";
+import type { Worker, Source } from "../../types";
 import type { SourcesMap, State as AppState } from "../../reducers/types";
 import type { Item } from "../shared/ManagedTree";
 
 type Props = {
-  cx: Context,
   thread: string,
   worker: Worker,
   sources: SourcesMap,
   sourceCount: number,
   shownSource?: Source,
   selectedSource?: Source,
   debuggeeUrl: string,
   projectRoot: string,
@@ -153,22 +151,22 @@ class SourcesTree extends Component<Prop
           sourceTree
         })
       );
     }
   }
 
   selectItem = (item: TreeNode) => {
     if (item.type == "source" && !Array.isArray(item.contents)) {
-      this.props.selectSource(this.props.cx, item.contents.id);
+      this.props.selectSource(item.contents.id);
     }
   };
 
   onFocus = (item: TreeNode) => {
-    this.props.focusItem(this.props.cx, { thread: this.props.thread, item });
+    this.props.focusItem({ thread: this.props.thread, item });
   };
 
   onActivate = (item: TreeNode) => {
     this.selectItem(item);
   };
 
   // NOTE: we get the source from sources because item.contents is cached
   getSource(item: TreeNode): ?Source {
@@ -368,17 +366,16 @@ function getSourceForTree(
 const mapStateToProps = (state, props) => {
   const selectedSource = getSelectedSource(state);
   const shownSource = getShownSource(state);
   const focused = getFocusedSourceItem(state);
   const thread = props.thread;
   const displayedSources = getDisplayedSourcesForThread(state, thread);
 
   return {
-    cx: getContext(state),
     shownSource: getSourceForTree(state, displayedSources, shownSource, thread),
     selectedSource: getSourceForTree(
       state,
       displayedSources,
       selectedSource,
       thread
     ),
     debuggeeUrl: getDebuggeeUrl(state),
--- a/devtools/client/debugger/new/src/components/PrimaryPanes/SourcesTreeItem.js
+++ b/devtools/client/debugger/new/src/components/PrimaryPanes/SourcesTreeItem.js
@@ -10,36 +10,34 @@ import classnames from "classnames";
 import { showMenu } from "devtools-contextmenu";
 
 import SourceIcon from "../shared/SourceIcon";
 import AccessibleImage from "../shared/AccessibleImage";
 
 import {
   getGeneratedSourceByURL,
   getHasSiblingOfSameName,
-  hasPrettySource as checkHasPrettySource,
-  getContext
+  hasPrettySource as checkHasPrettySource
 } from "../../selectors";
 import actions from "../../actions";
 
 import {
   isOriginal as isOriginalSource,
   getSourceQueryString,
   isUrlExtension,
   shouldBlackbox
 } from "../../utils/source";
 import { isDirectory } from "../../utils/sources-tree";
 import { copyToTheClipboard } from "../../utils/clipboard";
 import { features } from "../../utils/prefs";
 
 import type { TreeNode } from "../../utils/sources-tree/types";
-import type { Source, Context } from "../../types";
+import type { Source } from "../../types";
 
 type Props = {
-  cx: Context,
   debuggeeUrl: string,
   projectRoot: string,
   source: ?Source,
   item: TreeNode,
   depth: number,
   focused: boolean,
   expanded: boolean,
   hasMatchingGeneratedSource: boolean,
@@ -131,53 +129,53 @@ class SourceTreeItem extends Component<P
         const copySourceUri2 = {
           id: "node-menu-copy-source",
           label: copySourceUri2Label,
           accesskey: copySourceUri2Key,
           disabled: false,
           click: () => copyToTheClipboard(contents.url)
         };
 
-        const { cx, source } = this.props;
+        const { source } = this.props;
         if (source) {
           const blackBoxMenuItem = {
             id: "node-menu-blackbox",
             label: source.isBlackBoxed
               ? L10N.getStr("sourceFooter.unblackbox")
               : L10N.getStr("sourceFooter.blackbox"),
             accesskey: L10N.getStr("sourceFooter.blackbox.accesskey"),
             disabled: !shouldBlackbox(source),
-            click: () => this.props.toggleBlackBox(cx, source)
+            click: () => this.props.toggleBlackBox(source)
           };
           menuOptions.push(copySourceUri2, blackBoxMenuItem);
         }
       }
     }
 
     if (isDirectory(item)) {
       this.addCollapseExpandAllOptions(menuOptions, item);
 
       if (features.root) {
         const { path } = item;
-        const { cx, projectRoot } = this.props;
+        const { projectRoot } = this.props;
 
         if (projectRoot.endsWith(path)) {
           menuOptions.push({
             id: "node-remove-directory-root",
             label: removeDirectoryRootLabel,
             disabled: false,
-            click: () => this.props.clearProjectDirectoryRoot(cx)
+            click: () => this.props.clearProjectDirectoryRoot()
           });
         } else {
           menuOptions.push({
             id: "node-set-directory-root",
             label: setDirectoryRootLabel,
             accesskey: setDirectoryRootKey,
             disabled: false,
-            click: () => this.props.setProjectDirectoryRoot(cx, path)
+            click: () => this.props.setProjectDirectoryRoot(path)
           });
         }
       }
     }
 
     showMenu(event, menuOptions);
   };
 
@@ -270,17 +268,16 @@ function getHasMatchingGeneratedSource(s
   }
 
   return !!getGeneratedSourceByURL(state, source.url);
 }
 
 const mapStateToProps = (state, props) => {
   const { source } = props;
   return {
-    cx: getContext(state),
     hasMatchingGeneratedSource: getHasMatchingGeneratedSource(state, source),
     hasSiblingOfSameName: getHasSiblingOfSameName(state, source),
     hasPrettySource: source ? checkHasPrettySource(state, source.id) : false
   };
 };
 
 export default connect(
   mapStateToProps,
--- a/devtools/client/debugger/new/src/components/PrimaryPanes/index.js
+++ b/devtools/client/debugger/new/src/components/PrimaryPanes/index.js
@@ -9,39 +9,37 @@ import classnames from "classnames";
 import { Tab, Tabs, TabList, TabPanels } from "react-aria-components/src/tabs";
 
 import actions from "../../actions";
 import {
   getDisplayedSources,
   getActiveSearch,
   getProjectDirectoryRoot,
   getSelectedPrimaryPaneTab,
-  getThreads,
-  getContext
+  getThreads
 } from "../../selectors";
 import { features, prefs } from "../../utils/prefs";
 import { connect } from "../../utils/connect";
 import { formatKeyShortcut } from "../../utils/text";
 
 import Outline from "./Outline";
 import SourcesTree from "./SourcesTree";
 import AccessibleImage from "../shared/AccessibleImage";
 
 import type { SourcesMapByThread } from "../../reducers/types";
 import type { SelectedPrimaryPaneTabType } from "../../selectors";
-import type { Thread, Context } from "../../types";
+import type { Thread } from "../../types";
 
 import "./Sources.css";
 
 type State = {
   alphabetizeOutline: boolean
 };
 
 type Props = {
-  cx: Context,
   selectedTab: SelectedPrimaryPaneTabType,
   sources: SourcesMapByThread,
   horizontal: boolean,
   projectRoot: string,
   sourceSearchOn: boolean,
   setPrimaryPaneTab: typeof actions.setPrimaryPaneTab,
   setActiveSearch: typeof actions.setActiveSearch,
   closeActiveSearch: typeof actions.closeActiveSearch,
@@ -98,29 +96,29 @@ class PrimaryPanes extends Component<Pro
         key="outline-tab"
       >
         {outline}
       </Tab>
     ];
   }
 
   renderProjectRootHeader() {
-    const { cx, projectRoot } = this.props;
+    const { projectRoot } = this.props;
 
     if (!projectRoot) {
       return null;
     }
 
     const rootLabel = projectRoot.split("/").pop();
 
     return (
       <div key="root" className="sources-clear-root-container">
         <button
           className="sources-clear-root"
-          onClick={() => this.props.clearProjectDirectoryRoot(cx)}
+          onClick={() => this.props.clearProjectDirectoryRoot()}
           title={L10N.getStr("removeDirectoryRoot.label")}
         >
           <AccessibleImage className="home" />
           <AccessibleImage className="breadcrumb" />
           <span className="sources-clear-root-label">{rootLabel}</span>
         </button>
       </div>
     );
@@ -161,17 +159,16 @@ class PrimaryPanes extends Component<Pro
           />
         </TabPanels>
       </Tabs>
     );
   }
 }
 
 const mapStateToProps = state => ({
-  cx: getContext(state),
   selectedTab: getSelectedPrimaryPaneTab(state),
   sources: getDisplayedSources(state),
   sourceSearchOn: getActiveSearch(state) === "source",
   threads: getThreads(state),
   projectRoot: getProjectDirectoryRoot(state)
 });
 
 const connector = connect(
--- a/devtools/client/debugger/new/src/components/PrimaryPanes/tests/SourcesTree.spec.js
+++ b/devtools/client/debugger/new/src/components/PrimaryPanes/tests/SourcesTree.spec.js
@@ -4,17 +4,17 @@
 
 // @flow
 
 import React from "react";
 import { shallow } from "enzyme";
 import { showMenu } from "devtools-contextmenu";
 
 import SourcesTree from "../SourcesTree";
-import { makeMockSource, mockcx } from "../../../utils/test-mockup";
+import { makeMockSource } from "../../../utils/test-mockup";
 import { copyToTheClipboard } from "../../../utils/clipboard";
 
 jest.mock("devtools-contextmenu", () => ({ showMenu: jest.fn() }));
 jest.mock("../../../utils/clipboard", () => ({
   copyToTheClipboard: jest.fn()
 }));
 
 describe("SourcesTree", () => {
@@ -189,28 +189,26 @@ describe("SourcesTree", () => {
     it("select activated item", async () => {
       const { instance, props } = render();
       const item = createMockItem();
       const spy = jest.spyOn(instance, "selectItem");
 
       instance.onActivate(item);
       expect(spy).toHaveBeenCalledWith(item);
       expect(props.selectSource).toHaveBeenCalledWith(
-        mockcx,
         "server1.conn13.child1/39"
       );
     });
   });
 
   describe("selectItem", () => {
     it("should select item with no children", async () => {
       const { instance, props } = render();
       instance.selectItem(createMockItem());
       expect(props.selectSource).toHaveBeenCalledWith(
-        mockcx,
         "server1.conn13.child1/39"
       );
     });
 
     it("should not select item with children", async () => {
       const { props, instance } = render();
       instance.selectItem(createMockDirectory());
       expect(props.selectSource).not.toHaveBeenCalled();
@@ -354,17 +352,16 @@ function generateDefaults(overrides: Obj
     "server1.conn13.child1/42": createMockSource(
       "server1.conn13.child1/42",
       "http://mdn.com/four.js",
       false,
       "data:application/json?charset=utf?dsffewrsf"
     )
   };
   return {
-    cx: mockcx,
     thread: "FakeThread",
     autoExpandAll: true,
     selectSource: jest.fn(),
     setExpandedState: jest.fn(),
     sources: defaultSources,
     debuggeeUrl: "http://mdn.com",
     clearProjectDirectoryRoot: jest.fn(),
     setProjectDirectoryRoot: jest.fn(),
--- a/devtools/client/debugger/new/src/components/ProjectSearch.js
+++ b/devtools/client/debugger/new/src/components/ProjectSearch.js
@@ -14,28 +14,26 @@ import { getEditor } from "../utils/edit
 import { highlightMatches } from "../utils/project-search";
 
 import { statusType } from "../reducers/project-text-search";
 import { getRelativePath } from "../utils/sources-tree";
 import {
   getActiveSearch,
   getTextSearchResults,
   getTextSearchStatus,
-  getTextSearchQuery,
-  getContext
+  getTextSearchQuery
 } from "../selectors";
 
 import ManagedTree from "./shared/ManagedTree";
 import SearchInput from "./shared/SearchInput";
 import AccessibleImage from "./shared/AccessibleImage";
 
 import type { List } from "immutable";
 import type { ActiveSearchType } from "../reducers/types";
 import type { StatusType } from "../reducers/project-text-search";
-import type { Context } from "../types";
 
 import "./ProjectSearch.css";
 
 export type Match = {
   type: "MATCH",
   sourceId: string,
   line: number,
   column: number,
@@ -56,17 +54,16 @@ type Item = Result | Match;
 
 type State = {
   inputValue: string,
   inputFocused: boolean,
   focusedItem: ?Item
 };
 
 type Props = {
-  cx: Context,
   query: string,
   results: List<Result>,
   status: StatusType,
   activeSearch: ActiveSearchType,
   closeProjectSearch: typeof actions.closeProjectSearch,
   searchSources: typeof actions.searchSources,
   clearSearch: typeof actions.clearSearch,
   selectSpecificLocation: typeof actions.selectSpecificLocation,
@@ -117,36 +114,36 @@ export class ProjectSearch extends Compo
   componentDidUpdate(prevProps: Props) {
     // If the query changes in redux, also change it in the UI
     if (prevProps.query !== this.props.query) {
       this.setState({ inputValue: this.props.query });
     }
   }
 
   doSearch(searchTerm: string) {
-    this.props.searchSources(this.props.cx, searchTerm);
+    this.props.searchSources(searchTerm);
   }
 
   toggleProjectTextSearch = (key: string, e: KeyboardEvent) => {
-    const { cx, closeProjectSearch, setActiveSearch } = this.props;
+    const { closeProjectSearch, setActiveSearch } = this.props;
     if (e) {
       e.preventDefault();
     }
 
     if (this.isProjectSearchEnabled()) {
-      return closeProjectSearch(cx);
+      return closeProjectSearch();
     }
 
     return setActiveSearch("project");
   };
 
   isProjectSearchEnabled = () => this.props.activeSearch === "project";
 
   selectMatchItem = (matchItem: Match) => {
-    this.props.selectSpecificLocation(this.props.cx, {
+    this.props.selectSpecificLocation({
       sourceId: matchItem.sourceId,
       line: matchItem.line,
       column: matchItem.column
     });
     this.props.doSearchForHighlight(
       this.state.inputValue,
       getEditor(),
       matchItem.line,
@@ -194,20 +191,20 @@ export class ProjectSearch extends Compo
   onFocus = (item: Item) => {
     if (this.state.focusedItem !== item) {
       this.setState({ focusedItem: item });
     }
   };
 
   inputOnChange = (e: SyntheticInputEvent<HTMLInputElement>) => {
     const inputValue = e.target.value;
-    const { cx, clearSearch } = this.props;
+    const { clearSearch } = this.props;
     this.setState({ inputValue });
     if (inputValue === "") {
-      clearSearch(cx);
+      clearSearch();
     }
   };
 
   renderFile = (file: Result, focused: boolean, expanded: boolean) => {
     const matchesLength = file.matches.length;
     const matches = ` (${matchesLength} match${matchesLength > 1 ? "es" : ""})`;
 
     return (
@@ -329,17 +326,16 @@ export class ProjectSearch extends Compo
     );
   }
 }
 ProjectSearch.contextTypes = {
   shortcuts: PropTypes.object
 };
 
 const mapStateToProps = state => ({
-  cx: getContext(state),
   activeSearch: getActiveSearch(state),
   results: getTextSearchResults(state),
   query: getTextSearchQuery(state),
   status: getTextSearchStatus(state)
 });
 
 export default connect(
   mapStateToProps,
--- a/devtools/client/debugger/new/src/components/QuickOpenModal.js
+++ b/devtools/client/debugger/new/src/components/QuickOpenModal.js
@@ -12,18 +12,17 @@ import actions from "../actions";
 import {
   getDisplayedSourcesList,
   getQuickOpenEnabled,
   getQuickOpenQuery,
   getQuickOpenType,
   getSelectedSource,
   getSymbols,
   getTabs,
-  isSymbolsLoading,
-  getContext
+  isSymbolsLoading
 } from "../selectors";
 import { scrollList } from "../utils/result-list";
 import {
   formatSymbols,
   parseLineColumn,
   formatShortcutResults,
   formatSources
 } from "../utils/quick-open";
@@ -31,24 +30,23 @@ import Modal from "./shared/Modal";
 import SearchInput from "./shared/SearchInput";
 import ResultList from "./shared/ResultList";
 
 import type {
   FormattedSymbolDeclarations,
   QuickOpenResult
 } from "../utils/quick-open";
 
-import type { Source, Context } from "../types";
+import type { Source } from "../types";
 import type { QuickOpenType } from "../reducers/quick-open";
 import type { Tab } from "../reducers/tabs";
 
 import "./QuickOpenModal.css";
 
 type Props = {
-  cx: Context,
   enabled: boolean,
   sources: Array<Object>,
   selectedSource?: Source,
   query: string,
   searchType: QuickOpenType,
   symbols: FormattedSymbolDeclarations,
   symbolsLoading: boolean,
   tabs: Tab[],
@@ -242,21 +240,21 @@ export class QuickOpenModal extends Comp
     this.setState({ selectedIndex: nextIndex });
 
     if (results != null) {
       this.onSelectResultItem(results[nextIndex]);
     }
   };
 
   gotoLocation = (location: ?GotoLocationType) => {
-    const { cx, selectSpecificLocation, selectedSource } = this.props;
+    const { selectSpecificLocation, selectedSource } = this.props;
     const selectedSourceId = selectedSource ? selectedSource.id : "";
     if (location != null) {
       const sourceId = location.sourceId ? location.sourceId : selectedSourceId;
-      selectSpecificLocation(cx, {
+      selectSpecificLocation({
         sourceId,
         line: location.line,
         column: location.column
       });
       this.closeModal();
     }
   };
 
@@ -416,17 +414,16 @@ export class QuickOpenModal extends Comp
   }
 }
 
 /* istanbul ignore next: ignoring testing of redux connection stuff */
 function mapStateToProps(state) {
   const selectedSource = getSelectedSource(state);
 
   return {
-    cx: getContext(state),
     enabled: getQuickOpenEnabled(state),
     sources: formatSources(getDisplayedSourcesList(state), getTabs(state)),
     selectedSource,
     symbols: formatSymbols(getSymbols(state, selectedSource)),
     symbolsLoading: isSymbolsLoading(state, selectedSource),
     query: getQuickOpenQuery(state),
     searchType: getQuickOpenType(state),
     tabs: getTabs(state)
--- a/devtools/client/debugger/new/src/components/SecondaryPanes/Breakpoints/Breakpoint.js
+++ b/devtools/client/debugger/new/src/components/SecondaryPanes/Breakpoints/Breakpoint.js
@@ -22,34 +22,31 @@ import {
 import { getSelectedLocation } from "../../../utils/source-maps";
 import { features } from "../../../utils/prefs";
 import { getEditor } from "../../../utils/editor";
 
 import type {
   Breakpoint as BreakpointType,
   Frame,
   Source,
-  SourceLocation,
-  Context
+  SourceLocation
 } from "../../../types";
 
 type FormattedFrame = Frame & {
   selectedLocation: SourceLocation
 };
 
 import {
   getBreakpointsList,
   getSelectedFrame,
   getSelectedSource,
-  getCurrentThread,
-  getContext
+  getCurrentThread
 } from "../../../selectors";
 
 type Props = {
-  cx: Context,
   breakpoint: BreakpointType,
   breakpoints: BreakpointType[],
   selectedSource: Source,
   source: Source,
   frame: FormattedFrame,
   enableBreakpoint: typeof actions.enableBreakpoint,
   removeBreakpoint: typeof actions.removeBreakpoint,
   removeBreakpoints: typeof actions.removeBreakpoints,
@@ -77,32 +74,32 @@ class Breakpoint extends PureComponent<P
     const { breakpoint, openConditionalPanel } = this.props;
     if (breakpoint.options.condition) {
       openConditionalPanel(this.selectedLocation);
     }
   };
 
   selectBreakpoint = event => {
     event.preventDefault();
-    const { cx, selectSpecificLocation } = this.props;
-    selectSpecificLocation(cx, this.selectedLocation);
+    const { selectSpecificLocation } = this.props;
+    selectSpecificLocation(this.selectedLocation);
   };
 
   removeBreakpoint = event => {
-    const { cx, removeBreakpoint, breakpoint } = this.props;
+    const { removeBreakpoint, breakpoint } = this.props;
     event.stopPropagation();
-    removeBreakpoint(cx, breakpoint);
+    removeBreakpoint(breakpoint);
   };
 
   handleBreakpointCheckbox = () => {
-    const { cx, breakpoint, enableBreakpoint, disableBreakpoint } = this.props;
+    const { breakpoint, enableBreakpoint, disableBreakpoint } = this.props;
     if (breakpoint.disabled) {
-      enableBreakpoint(cx, breakpoint);
+      enableBreakpoint(breakpoint);
     } else {
-      disableBreakpoint(cx, breakpoint);
+      disableBreakpoint(breakpoint);
     }
   };
 
   isCurrentlyPausedAtBreakpoint() {
     const { frame } = this.props;
     if (!frame) {
       return false;
     }
@@ -209,17 +206,16 @@ const getFormattedFrame = createSelector
     return {
       ...frame,
       selectedLocation: getSelectedLocation(frame, selectedSource)
     };
   }
 );
 
 const mapStateToProps = state => ({
-  cx: getContext(state),
   breakpoints: getBreakpointsList(state),
   frame: getFormattedFrame(state, getCurrentThread(state))
 });
 
 export default connect(
   mapStateToProps,
   {
     enableBreakpoint: actions.enableBreakpoint,
--- a/devtools/client/debugger/new/src/components/SecondaryPanes/Breakpoints/BreakpointHeading.js
+++ b/devtools/client/debugger/new/src/components/SecondaryPanes/Breakpoints/BreakpointHeading.js
@@ -9,76 +9,67 @@ import actions from "../../../actions";
 import {
   getTruncatedFileName,
   getDisplayPath,
   getSourceQueryString,
   getFileURL
 } from "../../../utils/source";
 import {
   getHasSiblingOfSameName,
-  getBreakpointsForSource,
-  getContext
+  getBreakpointsForSource
 } from "../../../selectors";
 
 import SourceIcon from "../../shared/SourceIcon";
 
-import type { Source, Breakpoint, Context } from "../../../types";
+import type { Source, Breakpoint } from "../../../types";
 import showContextMenu from "./BreakpointHeadingsContextMenu";
 
 type Props = {
-  cx: Context,
   sources: Source[],
   source: Source,
   hasSiblingOfSameName: boolean,
   breakpointsForSource: Breakpoint[],
   disableBreakpointsInSource: typeof actions.disableBreakpointsInSource,
   enableBreakpointsInSource: typeof actions.enableBreakpointsInSource,
   removeBreakpointsInSource: typeof actions.removeBreakpointsInSource,
   selectSource: typeof actions.selectSource
 };
 
 class BreakpointHeading extends PureComponent<Props> {
   onContextMenu = e => {
     showContextMenu({ ...this.props, contextMenuEvent: e });
   };
 
   render() {
-    const {
-      cx,
-      sources,
-      source,
-      hasSiblingOfSameName,
-      selectSource
-    } = this.props;
+    const { sources, source, hasSiblingOfSameName, selectSource } = this.props;
 
     const path = getDisplayPath(source, sources);
     const query = hasSiblingOfSameName ? getSourceQueryString(source) : "";
 
     return (
       <div
         className="breakpoint-heading"
         title={getFileURL(source, false)}
-        onClick={() => selectSource(cx, source.id)}
+        onClick={() => selectSource(source.id)}
         onContextMenu={this.onContextMenu}
       >
         <SourceIcon
           source={source}
           shouldHide={icon => ["file", "javascript"].includes(icon)}
         />
         <div className="filename">
           {getTruncatedFileName(source, query)}
           {path && <span>{`../${path}/..`}</span>}
         </div>
       </div>
     );
   }
 }
 
 const mapStateToProps = (state, { source }) => ({
-  cx: getContext(state),
   hasSiblingOfSameName: getHasSiblingOfSameName(state, source),
   breakpointsForSource: getBreakpointsForSource(state, source.id)
 });
 
 export default connect(
   mapStateToProps,
   {
     selectSource: actions.selectSource,
--- a/devtools/client/debugger/new/src/components/SecondaryPanes/Breakpoints/BreakpointHeadingsContextMenu.js
+++ b/devtools/client/debugger/new/src/components/SecondaryPanes/Breakpoints/BreakpointHeadingsContextMenu.js
@@ -2,31 +2,29 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at <http://mozilla.org/MPL/2.0/>. */
 
 // @flow
 
 import { buildMenu, showMenu } from "devtools-contextmenu";
 
 import actions from "../../../actions";
-import type { Breakpoint, Source, Context } from "../../../types";
+import type { Breakpoint, Source } from "../../../types";
 
 type Props = {
-  cx: Context,
   source: Source,
   breakpointsForSource: Breakpoint[],
   disableBreakpointsInSource: typeof actions.disableBreakpointsInSource,
   enableBreakpointsInSource: typeof actions.enableBreakpointsInSource,
   removeBreakpointsInSource: typeof actions.removeBreakpointsInSource,
   contextMenuEvent: SyntheticEvent<HTMLElement>
 };
 
 export default function showContextMenu(props: Props) {
   const {
-    cx,
     source,
     breakpointsForSource,
     disableBreakpointsInSource,
     enableBreakpointsInSource,
     removeBreakpointsInSource,
     contextMenuEvent
   } = props;
 
@@ -51,33 +49,33 @@ export default function showContextMenu(
     "breakpointHeadingsMenuItem.removeInSource.accesskey"
   );
 
   const disableInSourceItem = {
     id: "node-menu-disable-in-source",
     label: disableInSourceLabel,
     accesskey: disableInSourceKey,
     disabled: false,
-    click: () => disableBreakpointsInSource(cx, source)
+    click: () => disableBreakpointsInSource(source)
   };
 
   const enableInSourceItem = {
     id: "node-menu-enable-in-source",
     label: enableInSourceLabel,
     accesskey: enableInSourceKey,
     disabled: false,
-    click: () => enableBreakpointsInSource(cx, source)
+    click: () => enableBreakpointsInSource(source)
   };
 
   const removeInSourceItem = {
     id: "node-menu-enable-in-source",
     label: removeInSourceLabel,
     accesskey: removeInSourceKey,
     disabled: false,
-    click: () => removeBreakpointsInSource(cx, source)
+    click: () => removeBreakpointsInSource(source)
   };
 
   const hideDisableInSourceItem = breakpointsForSource.every(
     breakpoint => breakpoint.disabled
   );
   const hideEnableInSourceItem = breakpointsForSource.every(
     breakpoint => !breakpoint.disabled
   );
--- a/devtools/client/debugger/new/src/components/SecondaryPanes/Breakpoints/BreakpointsContextMenu.js
+++ b/devtools/client/debugger/new/src/components/SecondaryPanes/Breakpoints/BreakpointsContextMenu.js
@@ -4,20 +4,19 @@
 
 // @flow
 
 import { buildMenu, showMenu } from "devtools-contextmenu";
 import { getSelectedLocation } from "../../../utils/source-maps";
 import actions from "../../../actions";
 import { features } from "../../../utils/prefs";
 
-import type { Breakpoint, Source, Context } from "../../../types";
+import type { Breakpoint, Source } from "../../../types";
 
 type Props = {
-  cx: Context,
   breakpoint: Breakpoint,
   breakpoints: Breakpoint[],
   selectedSource: Source,
   removeBreakpoint: typeof actions.removeBreakpoint,
   removeBreakpoints: typeof actions.removeBreakpoints,
   removeAllBreakpoints: typeof actions.removeAllBreakpoints,
   toggleBreakpoints: typeof actions.toggleBreakpoints,
   toggleAllBreakpoints: typeof actions.toggleAllBreakpoints,
@@ -25,17 +24,16 @@ type Props = {
   selectSpecificLocation: typeof actions.selectSpecificLocation,
   setBreakpointOptions: typeof actions.setBreakpointOptions,
   openConditionalPanel: typeof actions.openConditionalPanel,
   contextMenuEvent: SyntheticEvent<HTMLElement>
 };
 
 export default function showContextMenu(props: Props) {
   const {
-    cx,
     breakpoint,
     breakpoints,
     selectedSource,
     removeBreakpoint,
     removeBreakpoints,
     removeAllBreakpoints,
     toggleBreakpoints,
     toggleAllBreakpoints,
@@ -112,116 +110,116 @@ export default function showContextMenu(
   );
 
   const deleteSelfItem = {
     id: "node-menu-delete-self",
     label: deleteSelfLabel,
     accesskey: deleteSelfKey,
     disabled: false,
     click: () => {
-      removeBreakpoint(cx, breakpoint);
+      removeBreakpoint(breakpoint);
     }
   };
 
   const deleteAllItem = {
     id: "node-menu-delete-all",
     label: deleteAllLabel,
     accesskey: deleteAllKey,
     disabled: false,
-    click: () => removeAllBreakpoints(cx)
+    click: () => removeAllBreakpoints()
   };
 
   const deleteOthersItem = {
     id: "node-menu-delete-other",
     label: deleteOthersLabel,
     accesskey: deleteOthersKey,
     disabled: false,
-    click: () => removeBreakpoints(cx, otherBreakpoints)
+    click: () => removeBreakpoints(otherBreakpoints)
   };
 
   const enableSelfItem = {
     id: "node-menu-enable-self",
     label: enableSelfLabel,
     accesskey: enableSelfKey,
     disabled: false,
     click: () => {
-      toggleDisabledBreakpoint(cx, breakpoint);
+      toggleDisabledBreakpoint(breakpoint);
     }
   };
 
   const enableAllItem = {
     id: "node-menu-enable-all",
     label: enableAllLabel,
     accesskey: enableAllKey,
     disabled: false,
-    click: () => toggleAllBreakpoints(cx, false)
+    click: () => toggleAllBreakpoints(false)
   };
 
   const enableOthersItem = {
     id: "node-menu-enable-others",
     label: enableOthersLabel,
     accesskey: enableOthersKey,
     disabled: false,
-    click: () => toggleBreakpoints(cx, false, otherDisabledBreakpoints)
+    click: () => toggleBreakpoints(false, otherDisabledBreakpoints)
   };
 
   const disableSelfItem = {
     id: "node-menu-disable-self",
     label: disableSelfLabel,
     accesskey: disableSelfKey,
     disabled: false,
     click: () => {
-      toggleDisabledBreakpoint(cx, breakpoint);
+      toggleDisabledBreakpoint(breakpoint);
     }
   };
 
   const disableAllItem = {
     id: "node-menu-disable-all",
     label: disableAllLabel,
     accesskey: disableAllKey,
     disabled: false,
-    click: () => toggleAllBreakpoints(cx, true)
+    click: () => toggleAllBreakpoints(true)
   };
 
   const disableOthersItem = {
     id: "node-menu-disable-others",
     label: disableOthersLabel,
     accesskey: disableOthersKey,
-    click: () => toggleBreakpoints(cx, true, otherEnabledBreakpoints)
+    click: () => toggleBreakpoints(true, otherEnabledBreakpoints)
   };
 
   const removeConditionItem = {
     id: "node-menu-remove-condition",
     label: removeConditionLabel,
     accesskey: removeConditionKey,
     disabled: false,
     click: () =>
-      setBreakpointOptions(cx, selectedLocation, {
+      setBreakpointOptions(selectedLocation, {
         ...breakpoint.options,
         condition: null
       })
   };
 
   const addConditionItem = {
     id: "node-menu-add-condition",
     label: addConditionLabel,
     accesskey: addConditionKey,
     click: () => {
-      selectSpecificLocation(cx, selectedLocation);
+      selectSpecificLocation(selectedLocation);
       openConditionalPanel(selectedLocation);
     },
     accelerator: L10N.getStr("toggleCondPanel.breakpoint.key")
   };
 
   const editConditionItem = {
     id: "node-menu-edit-condition",
     label: editConditionLabel,
     accesskey: editConditionKey,
     click: () => {
-      selectSpecificLocation(cx, selectedLocation);
+      selectSpecificLocation(selectedLocation);
       openConditionalPanel(selectedLocation);
     },
     accelerator: L10N.getStr("toggleCondPanel.breakpoint.key")
   };
 
   const addLogPointItem = {
     id: "node-menu-add-log-point",
     label: L10N.getStr("editor.addLogPoint"),
@@ -241,17 +239,17 @@ export default function showContextMenu(
   };
 
   const removeLogPointItem = {
     id: "node-menu-remove-log",
     label: L10N.getStr("editor.removeLogPoint.label"),
     accesskey: L10N.getStr("editor.removeLogPoint.accesskey"),
     disabled: false,
     click: () =>
-      setBreakpointOptions(cx, selectedLocation, {
+      setBreakpointOptions(selectedLocation, {
         ...breakpoint.options,
         logValue: null
       })
   };
 
   const logPointItem = breakpoint.options.logValue
     ? editLogPointItem
     : addLogPointItem;
--- a/devtools/client/debugger/new/src/components/SecondaryPanes/Breakpoints/tests/BreakpointsContextMenu.spec.js
+++ b/devtools/client/debugger/new/src/components/SecondaryPanes/Breakpoints/tests/BreakpointsContextMenu.spec.js
@@ -7,18 +7,17 @@
 import React from "react";
 import { shallow } from "enzyme";
 
 import BreakpointsContextMenu from "../BreakpointsContextMenu";
 import { buildMenu } from "devtools-contextmenu";
 
 import {
   makeMockBreakpoint,
-  makeMockSource,
-  mockcx
+  makeMockSource
 } from "../../../../utils/test-mockup";
 
 jest.mock("devtools-contextmenu");
 
 function render(disabled = false) {
   const props = generateDefaults(disabled);
   const component = shallow(<BreakpointsContextMenu {...props} />);
   return { component, props };
@@ -51,17 +50,16 @@ function generateDefaults(disabled) {
     {
       ...makeMockBreakpoint(source, 3),
       id: "https://example.com/main.js:3:",
       disabled: disabled
     }
   ];
 
   const props = {
-    cx: mockcx,
     breakpoints,
     breakpoint: breakpoints[0],
     removeBreakpoint: jest.fn(),
     removeBreakpoints: jest.fn(),
     removeAllBreakpoints: jest.fn(),
     toggleBreakpoints: jest.fn(),
     toggleAllBreakpoints: jest.fn(),
     toggleDisabledBreakpoint: jest.fn(),
@@ -87,49 +85,49 @@ describe("BreakpointsContextMenu", () =>
       const deleteOthers = menuItems.find(
         item => item.item.id === "node-menu-delete-other"
       );
       deleteOthers.item.click();
 
       expect(props.removeBreakpoints).toHaveBeenCalled();
 
       const otherBreakpoints = [props.breakpoints[1], props.breakpoints[2]];
-      expect(props.removeBreakpoints.mock.calls[0][1]).toEqual(
+      expect(props.removeBreakpoints.mock.calls[0][0]).toEqual(
         otherBreakpoints
       );
     });
 
     it("'enable others' calls toggleBreakpoints with proper arguments", () => {
       const { props } = render(true);
       const menuItems = buildMenu.mock.calls[0][0];
       const enableOthers = menuItems.find(
         item => item.item.id === "node-menu-enable-others"
       );
       enableOthers.item.click();
 
       expect(props.toggleBreakpoints).toHaveBeenCalled();
 
-      expect(props.toggleBreakpoints.mock.calls[0][1]).toBe(false);
+      expect(props.toggleBreakpoints.mock.calls[0][0]).toBe(false);
 
       const otherBreakpoints = [props.breakpoints[1], props.breakpoints[2]];
-      expect(props.toggleBreakpoints.mock.calls[0][2]).toEqual(
+      expect(props.toggleBreakpoints.mock.calls[0][1]).toEqual(
         otherBreakpoints
       );
     });
 
     it("'disable others' calls toggleBreakpoints with proper arguments", () => {
       const { props } = render();
       const menuItems = buildMenu.mock.calls[0][0];
       const disableOthers = menuItems.find(
         item => item.item.id === "node-menu-disable-others"
       );
       disableOthers.item.click();
 
       expect(props.toggleBreakpoints).toHaveBeenCalled();
-      expect(props.toggleBreakpoints.mock.calls[0][1]).toBe(true);
+      expect(props.toggleBreakpoints.mock.calls[0][0]).toBe(true);
 
       const otherBreakpoints = [props.breakpoints[1], props.breakpoints[2]];
-      expect(props.toggleBreakpoints.mock.calls[0][2]).toEqual(
+      expect(props.toggleBreakpoints.mock.calls[0][1]).toEqual(
         otherBreakpoints
       );
     });
   });
 });
--- a/devtools/client/debugger/new/src/components/SecondaryPanes/CommandBar.js
+++ b/devtools/client/debugger/new/src/components/SecondaryPanes/CommandBar.js
@@ -7,30 +7,29 @@
 
 import PropTypes from "prop-types";
 import React, { Component } from "react";
 
 import { connect } from "../../utils/connect";
 import classnames from "classnames";
 import { features } from "../../utils/prefs";
 import {
+  getIsPaused,
   getIsWaitingOnBreak,
   getCanRewind,
   getSkipPausing,
-  getCurrentThread,
-  getThreadContext
+  getCurrentThread
 } from "../../selectors";
 import { formatKeyShortcut } from "../../utils/text";
 import actions from "../../actions";
 import { debugBtn } from "../shared/Button/CommandBarButton";
 import AccessibleImage from "../shared/AccessibleImage";
 import "./CommandBar.css";
 
 import { appinfo } from "devtools-services";
-import type { ThreadContext } from "../../types";
 
 const isMacOS = appinfo.OS === "Darwin";
 
 // NOTE: the "resume" command will call either the resume or breakOnNext action
 // depending on whether or not the debugger is paused or running
 const COMMANDS = ["resume", "stepOver", "stepIn", "stepOut"];
 
 const KEYS = {
@@ -71,17 +70,17 @@ function formatKey(action) {
       getKeyForOS("WINNT", `${action}Display`) || getKeyForOS("WINNT", action);
     // display both Windows type and Mac specific keys
     return formatKeyShortcut([key, winKey].join(" "));
   }
   return formatKeyShortcut(key);
 }
 
 type Props = {
-  cx: ThreadContext,
+  isPaused: boolean,
   isWaitingOnBreak: boolean,
   horizontal: boolean,
   canRewind: boolean,
   skipPausing: boolean,
   resume: typeof actions.resume,
   stepIn: typeof actions.stepIn,
   stepOut: typeof actions.stepOut,
   stepOver: typeof actions.stepOver,
@@ -117,70 +116,67 @@ class CommandBar extends Component<Props
         shortcuts.on(getKeyForOS("WINNT", action), (_, e) =>
           this.handleEvent(e, action)
         )
       );
     }
   }
 
   handleEvent(e, action) {
-    const { cx } = this.props;
     e.preventDefault();
     e.stopPropagation();
     if (action === "resume") {
-      this.props.cx.isPaused
-        ? this.props.resume(cx)
-        : this.props.breakOnNext(cx);
+      this.props.isPaused ? this.props.resume() : this.props.breakOnNext();
     } else {
-      this.props[action](cx);
+      this.props[action]();
     }
   }
 
   renderStepButtons() {
-    const { cx, canRewind } = this.props;
-    const className = cx.isPaused ? "active" : "disabled";
-    const isDisabled = !cx.isPaused;
+    const { isPaused, canRewind } = this.props;
+    const className = isPaused ? "active" : "disabled";
+    const isDisabled = !isPaused;
 
-    if (canRewind || (!cx.isPaused && features.removeCommandBarOptions)) {
+    if (canRewind || (!isPaused && features.removeCommandBarOptions)) {
       return;
     }
 
     return [
       debugBtn(
-        () => this.props.stepOver(cx),
+        this.props.stepOver,
         "stepOver",
         className,
         L10N.getFormatStr("stepOverTooltip", formatKey("stepOver")),
         isDisabled
       ),
       debugBtn(
-        () => this.props.stepIn(cx),
+        this.props.stepIn,
         "stepIn",
         className,
         L10N.getFormatStr("stepInTooltip", formatKey("stepIn")),
         isDisabled
       ),
       debugBtn(
-        () => this.props.stepOut(cx),
+        this.props.stepOut,
         "stepOut",
         className,
         L10N.getFormatStr("stepOutTooltip", formatKey("stepOut")),
         isDisabled
       )
     ];
   }
 
   resume() {
-    this.props.resume(this.props.cx);
+    this.props.resume();
   }
 
   renderPauseButton() {
-    const { cx, breakOnNext, isWaitingOnBreak, canRewind } = this.props;
+    const { isPaused, breakOnNext, isWaitingOnBreak, canRewind } = this.props;
 
-    if (cx.isPaused) {
+    if (isPaused) {
       if (canRewind) {
         return null;
       }
       return debugBtn(
         () => this.resume(),
         "resume",
         "active",
         L10N.getFormatStr("resumeButtonTooltip", formatKey("resume"))
@@ -197,71 +193,66 @@ class CommandBar extends Component<Props
         "pause",
         "disabled",
         L10N.getStr("pausePendingButtonTooltip"),
         true
       );
     }
 
     return debugBtn(
-      () => breakOnNext(cx),
+      breakOnNext,
       "pause",
       "active",
       L10N.getFormatStr("pauseButtonTooltip", formatKey("resume"))
     );
   }
 
   renderTimeTravelButtons() {
-    const { cx, canRewind } = this.props;
+    const { isPaused, canRewind } = this.props;
 
-    if (!canRewind || !cx.isPaused) {
+    if (!canRewind || !isPaused) {
       return null;
     }
 
-    const isDisabled = !cx.isPaused;
+    const isDisabled = !isPaused;
 
     return [
-      debugBtn(
-        () => this.props.rewind(cx),
-        "rewind",
-        "active",
-        "Rewind Execution"
-      ),
+      debugBtn(this.props.rewind, "rewind", "active", "Rewind Execution"),
 
       debugBtn(
-        () => this.props.resume(cx),
+        this.props.resume,
         "resume",
         "active",
         L10N.getFormatStr("resumeButtonTooltip", formatKey("resume"))
       ),
       <div key="divider-1" className="divider" />,
       debugBtn(
-        () => this.props.reverseStepOver(cx),
+        this.props.reverseStepOver,
         "reverseStepOver",
         "active",
         "Reverse step over"
       ),
       debugBtn(
-        () => this.props.stepOver(cx),
+        this.props.stepOver,
         "stepOver",
         "active",
         L10N.getFormatStr("stepOverTooltip", formatKey("stepOver")),
         isDisabled
       ),
       <div key="divider-2" className="divider" />,
       debugBtn(
-        () => this.props.stepOut(cx),
+        this.props.stepOut,
         "stepOut",
         "active",
         L10N.getFormatStr("stepOutTooltip", formatKey("stepOut")),
         isDisabled
       ),
 
       debugBtn(
-        () => this.props.stepIn(cx),
+        this.props.stepIn,
         "stepIn",
         "active",
         L10N.getFormatStr("stepInTooltip", formatKey("stepIn")),
         isDisabled
       )
     ];
   }
 
@@ -307,17 +298,17 @@ class CommandBar extends Component<Props
   }
 }
 
 CommandBar.contextTypes = {
   shortcuts: PropTypes.object
 };
 
 const mapStateToProps = state => ({
-  cx: getThreadContext(state),
+  isPaused: getIsPaused(state, getCurrentThread(state)),
   isWaitingOnBreak: getIsWaitingOnBreak(state, getCurrentThread(state)),
   canRewind: getCanRewind(state),
   skipPausing: getSkipPausing(state)
 });
 
 export default connect(
   mapStateToProps,
   {
--- a/devtools/client/debugger/new/src/components/SecondaryPanes/Expressions.js
+++ b/devtools/client/debugger/new/src/components/SecondaryPanes/Expressions.js
@@ -8,41 +8,39 @@ import { connect } from "../../utils/con
 import classnames from "classnames";
 import { features } from "../../utils/prefs";
 import { objectInspector } from "devtools-reps";
 
 import actions from "../../actions";
 import {
   getExpressions,
   getExpressionError,
-  getAutocompleteMatchset,
-  getThreadContext
+  getAutocompleteMatchset
 } from "../../selectors";
 import { getValue } from "../../utils/expressions";
 import { createObjectClient } from "../../client/firefox";
 
 import { CloseButton } from "../shared/Button";
 import { debounce } from "lodash";
 
 import type { List } from "immutable";
-import type { Expression, ThreadContext } from "../../types";
+import type { Expression } from "../../types";
 
 import "./Expressions.css";
 
 const { ObjectInspector } = objectInspector;
 
 type State = {
   editing: boolean,
   editIndex: number,
   inputValue: string,
   focused: boolean
 };
 
 type Props = {
-  cx: ThreadContext,
   expressions: List<Expression>,
   expressionError: boolean,
   showInput: boolean,
   autocompleteMatches: string[],
   onExpressionAdded: () => void,
   autocomplete: typeof actions.autocomplete,
   clearAutocomplete: typeof actions.clearAutocomplete,
   addExpression: typeof actions.addExpression,
@@ -68,20 +66,20 @@ class Expressions extends Component<Prop
       editing: false,
       editIndex: -1,
       inputValue: "",
       focused: false
     };
   }
 
   componentDidMount() {
-    const { cx, expressions, evaluateExpressions, showInput } = this.props;
+    const { expressions, evaluateExpressions, showInput } = this.props;
 
     if (expressions.size > 0) {
-      evaluateExpressions(cx);
+      evaluateExpressions();
     }
 
     // Ensures that the input is focused when the "+"
     // is clicked while the panel is collapsed
     if (showInput && this._input) {
       this._input.focus();
     }
   }
@@ -156,17 +154,17 @@ class Expressions extends Component<Prop
     if (features.autocompleteExpression) {
       this.findAutocompleteMatches(target.value, target.selectionStart);
     }
     this.setState({ inputValue: target.value });
   };
 
   findAutocompleteMatches = debounce((value, selectionStart) => {
     const { autocomplete } = this.props;
-    autocomplete(this.props.cx, value, selectionStart);
+    autocomplete(value, selectionStart);
   }, 250);
 
   handleKeyDown = (e: SyntheticKeyboardEvent<HTMLInputElement>) => {
     if (e.key === "Escape") {
       this.clear();
     }
   };
 
@@ -187,31 +185,27 @@ class Expressions extends Component<Prop
 
   handleExistingSubmit = async (
     e: SyntheticEvent<HTMLFormElement>,
     expression: Expression
   ) => {
     e.preventDefault();
     e.stopPropagation();
 
-    this.props.updateExpression(
-      this.props.cx,
-      this.state.inputValue,
-      expression
-    );
+    this.props.updateExpression(this.state.inputValue, expression);
     this.hideInput();
   };
 
   handleNewSubmit = async (e: SyntheticEvent<HTMLFormElement>) => {
     const { inputValue } = this.state;
     e.preventDefault();
     e.stopPropagation();
 
     this.props.clearExpressionError();
-    await this.props.addExpression(this.props.cx, this.state.inputValue);
+    await this.props.addExpression(this.state.inputValue);
     this.setState({
       editing: false,
       editIndex: -1,
       inputValue: this.props.expressionError ? inputValue : ""
     });
 
     if (!this.props.expressionError) {
       this.hideInput();
@@ -367,17 +361,16 @@ class Expressions extends Component<Prop
         {(showInput || !expressions.size) && this.renderNewExpressionInput()}
       </ul>
     );
   }
 }
 
 const mapStateToProps = state => {
   return {
-    cx: getThreadContext(state),
     autocompleteMatches: getAutocompleteMatchset(state),
     expressions: getExpressions(state),
     expressionError: getExpressionError(state)
   };
 };
 
 export default connect(
   mapStateToProps,
--- a/devtools/client/debugger/new/src/components/SecondaryPanes/Frames/Frame.js
+++ b/devtools/client/debugger/new/src/components/SecondaryPanes/Frames/Frame.js
@@ -8,19 +8,18 @@ import PropTypes from "prop-types";
 
 import classNames from "classnames";
 
 import AccessibleImage from "../../shared/AccessibleImage";
 import { formatDisplayName } from "../../../utils/pause/frames";
 import { getFilename, getFileURL } from "../../../utils/source";
 import FrameMenu from "./FrameMenu";
 import FrameIndent from "./FrameIndent";
-import actions from "../../../actions";
 
-import type { Frame, ThreadContext } from "../../../types";
+import type { Frame } from "../../../types";
 
 type FrameTitleProps = {
   frame: Frame,
   options: Object,
   l10n: Object
 };
 
 function FrameTitle({ frame, options = {}, l10n }: FrameTitleProps) {
@@ -57,22 +56,21 @@ function FrameLocation({ frame, displayF
       <span className="line">{location.line}</span>
     </span>
   );
 }
 
 FrameLocation.displayName = "FrameLocation";
 
 type FrameComponentProps = {
-  cx: ThreadContext,
   frame: Frame,
   selectedFrame: Frame,
   copyStackTrace: Function,
   toggleFrameworkGrouping: Function,
-  selectFrame: typeof actions.selectFrame,
+  selectFrame: Function,
   frameworkGroupingOn: boolean,
   hideLocation: boolean,
   shouldMapDisplayName: boolean,
   toggleBlackBox: Function,
   displayFullUrl: boolean,
   getFrameTitle?: string => string,
   disableContextMenu: boolean,
   selectable: boolean
@@ -104,28 +102,28 @@ export default class FrameComponent exte
   onMouseDown(
     e: SyntheticMouseEvent<HTMLElement>,
     frame: Frame,
     selectedFrame: Frame
   ) {
     if (e.button !== 0) {
       return;
     }
-    this.props.selectFrame(this.props.cx, frame);
+    this.props.selectFrame(frame);
   }
 
   onKeyUp(
     event: SyntheticKeyboardEvent<HTMLElement>,
     frame: Frame,
     selectedFrame: Frame
   ) {
     if (event.key != "Enter") {
       return;
     }
-    this.props.selectFrame(this.props.cx, frame);
+    this.props.selectFrame(frame);
   }
 
   render() {
     const {
       frame,
       selectedFrame,
       hideLocation,
       shouldMapDisplayName,
--- a/devtools/client/debugger/new/src/components/SecondaryPanes/Frames/Group.js
+++ b/devtools/client/debugger/new/src/components/SecondaryPanes/Frames/Group.js
@@ -10,18 +10,17 @@ import classNames from "classnames";
 import { getLibraryFromUrl } from "../../../utils/pause/frames";
 
 import FrameMenu from "./FrameMenu";
 import AccessibleImage from "../../shared/AccessibleImage";
 import FrameComponent from "./Frame";
 
 import "./Group.css";
 
-import actions from "../../../actions";
-import type { Frame, ThreadContext } from "../../../types";
+import type { Frame } from "../../../types";
 import Badge from "../../shared/Badge";
 import FrameIndent from "./FrameIndent";
 
 type FrameLocationProps = { frame: Frame, expanded: boolean };
 function FrameLocation({ frame, expanded }: FrameLocationProps) {
   const library = frame.library || getLibraryFromUrl(frame);
   if (!library) {
     return null;
@@ -35,20 +34,19 @@ function FrameLocation({ frame, expanded
       <span className="group-description-name">{library}</span>
     </span>
   );
 }
 
 FrameLocation.displayName = "FrameLocation";
 
 type Props = {
-  cx: ThreadContext,
   group: Frame[],
   selectedFrame: Frame,
-  selectFrame: typeof actions.selectFrame,
+  selectFrame: Function,
   toggleFrameworkGrouping: Function,
   copyStackTrace: Function,
   toggleBlackBox: Function,
   frameworkGroupingOn: boolean,
   displayFullUrl: boolean,
   getFrameTitle?: string => string,
   disableContextMenu: boolean,
   selectable: boolean
@@ -85,17 +83,16 @@ export default class Group extends Compo
 
   toggleFrames = (event: SyntheticMouseEvent<HTMLElement>) => {
     event.stopPropagation();
     this.setState(prevState => ({ expanded: !prevState.expanded }));
   };
 
   renderFrames() {
     const {
-      cx,
       group,
       selectFrame,
       selectedFrame,
       toggleFrameworkGrouping,
       frameworkGroupingOn,
       toggleBlackBox,
       copyStackTrace,
       displayFullUrl,
@@ -112,17 +109,16 @@ export default class Group extends Compo
     return (
       <div className="frames-list">
         {group.reduce((acc, frame, i) => {
           if (selectable) {
             acc.push(<FrameIndent key={`frame-indent-${i}`} />);
           }
           return acc.concat(
             <FrameComponent
-              cx={cx}
               copyStackTrace={copyStackTrace}
               frame={frame}
               frameworkGroupingOn={frameworkGroupingOn}
               hideLocation={true}
               key={frame.id}
               selectedFrame={selectedFrame}
               selectFrame={selectFrame}
               shouldMapDisplayName={false}
--- a/devtools/client/debugger/new/src/components/SecondaryPanes/Frames/index.js
+++ b/devtools/client/debugger/new/src/components/SecondaryPanes/Frames/index.js
@@ -3,47 +3,45 @@
  * file, You can obtain one at <http://mozilla.org/MPL/2.0/>. */
 
 // @flow
 
 import React, { Component } from "react";
 import { connect } from "../../../utils/connect";
 import PropTypes from "prop-types";
 
-import type { Frame, Why, ThreadContext } from "../../../types";
+import type { Frame, Why } from "../../../types";
 
 import FrameComponent from "./Frame";
 import Group from "./Group";
 
 import renderWhyPaused from "./WhyPaused";
 
 import actions from "../../../actions";
 import { collapseFrames, formatCopyName } from "../../../utils/pause/frames";
 import { copyToTheClipboard } from "../../../utils/clipboard";
 
 import {
   getFrameworkGroupingState,
   getSelectedFrame,
   getCallStackFrames,
   getPauseReason,
-  getCurrentThread,
-  getThreadContext
+  getCurrentThread
 } from "../../../selectors";
 
 import "./Frames.css";
 
 const NUM_FRAMES_SHOWN = 7;
 
 type Props = {
-  cx: ThreadContext,
   frames: Array<Frame>,
   frameworkGroupingOn: boolean,
   selectedFrame: Object,
   why: Why,
-  selectFrame: typeof actions.selectFrame,
+  selectFrame: Function,
   toggleBlackBox: Function,
   toggleFrameworkGrouping: Function,
   disableFrameTruncate: boolean,
   disableContextMenu: boolean,
   displayFullUrl: boolean,
   getFrameTitle?: string => string,
   selectable?: boolean
 };
@@ -111,17 +109,16 @@ class Frames extends Component<Props, St
 
   toggleFrameworkGrouping = () => {
     const { toggleFrameworkGrouping, frameworkGroupingOn } = this.props;
     toggleFrameworkGrouping(!frameworkGroupingOn);
   };
 
   renderFrames(frames: Frame[]) {
     const {
-      cx,
       selectFrame,
       selectedFrame,
       toggleBlackBox,
       frameworkGroupingOn,
       displayFullUrl,
       getFrameTitle,
       disableContextMenu,
       selectable = false
@@ -134,33 +131,31 @@ class Frames extends Component<Props, St
     // the user copies the trace. Needed for the console which has several
     // places where we don't want to have those new lines.
     return (
       <div role="list">
         {framesOrGroups.map(
           (frameOrGroup: FrameOrGroup) =>
             frameOrGroup.id ? (
               <FrameComponent
-                cx={cx}
                 frame={(frameOrGroup: any)}
                 toggleFrameworkGrouping={this.toggleFrameworkGrouping}
                 copyStackTrace={this.copyStackTrace}
                 frameworkGroupingOn={frameworkGroupingOn}
                 selectFrame={selectFrame}
                 selectedFrame={selectedFrame}
                 toggleBlackBox={toggleBlackBox}
                 key={String(frameOrGroup.id)}
                 displayFullUrl={displayFullUrl}
                 getFrameTitle={getFrameTitle}
                 disableContextMenu={disableContextMenu}
                 selectable={selectable}
               />
             ) : (
               <Group
-                cx={cx}
                 group={(frameOrGroup: any)}
                 toggleFrameworkGrouping={this.toggleFrameworkGrouping}
                 copyStackTrace={this.copyStackTrace}
                 frameworkGroupingOn={frameworkGroupingOn}
                 selectFrame={selectFrame}
                 selectedFrame={selectedFrame}
                 toggleBlackBox={toggleBlackBox}
                 key={frameOrGroup[0].id}
@@ -216,17 +211,16 @@ class Frames extends Component<Props, St
       </div>
     );
   }
 }
 
 Frames.contextTypes = { l10n: PropTypes.object };
 
 const mapStateToProps = state => ({
-  cx: getThreadContext(state),
   frames: getCallStackFrames(state),
   why: getPauseReason(state, getCurrentThread(state)),
   frameworkGroupingOn: getFrameworkGroupingState(state),
   selectedFrame: getSelectedFrame(state, getCurrentThread(state))
 });
 
 export default connect(
   mapStateToProps,
--- a/devtools/client/debugger/new/src/components/SecondaryPanes/Frames/tests/Frame.spec.js
+++ b/devtools/client/debugger/new/src/components/SecondaryPanes/Frames/tests/Frame.spec.js
@@ -2,28 +2,23 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at <http://mozilla.org/MPL/2.0/>. */
 
 // @flow
 
 import React from "react";
 import { shallow, mount } from "enzyme";
 import Frame from "../Frame.js";
-import {
-  makeMockFrame,
-  makeMockSource,
-  mockthreadcx
-} from "