diff --git a/packages/driver/src/cy/commands/actions/focus.ts b/packages/driver/src/cy/commands/actions/focus.ts
index e5bfdf8d3d63..965d16f1b978 100644
--- a/packages/driver/src/cy/commands/actions/focus.ts
+++ b/packages/driver/src/cy/commands/actions/focus.ts
@@ -22,74 +22,74 @@ interface InternalBlurOptions extends Partial<Cypress.BlurOptions> {
 
 export default (Commands, Cypress, cy) => {
   return Commands.addAll({ prevSubject: ['element', 'window'] }, {
-    focus (subject, options: Partial<Cypress.Loggable & Cypress.Timeoutable> = {}) {
+    focus (subject, userOptions: Partial<Cypress.Loggable & Cypress.Timeoutable> = {}) {
       // we should throw errors by default!
       // but allow them to be silenced
-      const _options: InternalFocusOptions = _.defaults({}, options, {
+      const options: InternalFocusOptions = _.defaults({}, userOptions, {
         $el: subject,
         error: true,
         log: true,
         verify: true,
       })
 
-      const isWin = $dom.isWindow(_options.$el)
+      const isWin = $dom.isWindow(options.$el)
 
       if (isWin) {
         // get this into a jquery object
-        _options.$el = $dom.wrap(_options.$el)
+        options.$el = $dom.wrap(options.$el)
       }
 
-      if (_options.log) {
-        _options._log = Cypress.log({
-          $el: _options.$el,
-          timeout: _options.timeout,
+      if (options.log) {
+        options._log = Cypress.log({
+          $el: options.$el,
+          timeout: options.timeout,
           consoleProps () {
-            return { 'Applied To': $dom.getElements(_options.$el) }
+            return { 'Applied To': $dom.getElements(options.$el) }
           },
         })
       }
 
-      const el = _options.$el.get(0)
+      const el = options.$el.get(0)
 
       // the body is not really focusable, but it
       // can have focus on initial page load.
       // this is instead a noop.
       // TODO: throw on body instead (breaking change)
-      const isBody = $dom.isJquery(_options.$el) &&
-      $elements.isElement(_options.$el.get(0)) &&
-      $elements.isBody(_options.$el.get(0))
+      const isBody = $dom.isJquery(options.$el) &&
+      $elements.isElement(options.$el.get(0)) &&
+      $elements.isBody(options.$el.get(0))
 
       // http://www.w3.org/$R/html5/editing.html#specially-focusable
       // ensure there is only 1 dom element in the subject
       // make sure its allowed to be focusable
-      if (!(isWin || isBody || $dom.isFocusable(_options.$el))) {
-        if (_options.error === false) {
+      if (!(isWin || isBody || $dom.isFocusable(options.$el))) {
+        if (options.error === false) {
           return
         }
 
-        const node = $dom.stringify(_options.$el)
+        const node = $dom.stringify(options.$el)
 
         $errUtils.throwErrByPath('focus.invalid_element', {
-          onFail: _options._log,
+          onFail: options._log,
           args: { node },
         })
       }
 
-      if (_options.$el.length && _options.$el.length > 1) {
-        if (_options.error === false) {
+      if (options.$el.length && options.$el.length > 1) {
+        if (options.error === false) {
           return
         }
 
         $errUtils.throwErrByPath('focus.multiple_elements', {
-          onFail: _options._log,
-          args: { num: _options.$el.length },
+          onFail: options._log,
+          args: { num: options.$el.length },
         })
       }
 
       cy.fireFocus(el)
 
       const verifyAssertions = () => {
-        return cy.verifyUpcomingAssertions(_options.$el, _options, {
+        return cy.verifyUpcomingAssertions(options.$el, options, {
           onRetry: verifyAssertions,
         })
       }
@@ -97,10 +97,10 @@ export default (Commands, Cypress, cy) => {
       return verifyAssertions()
     },
 
-    blur (subject, options: Partial<Cypress.BlurOptions> = {}) {
+    blur (subject, userOptions: Partial<Cypress.BlurOptions> = {}) {
       // we should throw errors by default!
       // but allow them to be silenced
-      const _options: InternalBlurOptions = _.defaults({}, options, {
+      const options: InternalBlurOptions = _.defaults({}, userOptions, {
         $el: subject,
         $focused: cy.getFocused(),
         error: true,
@@ -109,78 +109,78 @@ export default (Commands, Cypress, cy) => {
         force: false,
       })
 
-      const { $focused } = _options
+      const { $focused } = options
 
-      const isWin = $dom.isWindow(_options.$el)
+      const isWin = $dom.isWindow(options.$el)
 
       if (isWin) {
         // get this into a jquery object
-        _options.$el = $dom.wrap(_options.$el)
+        options.$el = $dom.wrap(options.$el)
       }
 
-      const isBody = _options.$el.is('body')
+      const isBody = options.$el.is('body')
 
-      if (_options.log) {
+      if (options.log) {
         // figure out the options which actually change the behavior of clicks
-        const deltaOptions = $utils.filterOutOptions(_options)
+        const deltaOptions = $utils.filterOutOptions(options)
 
-        _options._log = Cypress.log({
-          $el: _options.$el,
+        options._log = Cypress.log({
+          $el: options.$el,
           message: deltaOptions,
-          timeout: _options.timeout,
+          timeout: options.timeout,
           consoleProps () {
-            return { 'Applied To': $dom.getElements(_options.$el) }
+            return { 'Applied To': $dom.getElements(options.$el) }
           },
         })
       }
 
-      if (_options.$el.length && _options.$el.length > 1) {
-        if (_options.error === false) {
+      if (options.$el.length && options.$el.length > 1) {
+        if (options.error === false) {
           return
         }
 
         $errUtils.throwErrByPath('blur.multiple_elements', {
-          onFail: _options._log,
-          args: { num: _options.$el.length },
+          onFail: options._log,
+          args: { num: options.$el.length },
         })
       }
 
       // if we haven't forced the blur, and we don't currently
       // have a focused element OR we aren't the window or body then error
-      if (_options.force !== true && !$focused && !isWin && !isBody) {
-        if (_options.error === false) {
+      if (options.force !== true && !$focused && !isWin && !isBody) {
+        if (options.error === false) {
           return
         }
 
-        $errUtils.throwErrByPath('blur.no_focused_element', { onFail: _options._log })
+        $errUtils.throwErrByPath('blur.no_focused_element', { onFail: options._log })
       }
 
       // if we're currently window dont check for the wrong
       // focused element because window will not show up
       // as $focused
-      if (_options.force !== true &&
+      if (options.force !== true &&
         !isWin &&
         !isBody &&
-        _options.$el.get(0) !== $focused.get(0)
+        options.$el.get(0) !== $focused.get(0)
       ) {
-        if (_options.error === false) {
+        if (options.error === false) {
           return
         }
 
         const node = $dom.stringify($focused)
 
         $errUtils.throwErrByPath('blur.wrong_focused_element', {
-          onFail: _options._log,
+          onFail: options._log,
           args: { node },
         })
       }
 
-      const el = _options.$el.get(0)
+      const el = options.$el.get(0)
 
       cy.fireBlur(el)
 
       const verifyAssertions = () => {
-        return cy.verifyUpcomingAssertions(_options.$el, _options, {
+        return cy.verifyUpcomingAssertions(options.$el, options, {
           onRetry: verifyAssertions,
         })
       }
diff --git a/packages/driver/src/cy/commands/actions/scroll.ts b/packages/driver/src/cy/commands/actions/scroll.ts
index 9105e490353e..e1bbee118399 100644
--- a/packages/driver/src/cy/commands/actions/scroll.ts
+++ b/packages/driver/src/cy/commands/actions/scroll.ts
@@ -47,9 +47,9 @@ interface InternalScrollToOptions extends Partial<Cypress.ScrollToOptions> {
 
 export default (Commands, Cypress, cy, state) => {
   Commands.addAll({ prevSubject: 'element' }, {
-    scrollIntoView (subject, options: Partial<Cypress.ScrollToOptions> = {}) {
-      if (!_.isObject(options)) {
-        $errUtils.throwErrByPath('scrollIntoView.invalid_argument', { args: { arg: options } })
+    scrollIntoView (subject, userOptions: Partial<Cypress.ScrollToOptions> = {}) {
+      if (!_.isObject(userOptions)) {
+        $errUtils.throwErrByPath('scrollIntoView.invalid_argument', { args: { arg: userOptions } })
       }
 
       // ensure the subject is not window itself
@@ -63,7 +63,7 @@ export default (Commands, Cypress, cy, state) => {
         $errUtils.throwErrByPath('scrollIntoView.multiple_elements', { args: { num: subject.length } })
       }
 
-      const _options: InternalScrollIntoViewOptions = _.defaults({}, options, {
+      const options: InternalScrollIntoViewOptions = _.defaults({}, userOptions, {
         $el: subject,
         $parent: state('window'),
         log: true,
@@ -73,69 +73,69 @@ export default (Commands, Cypress, cy, state) => {
       })
 
       // figure out the options which actually change the behavior of clicks
-      let deltaOptions = $utils.filterOutOptions(_options)
+      let deltaOptions = $utils.filterOutOptions(options)
 
       // here we want to figure out what has to actually
       // be scrolled to get to this element, cause we need
       // to scrollTo passing in that element.
-      _options.$parent = findScrollableParent(_options.$el, state('window'))
+      options.$parent = findScrollableParent(options.$el, state('window'))
 
       let parentIsWin = false
 
-      if (_options.$parent === state('window')) {
+      if (options.$parent === state('window')) {
         parentIsWin = true
         // jQuery scrollTo looks for the prop contentWindow
         // otherwise it'll use the wrong window to scroll :(
-        _options.$parent.contentWindow = _options.$parent
+        options.$parent.contentWindow = options.$parent
       }
 
       // if we cannot parse an integer out of duration
       // which could be 500 or "500", then it's NaN...throw
-      if (isNaNOrInfinity(_options.duration)) {
-        $errUtils.throwErrByPath('scrollIntoView.invalid_duration', { args: { duration: _options.duration } })
+      if (isNaNOrInfinity(options.duration)) {
+        $errUtils.throwErrByPath('scrollIntoView.invalid_duration', { args: { duration: options.duration } })
       }
 
-      if (!((_options.easing === 'swing') || (_options.easing === 'linear'))) {
-        $errUtils.throwErrByPath('scrollIntoView.invalid_easing', { args: { easing: _options.easing } })
+      if (!((options.easing === 'swing') || (options.easing === 'linear'))) {
+        $errUtils.throwErrByPath('scrollIntoView.invalid_easing', { args: { easing: options.easing } })
       }
 
-      if (_options.log) {
-        deltaOptions = $utils.filterOutOptions(_options, { duration: 0, easing: 'swing', offset: { left: 0, top: 0 } })
+      if (options.log) {
+        deltaOptions = $utils.filterOutOptions(options, { duration: 0, easing: 'swing', offset: { left: 0, top: 0 } })
 
         const log = {
-          $el: _options.$el,
+          $el: options.$el,
           message: deltaOptions,
-          timeout: _options.timeout,
+          timeout: options.timeout,
           consoleProps () {
             const obj = {
               // merge into consoleProps without mutating it
-              'Applied To': $dom.getElements(_options.$el),
-              'Scrolled Element': $dom.getElements(_options.$el),
+              'Applied To': $dom.getElements(options.$el),
+              'Scrolled Element': $dom.getElements(options.$el),
             }
 
             return obj
           },
         }
 
-        _options._log = Cypress.log(log)
+        options._log = Cypress.log(log)
       }
 
       if (!parentIsWin) {
         // scroll the parent into view first
         // before attemp
-        _options.$parent[0].scrollIntoView()
+        options.$parent[0].scrollIntoView()
       }
 
       const scrollIntoView = () => {
         return new Promise((resolve, reject) => {
           // scroll our axes
-          return $(_options.$parent).scrollTo(_options.$el, {
-            axis: _options.axis,
-            easing: _options.easing,
-            duration: _options.duration,
-            offset: _options.offset,
+          return $(options.$parent).scrollTo(options.$el, {
+            axis: options.axis,
+            easing: options.easing,
+            duration: options.duration,
+            offset: options.offset,
             done () {
-              return resolve(_options.$el)
+              return resolve(options.$el)
             },
             fail () {
               // its Promise object is rejected
@@ -147,7 +147,7 @@ export default (Commands, Cypress, cy, state) => {
             },
             always () {
               if (parentIsWin) {
-                delete _options.$parent.contentWindow
+                delete options.$parent.contentWindow
               }
             },
           })
@@ -157,7 +157,7 @@ export default (Commands, Cypress, cy, state) => {
       return scrollIntoView()
       .then(() => {
         const verifyAssertions = () => {
-          return cy.verifyUpcomingAssertions(_options.$el, _options, {
+          return cy.verifyUpcomingAssertions(options.$el, options, {
             onRetry: verifyAssertions,
           })
         }
@@ -168,9 +168,8 @@ export default (Commands, Cypress, cy, state) => {
   })
 
   Commands.addAll({ prevSubject: ['optional', 'element', 'window'] }, {
-    scrollTo (subject, xOrPosition, yOrOptions, options: Partial<Cypress.ScrollToOptions> = {}) {
+    scrollTo (subject, xOrPosition, yOrOptions, userOptions: Partial<Cypress.ScrollToOptions> = {}) {
       let x; let y
-      let userOptions = options
 
       // check for undefined or null values
       if (xOrPosition === undefined || xOrPosition === null) {
@@ -271,7 +270,7 @@ export default (Commands, Cypress, cy, state) => {
         $errUtils.throwErrByPath('scrollTo.multiple_containers', { args: { num: $container.length } })
       }
 
-      const _options: InternalScrollToOptions = _.defaults({}, userOptions, {
+      const options: InternalScrollToOptions = _.defaults({}, userOptions, {
         $el: $container,
         log: true,
         duration: 0,
@@ -284,28 +283,28 @@ export default (Commands, Cypress, cy, state) => {
 
       // if we cannot parse an integer out of duration
       // which could be 500 or "500", then it's NaN...throw
-      if (isNaNOrInfinity(_options.duration)) {
-        $errUtils.throwErrByPath('scrollTo.invalid_duration', { args: { duration: _options.duration } })
+      if (isNaNOrInfinity(options.duration)) {
+        $errUtils.throwErrByPath('scrollTo.invalid_duration', { args: { duration: options.duration } })
       }
 
-      if (!((_options.easing === 'swing') || (_options.easing === 'linear'))) {
-        $errUtils.throwErrByPath('scrollTo.invalid_easing', { args: { easing: _options.easing } })
+      if (!((options.easing === 'swing') || (options.easing === 'linear'))) {
+        $errUtils.throwErrByPath('scrollTo.invalid_easing', { args: { easing: options.easing } })
       }
 
-      if (!_.isBoolean(_options.ensureScrollable)) {
-        $errUtils.throwErrByPath('scrollTo.invalid_ensureScrollable', { args: { ensureScrollable: _options.ensureScrollable } })
+      if (!_.isBoolean(options.ensureScrollable)) {
+        $errUtils.throwErrByPath('scrollTo.invalid_ensureScrollable', { args: { ensureScrollable: options.ensureScrollable } })
       }
 
       // if we cannot parse an integer out of y or x
       // which could be 50 or "50px" or "50%" then
       // it's NaN/Infinity...throw
-      if (isNaNOrInfinity(_options.y) || isNaNOrInfinity(_options.x)) {
+      if (isNaNOrInfinity(options.y) || isNaNOrInfinity(options.x)) {
         $errUtils.throwErrByPath('scrollTo.invalid_target', { args: { x, y } })
       }
 
-      if (_options.log) {
+      if (options.log) {
         const deltaOptions = $utils.stringify(
-          $utils.filterOutOptions(_options, { duration: 0, easing: 'swing' }),
+          $utils.filterOutOptions(options, { duration: 0, easing: 'swing' }),
         )
 
         const messageArgs: string[] = []
@@ -323,7 +322,7 @@ export default (Commands, Cypress, cy, state) => {
 
         const log: Record<string, any> = {
           message: messageArgs.join(', '),
-          timeout: _options.timeout,
+          timeout: options.timeout,
           consoleProps () {
             // merge into consoleProps without mutating it
             const obj: Record<string, any> = {}
@@ -339,23 +338,23 @@ export default (Commands, Cypress, cy, state) => {
               obj.Options = deltaOptions
             }
 
-            obj['Scrolled Element'] = $dom.getElements(_options.$el)
+            obj['Scrolled Element'] = $dom.getElements(options.$el)
 
             return obj
           },
         }
 
         if (!isWin) {
-          log.$el = _options.$el
+          log.$el = options.$el
         }
 
-        _options._log = Cypress.log(log)
+        options._log = Cypress.log(log)
       }
 
       const ensureScrollability = () => {
         // Some elements are not scrollable, user may opt out of error checking
         // https://github.com/cypress-io/cypress/issues/1924
-        if (!_options.ensureScrollable) {
+        if (!options.ensureScrollable) {
           return
         }
 
@@ -363,25 +362,25 @@ export default (Commands, Cypress, cy, state) => {
           // make sure our container can even be scrolled
           return cy.ensureScrollability($container, 'scrollTo')
         } catch (err) {
-          _options.error = err
+          options.error = err
 
-          return cy.retry(ensureScrollability, _options)
+          return cy.retry(ensureScrollability, options)
         }
       }
 
       const scrollTo = () => {
         return new Promise((resolve, reject) => {
           // scroll our axis
-          $(_options.$el).scrollTo({ left: x, top: y }, {
-            axis: _options.axis,
-            easing: _options.easing,
-            duration: _options.duration,
+          $(options.$el).scrollTo({ left: x, top: y }, {
+            axis: options.axis,
+            easing: options.easing,
+            duration: options.duration,
             // TODO: ensureScrollable option does not exist on jQuery or config/jquery.scrollto.ts.
             // It can be removed.
             // @ts-ignore
-            ensureScrollable: _options.ensureScrollable,
+            ensureScrollable: options.ensureScrollable,
             done () {
-              return resolve(_options.$el)
+              return resolve(options.$el)
             },
             fail () {
               // its Promise object is rejected
@@ -394,7 +393,7 @@ export default (Commands, Cypress, cy, state) => {
           })
 
           if (isWin) {
-            delete _options.$el.contentWindow
+            delete options.$el.contentWindow
           }
         })
       }
@@ -404,7 +403,7 @@ export default (Commands, Cypress, cy, state) => {
       .then(scrollTo)
       .then(() => {
         const verifyAssertions = () => {
-          return cy.verifyUpcomingAssertions(_options.$el, _options, {
+          return cy.verifyUpcomingAssertions(options.$el, options, {
             onRetry: verifyAssertions,
           })
         }
diff --git a/packages/driver/src/cy/commands/actions/select.ts b/packages/driver/src/cy/commands/actions/select.ts
index 2fa7ba4d117a..cb5972960206 100644
--- a/packages/driver/src/cy/commands/actions/select.ts
+++ b/packages/driver/src/cy/commands/actions/select.ts
@@ -16,7 +16,7 @@ interface InternalSelectOptions extends Partial<Cypress.SelectOptions> {
 
 export default (Commands, Cypress, cy) => {
   Commands.addAll({ prevSubject: 'element' }, {
-    select (subject, valueOrTextOrIndex, options: Partial<Cypress.SelectOptions> = {}) {
+    select (subject, valueOrTextOrIndex, userOptions: Partial<Cypress.SelectOptions> = {}) {
       if (
         !_.isNumber(valueOrTextOrIndex)
         && !_.isString(valueOrTextOrIndex)
@@ -33,7 +33,7 @@ export default (Commands, Cypress, cy) => {
         $errUtils.throwErrByPath('select.invalid_array_argument', { args: { value: JSON.stringify(valueOrTextOrIndex) } })
       }
 
-      const _options: InternalSelectOptions = _.defaults({}, options, {
+      const options: InternalSelectOptions = _.defaults({}, userOptions, {
         $el: subject,
         log: true,
         force: false,
@@ -41,24 +41,24 @@ export default (Commands, Cypress, cy) => {
 
       const consoleProps: Record<string, any> = {}
 
-      if (_options.log) {
+      if (options.log) {
         // figure out the options which actually change the behavior of clicks
-        const deltaOptions = $utils.filterOutOptions(_options)
+        const deltaOptions = $utils.filterOutOptions(options)
 
-        _options._log = Cypress.log({
+        options._log = Cypress.log({
           message: deltaOptions,
-          $el: _options.$el,
-          timeout: _options.timeout,
+          $el: options.$el,
+          timeout: options.timeout,
           consoleProps () {
             // merge into consoleProps without mutating it
             return _.extend({}, consoleProps, {
-              'Applied To': $dom.getElements(_options.$el),
+              'Applied To': $dom.getElements(options.$el),
               'Options': deltaOptions,
             })
           },
         })
 
-        _options._log.snapshot('before', { next: 'after' })
+        options._log.snapshot('before', { next: 'after' })
       }
 
       let node
@@ -74,13 +74,13 @@ export default (Commands, Cypress, cy) => {
       // or texts and clear the previous selections which matches jQuery's
       // behavior
 
-      if (!_options.$el.is('select')) {
-        node = $dom.stringify(_options.$el)
+      if (!options.$el.is('select')) {
+        node = $dom.stringify(options.$el)
         $errUtils.throwErrByPath('select.invalid_element', { args: { node } })
       }
 
-      if (_options.$el.length && _options.$el.length > 1) {
-        $errUtils.throwErrByPath('select.multiple_elements', { args: { num: _options.$el.length } })
+      if (options.$el.length && options.$el.length > 1) {
+        $errUtils.throwErrByPath('select.multiple_elements', { args: { num: options.$el.length } })
       }
 
       // normalize valueOrTextOrIndex if its not an array
@@ -95,7 +95,7 @@ export default (Commands, Cypress, cy) => {
         return _.isNumber(v) ? v : v.replace(/&nbsp;/g, '\u00a0')
       })
 
-      const multiple = _options.$el.prop('multiple')
+      const multiple = options.$el.prop('multiple')
 
       // throw if we're not a multiple select and we've
       // passed an array of values
@@ -107,14 +107,14 @@ export default (Commands, Cypress, cy) => {
         let notAllUniqueValues
 
         // throw if <select> is disabled
-        if (!_options.force && _options.$el.prop('disabled')) {
-          node = $dom.stringify(_options.$el)
+        if (!options.force && options.$el.prop('disabled')) {
+          node = $dom.stringify(options.$el)
           $errUtils.throwErrByPath('select.disabled', { args: { node } })
         }
 
         const values: string[] = []
         const optionEls: JQuery<any>[] = []
-        const optionsObjects = _options.$el.find('option').map((index, el) => {
+        const optionsObjects = options.$el.find('option').map((index, el) => {
           // push the value in values array if its
           // found within the valueOrText
           const value = $elements.getNativeProp(el, 'value')
@@ -198,9 +198,9 @@ export default (Commands, Cypress, cy) => {
         return Promise
         .try(getOptions)
         .catch((err) => {
-          _options.error = err
+          options.error = err
 
-          return cy.retry(retryOptions, _options)
+          return cy.retry(retryOptions, options)
         })
       }
 
@@ -212,15 +212,15 @@ export default (Commands, Cypress, cy) => {
         // preserve the selected values
         consoleProps.Selected = values
 
-        return cy.now('click', _options.$el, {
-          $el: _options.$el,
+        return cy.now('click', options.$el, {
+          $el: options.$el,
           log: false,
           verify: false,
           errorOnSelect: false, // prevent click errors since we want the select to be clicked
-          _log: _options._log,
-          force: _options.force,
-          timeout: _options.timeout,
-          interval: _options.interval,
+          _log: options._log,
+          force: options.force,
+          timeout: options.timeout,
+          interval: options.interval,
         }).then(() => {
           // TODO:
           // 1. test cancelation
@@ -231,11 +231,11 @@ export default (Commands, Cypress, cy) => {
           // 6. test that option actually receives click event
           // 7. test that select still has focus (i think it already does have a test)
           // 8. test that multiple=true selects receive option event for each selected option
-          const activeElement = $elements.getActiveElByDocument(_options.$el)
+          const activeElement = $elements.getActiveElByDocument(options.$el)
 
-          if (!_options.force && activeElement === null) {
-            const node = $dom.stringify(_options.$el)
-            const onFail = _options._log
+          if (!options.force && activeElement === null) {
+            const node = $dom.stringify(options.$el)
+            const onFail = options._log
 
             $errUtils.throwErrByPath('select.disabled', {
               onFail,
@@ -251,11 +251,11 @@ export default (Commands, Cypress, cy) => {
               log: false,
               verify: false,
               force: true, // always force the click to happen on the <option>
-              timeout: _options.timeout,
-              interval: _options.interval,
+              timeout: options.timeout,
+              interval: options.interval,
             })
           }).then(() => {
-            const oldValue = _options.$el[0].selectedIndex
+            const oldValue = options.$el[0].selectedIndex
 
             // reset the selects value after we've
             // fired all the proper click events
@@ -263,7 +263,7 @@ export default (Commands, Cypress, cy) => {
             // TODO: shouldn't we be updating the values
             // as we click the <option> instead of
             // all afterwards?
-            _options.$el.val(values)
+            options.$el.val(values)
 
             if (notAllUniqueValues) {
               // if all the values are the same and the user is trying to
@@ -281,12 +281,12 @@ export default (Commands, Cypress, cy) => {
                 return $el.prop('selected', 'selected')
               })
 
-              _options.$el[0].selectedIndex = selectedIndex
+              options.$el[0].selectedIndex = selectedIndex
             }
 
             // https://github.com/cypress-io/cypress/issues/19494
             // When user selects the same option again, `input`, `change` events should not be fired.
-            if (_options.$el[0].selectedIndex === oldValue) {
+            if (options.$el[0].selectedIndex === oldValue) {
               return
             }
 
@@ -295,7 +295,7 @@ export default (Commands, Cypress, cy) => {
               cancelable: false,
             })
 
-            _options.$el.get(0).dispatchEvent(input)
+            options.$el.get(0).dispatchEvent(input)
 
             // yup manually create this change event
             // 1.6.5. HTML event types
@@ -304,11 +304,11 @@ export default (Commands, Cypress, cy) => {
 
             change.initEvent('change', true, false)
 
-            _options.$el.get(0).dispatchEvent(change)
+            options.$el.get(0).dispatchEvent(change)
           })
         }).then(() => {
           const verifyAssertions = () => {
-            return cy.verifyUpcomingAssertions(_options.$el, _options, {
+            return cy.verifyUpcomingAssertions(options.$el, options, {
               onRetry: verifyAssertions,
             })
           }
diff --git a/packages/driver/src/cy/commands/actions/submit.ts b/packages/driver/src/cy/commands/actions/submit.ts
index a16c6223a272..dcacdb60de8a 100644
--- a/packages/driver/src/cy/commands/actions/submit.ts
+++ b/packages/driver/src/cy/commands/actions/submit.ts
@@ -13,8 +13,8 @@ interface InternalSubmitOptions extends Partial<Cypress.Loggable & Cypress.Timeo
 
 export default (Commands, Cypress, cy) => {
   Commands.addAll({ prevSubject: 'element' }, {
-    submit (subject, options: Partial<Cypress.Loggable & Cypress.Timeoutable> = {}) {
-      const _options: InternalSubmitOptions = _.defaults({}, options, {
+    submit (subject, userOptions: Partial<Cypress.Loggable & Cypress.Timeoutable> = {}) {
+      const options: InternalSubmitOptions = _.defaults({}, userOptions, {
         log: true,
         $el: subject,
       })
@@ -23,37 +23,37 @@ export default (Commands, Cypress, cy) => {
       // to break when they need to be triggered synchronously
       // like with type {enter}.  either convert type to a promise
       // to just create a synchronous submit function
-      const form = _options.$el.get(0)
+      const form = options.$el.get(0)
 
-      if (_options.log) {
-        _options._log = Cypress.log({
-          $el: _options.$el,
-          timeout: _options.timeout,
+      if (options.log) {
+        options._log = Cypress.log({
+          $el: options.$el,
+          timeout: options.timeout,
           consoleProps () {
             return {
-              'Applied To': $dom.getElements(_options.$el),
-              Elements: _options.$el.length,
+              'Applied To': $dom.getElements(options.$el),
+              Elements: options.$el.length,
             }
           },
         })
 
-        _options._log.snapshot('before', { next: 'after' })
+        options._log.snapshot('before', { next: 'after' })
       }
 
-      if (!_options.$el.is('form')) {
-        const node = $dom.stringify(_options.$el)
-        const word = $utils.plural(_options.$el, 'contains', 'is')
+      if (!options.$el.is('form')) {
+        const node = $dom.stringify(options.$el)
+        const word = $utils.plural(options.$el, 'contains', 'is')
 
         $errUtils.throwErrByPath('submit.not_on_form', {
-          onFail: _options._log,
+          onFail: options._log,
           args: { node, word },
         })
       }
 
-      if (_options.$el.length && _options.$el.length > 1) {
+      if (options.$el.length && options.$el.length > 1) {
         $errUtils.throwErrByPath('submit.multiple_forms', {
-          onFail: _options._log,
-          args: { num: _options.$el.length },
+          onFail: options._log,
+          args: { num: options.$el.length },
         })
       }
 
@@ -75,7 +75,7 @@ export default (Commands, Cypress, cy) => {
       .delay($actionability.delay, 'submit')
       .then(() => {
         const verifyAssertions = () => {
-          return cy.verifyUpcomingAssertions(_options.$el, _options, {
+          return cy.verifyUpcomingAssertions(options.$el, options, {
             onRetry: verifyAssertions,
           })
         }
diff --git a/packages/driver/src/cy/commands/actions/type.ts b/packages/driver/src/cy/commands/actions/type.ts
index d8ba837b92f5..206de7fe84c4 100644
--- a/packages/driver/src/cy/commands/actions/type.ts
+++ b/packages/driver/src/cy/commands/actions/type.ts
@@ -27,13 +27,12 @@ interface InternalClearOptions extends Partial<Cypress.ClearOptions> {
 export default function (Commands, Cypress, cy, state, config) {
   const { keyboard } = cy.devices
 
-  function type (subject, chars, options: Partial<Cypress.TypeOptions> = {}) {
-    const userOptions = options
+  function type (subject, chars, userOptions: Partial<Cypress.TypeOptions> = {}) {
     let updateTable
 
     // allow the el we're typing into to be
     // changed by options -- used by cy.clear()
-    const _options: InternalTypeOptions = _.defaults({}, userOptions, {
+    const options: InternalTypeOptions = _.defaults({}, userOptions, {
       $el: subject,
       log: true,
       verify: true,
@@ -45,9 +44,9 @@ export default function (Commands, Cypress, cy, state, config) {
       animationDistanceThreshold: config('animationDistanceThreshold'),
     })
 
-    if (_options.log) {
+    if (options.log) {
       // figure out the options which actually change the behavior of clicks
-      const deltaOptions = $utils.filterOutOptions(_options)
+      const deltaOptions = $utils.filterOutOptions(options)
 
       const table = {}
 
@@ -96,14 +95,14 @@ export default function (Commands, Cypress, cy, state, config) {
         , {})
       }
 
-      _options._log = Cypress.log({
+      options._log = Cypress.log({
         message: [chars, deltaOptions],
-        $el: _options.$el,
-        timeout: _options.timeout,
+        $el: options.$el,
+        timeout: options.timeout,
         consoleProps () {
           return {
             'Typed': chars,
-            'Applied To': $dom.getElements(_options.$el),
+            'Applied To': $dom.getElements(options.$el),
             'Options': deltaOptions,
             'table': {
               // mouse events tables will take up slot 1 if they're present
@@ -119,26 +118,26 @@ export default function (Commands, Cypress, cy, state, config) {
         },
       })
 
-      _options._log.snapshot('before', { next: 'after' })
+      options._log.snapshot('before', { next: 'after' })
     }
 
-    if (_options.$el.length > 1) {
+    if (options.$el.length > 1) {
       $errUtils.throwErrByPath('type.multiple_elements', {
-        onFail: _options._log,
-        args: { num: _options.$el.length },
+        onFail: options._log,
+        args: { num: options.$el.length },
       })
     }
 
     if (!(_.isString(chars) || _.isFinite(chars))) {
       $errUtils.throwErrByPath('type.wrong_type', {
-        onFail: _options._log,
+        onFail: options._log,
         args: { chars },
       })
     }
 
     if (_.isString(chars) && _.isEmpty(chars)) {
       $errUtils.throwErrByPath('type.empty_string', {
-        onFail: _options._log,
+        onFail: options._log,
         args: { chars },
       })
     }
@@ -149,7 +148,7 @@ export default function (Commands, Cypress, cy, state, config) {
 
     if (isInvalidDelay(userOptions.delay)) {
       $errUtils.throwErrByPath('keyboard.invalid_delay', {
-        onFail: _options._log,
+        onFail: options._log,
         args: {
           cmd: 'type',
           docsPath: 'type',
@@ -162,7 +161,7 @@ export default function (Commands, Cypress, cy, state, config) {
     // specific error if test config keystrokeDelay is invalid
     if (isInvalidDelay(config('keystrokeDelay'))) {
       $errUtils.throwErrByPath('keyboard.invalid_per_test_delay', {
-        onFail: _options._log,
+        onFail: options._log,
         args: { delay: config('keystrokeDelay') },
       })
     }
@@ -184,7 +183,7 @@ export default function (Commands, Cypress, cy, state, config) {
 
     const type = function () {
       const simulateSubmitHandler = function () {
-        const form = _options.$el.parents('form')
+        const form = options.$el.parents('form')
 
         if (!form.length) {
           return
@@ -281,8 +280,8 @@ export default function (Commands, Cypress, cy, state, config) {
       // see comment in updateValue below
       let typed = ''
 
-      const isContentEditable = $elements.isContentEditable(_options.$el.get(0))
-      const isTextarea = $elements.isTextarea(_options.$el.get(0))
+      const isContentEditable = $elements.isContentEditable(options.$el.get(0))
+      const isTextarea = $elements.isTextarea(options.$el.get(0))
 
       const fireClickEvent = (el) => {
         const ctor = $dom.getDocumentFromElement(el).defaultView!.PointerEvent
@@ -294,14 +293,14 @@ export default function (Commands, Cypress, cy, state, config) {
       let keydownEvents: any[] = []
 
       return keyboard.type({
-        $el: _options.$el,
+        $el: options.$el,
         chars,
-        delay: _options.delay,
-        release: _options.release,
-        parseSpecialCharSequences: _options.parseSpecialCharSequences,
+        delay: options.delay,
+        release: options.release,
+        parseSpecialCharSequences: options.parseSpecialCharSequences,
         window: win,
-        force: _options.force,
-        onFail: _options._log,
+        force: options.force,
+        onFail: options._log,
 
         updateValue (el, key, charsToType) {
           // in these cases, the value must only be set after all
@@ -319,7 +318,7 @@ export default function (Commands, Cypress, cy, state, config) {
         },
 
         onAfterType () {
-          if (_options.release === true) {
+          if (options.release === true) {
             state('keyboardModifiers', null)
           }
         },
@@ -328,8 +327,8 @@ export default function (Commands, Cypress, cy, state, config) {
           // for the total number of keys we're about to
           // type, ensure we raise the timeout to account
           // for the delay being added to each keystroke
-          if (_options.delay) {
-            return cy.timeout(totalKeys * _options.delay, true, 'type')
+          if (options.delay) {
+            return cy.timeout(totalKeys * options.delay, true, 'type')
           }
         },
 
@@ -434,11 +433,11 @@ export default function (Commands, Cypress, cy, state, config) {
 
         onNoMatchingSpecialChars (chars, allChars) {
           if (chars === 'tab') {
-            $errUtils.throwErrByPath('type.tab', { onFail: _options._log })
+            $errUtils.throwErrByPath('type.tab', { onFail: options._log })
           }
 
           $errUtils.throwErrByPath('type.invalid', {
-            onFail: _options._log,
+            onFail: options._log,
             args: { chars: `{${chars}}`, allChars },
           })
         },
@@ -448,7 +447,7 @@ export default function (Commands, Cypress, cy, state, config) {
     const handleFocused = function () {
       // if it's the body, don't need to worry about focus
       // (unless it can be modified i.e we're in designMode or contenteditable)
-      const isBody = _options.$el.is('body') && !$elements.isContentEditable(_options.$el[0])
+      const isBody = options.$el.is('body') && !$elements.isContentEditable(options.$el[0])
 
       if (isBody) {
         debug('typing into body')
@@ -456,7 +455,7 @@ export default function (Commands, Cypress, cy, state, config) {
         return type()
       }
 
-      _options.ensure = {
+      options.ensure = {
         position: true,
         visibility: true,
         notDisabled: true,
@@ -470,14 +469,14 @@ export default function (Commands, Cypress, cy, state, config) {
       // and seeing if that is focused
       // Checking first if element is focusable accounts for focusable els inside
       // of contenteditables
-      if ($elements.isFocusedOrInFocused(_options.$el.get(0))) {
+      if ($elements.isFocusedOrInFocused(options.$el.get(0))) {
         debug('element is already focused, only checking readOnly property')
-        _options.ensure = {
+        options.ensure = {
           notReadonly: true,
         }
       }
 
-      return $actionability.verify(cy, _options.$el, config, _options, {
+      return $actionability.verify(cy, options.$el, config, options, {
         onScroll ($el, type) {
           return Cypress.action('cy:scrolled', $el, type)
         },
@@ -499,19 +498,19 @@ export default function (Commands, Cypress, cy, state, config) {
             $el: $elToClick,
             log: false,
             verify: false,
-            _log: _options._log,
+            _log: options._log,
             force: true, // force the click, avoid waiting
-            timeout: _options.timeout,
-            interval: _options.interval,
+            timeout: options.timeout,
+            interval: options.interval,
             errorOnSelect: false,
-            scrollBehavior: _options.scrollBehavior,
+            scrollBehavior: options.scrollBehavior,
           })
           .then(() => {
             let activeElement = $elements.getActiveElByDocument($elToClick)
 
-            if (!_options.force && activeElement === null) {
+            if (!options.force && activeElement === null) {
               const node = $dom.stringify($elToClick)
-              const onFail = _options._log
+              const onFail = options._log
 
               if ($dom.isTextLike($elToClick[0])) {
                 $errUtils.throwErrByPath('type.not_actionable_textlike', {
@@ -542,12 +541,12 @@ export default function (Commands, Cypress, cy, state, config) {
         // command which consume cy.type may
         // want to handle verification themselves
 
-        if (_options.verify === false) {
-          return _options.$el
+        if (options.verify === false) {
+          return options.$el
         }
 
         const verifyAssertions = () => {
-          return cy.verifyUpcomingAssertions(_options.$el, _options, {
+          return cy.verifyUpcomingAssertions(options.$el, options, {
             onRetry: verifyAssertions,
           })
         }
@@ -557,8 +556,8 @@ export default function (Commands, Cypress, cy, state, config) {
     })
   }
 
-  function clear (subject, options: Partial<Cypress.ClearOptions> = {}) {
-    const _options: InternalClearOptions = _.defaults({}, options, {
+  function clear (subject, userOptions: Partial<Cypress.ClearOptions> = {}) {
+    const options: InternalClearOptions = _.defaults({}, userOptions, {
       log: true,
       force: false,
       waitForAnimations: config('waitForAnimations'),
@@ -570,14 +569,14 @@ export default function (Commands, Cypress, cy, state, config) {
     const clear = function (el) {
       const $el = $dom.wrap(el)
 
-      if (_options.log) {
+      if (options.log) {
         // figure out the options which actually change the behavior of clicks
-        const deltaOptions = $utils.filterOutOptions(_options)
+        const deltaOptions = $utils.filterOutOptions(options)
 
-        _options._log = Cypress.log({
+        options._log = Cypress.log({
           message: deltaOptions,
           $el,
-          timeout: _options.timeout,
+          timeout: options.timeout,
           consoleProps () {
             return {
               'Applied To': $dom.getElements($el),
@@ -593,16 +592,16 @@ export default function (Commands, Cypress, cy, state, config) {
           $el,
           log: false,
           verify: false, // handle verification ourselves
-          _log: _options._log,
-          force: _options.force,
-          timeout: _options.timeout,
-          interval: _options.interval,
-          waitForAnimations: _options.waitForAnimations,
-          animationDistanceThreshold: _options.animationDistanceThreshold,
-          scrollBehavior: _options.scrollBehavior,
+          _log: options._log,
+          force: options.force,
+          timeout: options.timeout,
+          interval: options.interval,
+          waitForAnimations: options.waitForAnimations,
+          animationDistanceThreshold: options.animationDistanceThreshold,
+          scrollBehavior: options.scrollBehavior,
         }).then(() => {
-          if (_options._log) {
-            _options._log.snapshot().end()
+          if (options._log) {
+            options._log.snapshot().end()
           }
 
           return null
@@ -614,13 +613,13 @@ export default function (Commands, Cypress, cy, state, config) {
         const word = $utils.plural(subject, 'contains', 'is')
 
         $errUtils.throwErrByPath('clear.invalid_element', {
-          onFail: _options._log,
+          onFail: options._log,
           args: { word, node },
         })
       }
 
       if (!$dom.isTextLike($el.get(0))) {
-        _options.ensure = {
+        options.ensure = {
           position: true,
           visibility: true,
           notDisabled: true,
@@ -629,7 +628,7 @@ export default function (Commands, Cypress, cy, state, config) {
           notReadonly: true,
         }
 
-        return $actionability.verify(cy, $el, config, _options, {
+        return $actionability.verify(cy, $el, config, options, {
           onScroll ($el, type) {
             return Cypress.action('cy:scrolled', $el, type)
           },
@@ -637,7 +636,7 @@ export default function (Commands, Cypress, cy, state, config) {
           onReady ($elToClick) {
             let activeElement = $elements.getActiveElByDocument($elToClick)
 
-            if (!_options.force && activeElement === null || !$dom.isTextLike($elToClick.get(0))) {
+            if (!options.force && activeElement === null || !$dom.isTextLike($elToClick.get(0))) {
               throwError($el)
             }
 
@@ -654,7 +653,7 @@ export default function (Commands, Cypress, cy, state, config) {
     .each(clear)
     .then(() => {
       const verifyAssertions = () => {
-        return cy.verifyUpcomingAssertions(subject, _options, {
+        return cy.verifyUpcomingAssertions(subject, options, {
           onRetry: verifyAssertions,
         })
       }
diff --git a/packages/driver/src/cy/commands/angular.ts b/packages/driver/src/cy/commands/angular.ts
index 1c7a15887873..76d4536c2b05 100644
--- a/packages/driver/src/cy/commands/angular.ts
+++ b/packages/driver/src/cy/commands/angular.ts
@@ -93,7 +93,7 @@ export default (Commands, Cypress, cy, state) => {
   }
 
   Commands.addAll({
-    ng (type, selector, options: Partial<Cypress.Loggable & Cypress.Timeoutable> = {}) {
+    ng (type, selector, userOptions: Partial<Cypress.Loggable & Cypress.Timeoutable> = {}) {
       // what about requirejs / browserify?
       // we need to intelligently check to see if we're using those
       // and if angular is available through them.  throw a very specific
@@ -103,21 +103,21 @@ export default (Commands, Cypress, cy, state) => {
         $errUtils.throwErrByPath('ng.no_global')
       }
 
-      const _options: InternalNgOptions = _.defaults({}, options, { log: true })
+      const options: InternalNgOptions = _.defaults({}, userOptions, { log: true })
 
-      if (_options.log) {
-        _options._log = Cypress.log({
-          timeout: _options.timeout,
+      if (options.log) {
+        options._log = Cypress.log({
+          timeout: options.timeout,
         })
       }
 
       switch (type) {
         case 'model':
-          return findByNgAttr('model', 'model=', selector, _options)
+          return findByNgAttr('model', 'model=', selector, options)
         case 'repeater':
-          return findByNgAttr('repeater', 'repeat*=', selector, _options)
+          return findByNgAttr('repeater', 'repeat*=', selector, options)
         case 'binding':
-          return findByNgBinding(selector, _options)
+          return findByNgBinding(selector, options)
         default:
           return
       }
diff --git a/packages/driver/src/cy/commands/cookies.ts b/packages/driver/src/cy/commands/cookies.ts
index 73020ca2231a..8a07c0080e3b 100644
--- a/packages/driver/src/cy/commands/cookies.ts
+++ b/packages/driver/src/cy/commands/cookies.ts
@@ -188,21 +188,21 @@ export default function (Commands, Cypress, cy, state, config) {
   })
 
   return Commands.addAll({
-    getCookie (name, options: Partial<Cypress.Loggable & Cypress.Timeoutable> = {}) {
-      const _options: InternalGetCookieOptions = _.defaults({}, options, {
+    getCookie (name, userOptions: Partial<Cypress.Loggable & Cypress.Timeoutable> = {}) {
+      const options: InternalGetCookieOptions = _.defaults({}, userOptions, {
         log: true,
         timeout: config('responseTimeout'),
       })
 
-      if (_options.log) {
-        _options._log = Cypress.log({
+      if (options.log) {
+        options._log = Cypress.log({
           message: name,
-          timeout: _options.timeout,
+          timeout: options.timeout,
           consoleProps () {
             let c
             const obj = {}
 
-            c = _options.cookie
+            c = options.cookie
 
             if (c) {
               obj['Yielded'] = c
@@ -216,37 +216,37 @@ export default function (Commands, Cypress, cy, state, config) {
         })
       }
 
-      const onFail = _options._log
+      const onFail = options._log
 
       if (!_.isString(name)) {
         $errUtils.throwErrByPath('getCookie.invalid_argument', { onFail })
       }
 
-      return automateCookies('get:cookie', { name }, _options._log, _options.timeout)
+      return automateCookies('get:cookie', { name }, options._log, options.timeout)
       .then(pickCookieProps)
       .then((resp) => {
-        _options.cookie = resp
+        options.cookie = resp
 
         return resp
       })
       .catch(handleBackendError('getCookie', 'reading the requested cookie from', onFail))
     },
 
-    getCookies (options: Partial<Cypress.Loggable & Cypress.Timeoutable> = {}) {
-      const _options: InternalGetCookiesOptions = _.defaults({}, options, {
+    getCookies (userOptions: Partial<Cypress.Loggable & Cypress.Timeoutable> = {}) {
+      const options: InternalGetCookiesOptions = _.defaults({}, userOptions, {
         log: true,
         timeout: config('responseTimeout'),
       })
 
-      if (_options.log) {
-        _options._log = Cypress.log({
+      if (options.log) {
+        options._log = Cypress.log({
           message: '',
-          timeout: _options.timeout,
+          timeout: options.timeout,
           consoleProps () {
             let c
             const obj = {}
 
-            c = _options.cookies
+            c = options.cookies
 
             if (c) {
               obj['Yielded'] = c
@@ -258,18 +258,18 @@ export default function (Commands, Cypress, cy, state, config) {
         })
       }
 
-      return automateCookies('get:cookies', _.pick(_options, 'domain'), _options._log, _options.timeout)
+      return automateCookies('get:cookies', _.pick(options, 'domain'), options._log, options.timeout)
       .then(pickCookieProps)
       .then((resp) => {
-        _options.cookies = resp
+        options.cookies = resp
 
         return resp
       })
-      .catch(handleBackendError('getCookies', 'reading cookies from', _options._log))
+      .catch(handleBackendError('getCookies', 'reading cookies from', options._log))
     },
 
-    setCookie (name, value, options: Partial<Cypress.SetCookieOptions> = {}) {
-      const _options: InternalSetCookieOptions = _.defaults({}, options, {
+    setCookie (name, value, userOptions: Partial<Cypress.SetCookieOptions> = {}) {
+      const options: InternalSetCookieOptions = _.defaults({}, userOptions, {
         name,
         value,
         path: '/',
@@ -280,17 +280,17 @@ export default function (Commands, Cypress, cy, state, config) {
         timeout: config('responseTimeout'),
       })
 
-      const cookie = pickCookieProps(_options)
+      const cookie = pickCookieProps(options)
 
-      if (_options.log) {
-        _options._log = Cypress.log({
+      if (options.log) {
+        options._log = Cypress.log({
           message: [name, value],
-          timeout: _options.timeout,
+          timeout: options.timeout,
           consoleProps () {
             let c
             const obj = {}
 
-            c = _options.cookie
+            c = options.cookie
 
             if (c) {
               obj['Yielded'] = c
@@ -301,7 +301,7 @@ export default function (Commands, Cypress, cy, state, config) {
         })
       }
 
-      const onFail = _options._log
+      const onFail = options._log
 
       cookie.sameSite = normalizeSameSite(cookie.sameSite)
 
@@ -309,7 +309,7 @@ export default function (Commands, Cypress, cy, state, config) {
         $errUtils.throwErrByPath('setCookie.invalid_samesite', {
           onFail,
           args: {
-            value: _options.sameSite, // for clarity, throw the error with the user's unnormalized option
+            value: options.sameSite, // for clarity, throw the error with the user's unnormalized option
             validValues: VALID_SAMESITE_VALUES,
           },
         })
@@ -321,7 +321,7 @@ export default function (Commands, Cypress, cy, state, config) {
         $errUtils.throwErrByPath('setCookie.secure_not_set_with_samesite_none', {
           onFail,
           args: {
-            value: _options.sameSite, // for clarity, throw the error with the user's unnormalized option
+            value: options.sameSite, // for clarity, throw the error with the user's unnormalized option
           },
         })
       }
@@ -330,40 +330,40 @@ export default function (Commands, Cypress, cy, state, config) {
         $errUtils.throwErrByPath('setCookie.invalid_arguments', { onFail })
       }
 
-      if (_options.name.startsWith('__Secure-') && cookieValidatesSecurePrefix(_options)) {
+      if (options.name.startsWith('__Secure-') && cookieValidatesSecurePrefix(options)) {
         $errUtils.throwErrByPath('setCookie.secure_prefix', { onFail })
       }
 
-      if (_options.name.startsWith('__Host-') && cookieValidatesHostPrefix(_options)) {
+      if (options.name.startsWith('__Host-') && cookieValidatesHostPrefix(options)) {
         $errUtils.throwErrByPath('setCookie.host_prefix', { onFail })
       }
 
-      return automateCookies('set:cookie', cookie, _options._log, _options.timeout)
+      return automateCookies('set:cookie', cookie, options._log, options.timeout)
       .then(pickCookieProps)
       .then((resp) => {
-        _options.cookie = resp
+        options.cookie = resp
 
         return resp
       }).catch(handleBackendError('setCookie', 'setting the requested cookie in', onFail))
     },
 
-    clearCookie (name, options: Partial<Cypress.Loggable & Cypress.Timeoutable> = {}) {
-      const _options: InternalClearCookieOptions = _.defaults({}, options, {
+    clearCookie (name, userOptions: Partial<Cypress.Loggable & Cypress.Timeoutable> = {}) {
+      const options: InternalClearCookieOptions = _.defaults({}, userOptions, {
         log: true,
         timeout: config('responseTimeout'),
       })
 
-      if (_options.log) {
-        _options._log = Cypress.log({
+      if (options.log) {
+        options._log = Cypress.log({
           message: name,
-          timeout: _options.timeout,
+          timeout: options.timeout,
           consoleProps () {
             let c
             const obj = {}
 
             obj['Yielded'] = 'null'
 
-            c = _options.cookie
+            c = options.cookie
 
             if (c) {
               obj['Cleared Cookie'] = c
@@ -376,17 +376,17 @@ export default function (Commands, Cypress, cy, state, config) {
         })
       }
 
-      const onFail = _options._log
+      const onFail = options._log
 
       if (!_.isString(name)) {
         $errUtils.throwErrByPath('clearCookie.invalid_argument', { onFail })
       }
 
       // TODO: prevent clearing a cypress namespace
-      return automateCookies('clear:cookie', { name }, _options._log, _options.timeout)
+      return automateCookies('clear:cookie', { name }, options._log, options.timeout)
       .then(pickCookieProps)
       .then((resp) => {
-        _options.cookie = resp
+        options.cookie = resp
 
         // null out the current subject
         return null
@@ -394,18 +394,18 @@ export default function (Commands, Cypress, cy, state, config) {
       .catch(handleBackendError('clearCookie', 'clearing the requested cookie in', onFail))
     },
 
-    clearCookies (options: Partial<Cypress.Loggable & Cypress.Timeoutable> = {}) {
-      const _options: InternalClearCookiesOptions = _.defaults({}, options, {
+    clearCookies (userOptions: Partial<Cypress.Loggable & Cypress.Timeoutable> = {}) {
+      const options: InternalClearCookiesOptions = _.defaults({}, userOptions, {
         log: true,
         timeout: config('responseTimeout'),
       })
 
-      if (_options.log) {
-        _options._log = Cypress.log({
+      if (options.log) {
+        options._log = Cypress.log({
           message: '',
-          timeout: _options.timeout,
+          timeout: options.timeout,
           consoleProps () {
-            const c = _options.cookies
+            const c = options.cookies
             const obj = {}
 
             obj['Yielded'] = 'null'
@@ -422,9 +422,9 @@ export default function (Commands, Cypress, cy, state, config) {
         })
       }
 
-      return getAndClear(_options._log, _options.timeout, { domain: _options.domain })
+      return getAndClear(options._log, options.timeout, { domain: options.domain })
       .then((resp) => {
-        _options.cookies = resp
+        options.cookies = resp
 
         // null out the current subject
         return null
@@ -433,7 +433,7 @@ export default function (Commands, Cypress, cy, state, config) {
         err.message = err.message.replace('getCookies', 'clearCookies')
         throw err
       })
-      .catch(handleBackendError('clearCookies', 'clearing cookies in', _options._log))
+      .catch(handleBackendError('clearCookies', 'clearing cookies in', options._log))
     },
   })
 }
diff --git a/packages/driver/src/cy/commands/debugging.ts b/packages/driver/src/cy/commands/debugging.ts
index e812d89cd9de..b6b51d7e9983 100644
--- a/packages/driver/src/cy/commands/debugging.ts
+++ b/packages/driver/src/cy/commands/debugging.ts
@@ -52,16 +52,16 @@ export default (Commands, Cypress, cy, state, config) => {
   Commands.addAll({ type: 'utility', prevSubject: 'optional' }, {
     // pause should indefinitely pause until the user
     // presses a key or clicks in the UI to continue
-    pause (subject, options: Partial<Cypress.Loggable> = {}) {
+    pause (subject, userOptions: Partial<Cypress.Loggable> = {}) {
       // bail if we're in run mode, unless --headed and --no-exit flags are passed
       if (!config('isInteractive') && (!config('browser').isHeaded || config('exit'))) {
         return subject
       }
 
-      const _options: InternalPauseOptions = _.defaults({}, options, { log: true })
+      const options: InternalPauseOptions = _.defaults({}, userOptions, { log: true })
 
-      if (_options.log) {
-        _options._log = Cypress.log({
+      if (options.log) {
+        options._log = Cypress.log({
           snapshot: true,
           autoEnd: false,
           timeout: 0,
@@ -77,8 +77,8 @@ export default (Commands, Cypress, cy, state, config) => {
           // pause on the very next one
             state('onPaused', null)
 
-            if (_options.log) {
-              _options._log.end()
+            if (options.log) {
+              options._log.end()
             }
           }
 
@@ -108,13 +108,13 @@ export default (Commands, Cypress, cy, state, config) => {
       return subject
     },
 
-    debug (subject, options: Partial<Cypress.Loggable> = {}) {
-      const _options: InternalDebugOptions = _.defaults({}, options, {
+    debug (subject, userOptions: Partial<Cypress.Loggable> = {}) {
+      const options: InternalDebugOptions = _.defaults({}, userOptions, {
         log: true,
       })
 
-      if (_options.log) {
-        _options._log = Cypress.log({
+      if (options.log) {
+        options._log = Cypress.log({
           snapshot: true,
           end: true,
           timeout: 0,
diff --git a/packages/driver/src/cy/commands/exec.ts b/packages/driver/src/cy/commands/exec.ts
index c3ca1beb4384..e6abe7e1e8ad 100644
--- a/packages/driver/src/cy/commands/exec.ts
+++ b/packages/driver/src/cy/commands/exec.ts
@@ -10,8 +10,8 @@ interface InternalExecOptions extends Partial<Cypress.ExecOptions> {
 
 export default (Commands, Cypress, cy) => {
   Commands.addAll({
-    exec (cmd: string, options: Partial<Cypress.ExecOptions> = {}) {
-      const _options: InternalExecOptions = _.defaults({}, options, {
+    exec (cmd: string, userOptions: Partial<Cypress.ExecOptions> = {}) {
+      const options: InternalExecOptions = _.defaults({}, userOptions, {
         log: true,
         timeout: Cypress.config('execTimeout'),
         failOnNonZeroExit: true,
@@ -20,12 +20,12 @@ export default (Commands, Cypress, cy) => {
 
       let consoleOutput
 
-      if (_options.log) {
+      if (options.log) {
         consoleOutput = {}
 
-        _options._log = Cypress.log({
+        options._log = Cypress.log({
           message: _.truncate(cmd, { length: 25 }),
-          timeout: _options.timeout,
+          timeout: options.timeout,
           consoleProps () {
             return consoleOutput
           },
@@ -34,27 +34,27 @@ export default (Commands, Cypress, cy) => {
 
       if (!cmd || !_.isString(cmd)) {
         $errUtils.throwErrByPath('exec.invalid_argument', {
-          onFail: _options._log,
+          onFail: options._log,
           args: { cmd: cmd ?? '' },
         })
       }
 
-      _options.cmd = cmd
+      options.cmd = cmd
 
       // need to remove the current timeout
       // because we're handling timeouts ourselves
       cy.clearTimeout()
 
-      return Cypress.backend('exec', _.pick(_options, 'cmd', 'timeout', 'env'))
-      .timeout(_options.timeout)
+      return Cypress.backend('exec', _.pick(options, 'cmd', 'timeout', 'env'))
+      .timeout(options.timeout)
       .then((result) => {
-        if (_options._log) {
+        if (options._log) {
           _.extend(consoleOutput, { Yielded: _.omit(result, 'shell') })
 
           consoleOutput['Shell Used'] = result.shell
         }
 
-        if ((result.code === 0) || !_options.failOnNonZeroExit) {
+        if ((result.code === 0) || !options.failOnNonZeroExit) {
           return result
         }
 
@@ -69,14 +69,14 @@ export default (Commands, Cypress, cy) => {
         }
 
         return $errUtils.throwErrByPath('exec.non_zero_exit', {
-          onFail: _options._log,
+          onFail: options._log,
           args: { cmd, output, code: result.code },
         })
       })
       .catch(Promise.TimeoutError, { timedOut: true }, () => {
         return $errUtils.throwErrByPath('exec.timed_out', {
-          onFail: _options._log,
-          args: { cmd, timeout: _options.timeout },
+          onFail: options._log,
+          args: { cmd, timeout: options.timeout },
         })
       })
       .catch((error) => {
@@ -86,7 +86,7 @@ export default (Commands, Cypress, cy) => {
         }
 
         return $errUtils.throwErrByPath('exec.failed', {
-          onFail: _options._log,
+          onFail: options._log,
           args: { cmd, error },
         })
       })
diff --git a/packages/driver/src/cy/commands/files.ts b/packages/driver/src/cy/commands/files.ts
index d61215edd8ce..f61116f38b44 100644
--- a/packages/driver/src/cy/commands/files.ts
+++ b/packages/driver/src/cy/commands/files.ts
@@ -14,15 +14,13 @@ interface InternalWriteFileOptions extends Partial<Cypress.WriteFileOptions & Cy
 
 export default (Commands, Cypress, cy, state) => {
   Commands.addAll({
-    readFile (file, encoding, options: Partial<Cypress.Loggable & Cypress.Timeoutable> = {}) {
-      let userOptions = options
-
+    readFile (file, encoding, userOptions: Partial<Cypress.Loggable & Cypress.Timeoutable> = {}) {
       if (_.isObject(encoding)) {
         userOptions = encoding
         encoding = undefined
       }
 
-      const _options: InternalReadFileOptions = _.defaults({}, userOptions, {
+      const options: InternalReadFileOptions = _.defaults({}, userOptions, {
         // https://github.com/cypress-io/cypress/issues/1558
         // If no encoding is specified, then Cypress has historically defaulted
         // to `utf8`, because of it's focus on text files. This is in contrast to
@@ -35,10 +33,10 @@ export default (Commands, Cypress, cy, state) => {
 
       const consoleProps = {}
 
-      if (_options.log) {
-        _options._log = Cypress.log({
+      if (options.log) {
+        options._log = Cypress.log({
           message: file,
-          timeout: _options.timeout,
+          timeout: options.timeout,
           consoleProps () {
             return consoleProps
           },
@@ -47,7 +45,7 @@ export default (Commands, Cypress, cy, state) => {
 
       if (!file || !_.isString(file)) {
         $errUtils.throwErrByPath('files.invalid_argument', {
-          onFail: _options._log,
+          onFail: options._log,
           args: { cmd: 'readFile', file },
         })
       }
@@ -57,19 +55,19 @@ export default (Commands, Cypress, cy, state) => {
       cy.clearTimeout()
 
       const verifyAssertions = () => {
-        return Cypress.backend('read:file', file, _.pick(_options, 'encoding')).timeout(_options.timeout)
+        return Cypress.backend('read:file', file, _.pick(options, 'encoding')).timeout(options.timeout)
         .catch((err) => {
           if (err.name === 'TimeoutError') {
             return $errUtils.throwErrByPath('files.timed_out', {
-              onFail: _options._log,
-              args: { cmd: 'readFile', file, timeout: _options.timeout },
+              onFail: options._log,
+              args: { cmd: 'readFile', file, timeout: options.timeout },
             })
           }
 
           // Non-ENOENT errors are not retried
           if (err.code !== 'ENOENT') {
             return $errUtils.throwErrByPath('files.unexpected_error', {
-              onFail: _options._log,
+              onFail: options._log,
               args: { cmd: 'readFile', action: 'read', file, filePath: err.filePath, error: err.message },
             })
           }
@@ -83,7 +81,7 @@ export default (Commands, Cypress, cy, state) => {
           // We invoke Buffer.from() in order to transform this from an ArrayBuffer -
           // which socket.io uses to transfer the file over the websocket - into a
           // `Buffer`, which webpack polyfills in the browser.
-          if (_options.encoding === null) {
+          if (options.encoding === null) {
             contents = Buffer.from(contents)
           }
 
@@ -93,7 +91,7 @@ export default (Commands, Cypress, cy, state) => {
           consoleProps['File Path'] = filePath
           consoleProps['Contents'] = contents
 
-          return cy.verifyUpcomingAssertions(contents, _options, {
+          return cy.verifyUpcomingAssertions(contents, options, {
             ensureExistenceFor: 'subject',
             onFail (err) {
               if (err.type !== 'existence') {
@@ -117,15 +115,13 @@ export default (Commands, Cypress, cy, state) => {
       return verifyAssertions()
     },
 
-    writeFile (fileName, contents, encoding, options: Partial<Cypress.WriteFileOptions & Cypress.Timeoutable> = {}) {
-      let userOptions = options
-
+    writeFile (fileName, contents, encoding, userOptions: Partial<Cypress.WriteFileOptions & Cypress.Timeoutable> = {}) {
       if (_.isObject(encoding)) {
         userOptions = encoding
         encoding = undefined
       }
 
-      const _options: InternalWriteFileOptions = _.defaults({}, userOptions, {
+      const options: InternalWriteFileOptions = _.defaults({}, userOptions, {
         // https://github.com/cypress-io/cypress/issues/1558
         // If no encoding is specified, then Cypress has historically defaulted
         // to `utf8`, because of it's focus on text files. This is in contrast to
@@ -139,10 +135,10 @@ export default (Commands, Cypress, cy, state) => {
 
       const consoleProps = {}
 
-      if (_options.log) {
-        _options._log = Cypress.log({
+      if (options.log) {
+        options._log = Cypress.log({
           message: fileName,
-          timeout: _options.timeout,
+          timeout: options.timeout,
           consoleProps () {
             return consoleProps
           },
@@ -151,14 +147,14 @@ export default (Commands, Cypress, cy, state) => {
 
       if (!fileName || !_.isString(fileName)) {
         $errUtils.throwErrByPath('files.invalid_argument', {
-          onFail: _options._log,
+          onFail: options._log,
           args: { cmd: 'writeFile', file: fileName },
         })
       }
 
       if (!(_.isString(contents) || _.isObject(contents))) {
         $errUtils.throwErrByPath('files.invalid_contents', {
-          onFail: _options._log,
+          onFail: options._log,
           args: { contents },
         })
       }
@@ -171,7 +167,7 @@ export default (Commands, Cypress, cy, state) => {
       // the timeout ourselves
       cy.clearTimeout()
 
-      return Cypress.backend('write:file', fileName, contents, _.pick(_options, 'encoding', 'flag')).timeout(_options.timeout)
+      return Cypress.backend('write:file', fileName, contents, _.pick(options, 'encoding', 'flag')).timeout(options.timeout)
       .then(({ filePath, contents }) => {
         consoleProps['File Path'] = filePath
         consoleProps['Contents'] = contents
@@ -181,13 +177,13 @@ export default (Commands, Cypress, cy, state) => {
       .catch((err) => {
         if (err.name === 'TimeoutError') {
           return $errUtils.throwErrByPath('files.timed_out', {
-            onFail: _options._log,
-            args: { cmd: 'writeFile', file: fileName, timeout: _options.timeout },
+            onFail: options._log,
+            args: { cmd: 'writeFile', file: fileName, timeout: options.timeout },
           })
         }
 
         return $errUtils.throwErrByPath('files.unexpected_error', {
-          onFail: _options._log,
+          onFail: options._log,
           args: { cmd: 'writeFile', action: 'write', file: fileName, filePath: err.filePath, error: err.message },
         })
       })
diff --git a/packages/driver/src/cy/commands/location.ts b/packages/driver/src/cy/commands/location.ts
index eeee09be07aa..673eda9ca8c1 100644
--- a/packages/driver/src/cy/commands/location.ts
+++ b/packages/driver/src/cy/commands/location.ts
@@ -14,13 +14,13 @@ interface InternalHashOptions extends Partial<Cypress.Loggable & Cypress.Timeout
 
 export default (Commands, Cypress, cy) => {
   Commands.addAll({
-    url (options: Partial<Cypress.UrlOptions> = {}) {
-      const _options: InternalUrlOptions = _.defaults({}, options, { log: true })
+    url (userOptions: Partial<Cypress.UrlOptions> = {}) {
+      const options: InternalUrlOptions = _.defaults({}, userOptions, { log: true })
 
-      if (_options.log !== false) {
-        _options._log = Cypress.log({
+      if (options.log !== false) {
+        options._log = Cypress.log({
           message: '',
-          timeout: _options.timeout,
+          timeout: options.timeout,
         })
       }
 
@@ -30,11 +30,11 @@ export default (Commands, Cypress, cy) => {
 
       const resolveHref = () => {
         return Promise.try(getHref).then((href) => {
-          if (_options.decode) {
+          if (options.decode) {
             href = decodeURI(href)
           }
 
-          return cy.verifyUpcomingAssertions(href, _options, {
+          return cy.verifyUpcomingAssertions(href, options, {
             onRetry: resolveHref,
           })
         })
@@ -43,13 +43,13 @@ export default (Commands, Cypress, cy) => {
       return resolveHref()
     },
 
-    hash (options: Partial<Cypress.Loggable & Cypress.Timeoutable> = {}) {
-      const _options: InternalHashOptions = _.defaults({}, options, { log: true })
+    hash (userOptions: Partial<Cypress.Loggable & Cypress.Timeoutable> = {}) {
+      const options: InternalHashOptions = _.defaults({}, userOptions, { log: true })
 
-      if (_options.log !== false) {
-        _options._log = Cypress.log({
+      if (options.log !== false) {
+        options._log = Cypress.log({
           message: '',
-          timeout: _options.timeout,
+          timeout: options.timeout,
         })
       }
 
@@ -59,7 +59,7 @@ export default (Commands, Cypress, cy) => {
 
       const resolveHash = () => {
         return Promise.try(getHash).then((hash) => {
-          return cy.verifyUpcomingAssertions(hash, _options, {
+          return cy.verifyUpcomingAssertions(hash, options, {
             onRetry: resolveHash,
           })
         })
diff --git a/packages/driver/src/cy/commands/misc.ts b/packages/driver/src/cy/commands/misc.ts
index 25e19fc97685..8e66d8a91090 100644
--- a/packages/driver/src/cy/commands/misc.ts
+++ b/packages/driver/src/cy/commands/misc.ts
@@ -54,8 +54,8 @@ export default (Commands, Cypress, cy, state) => {
       return null
     },
 
-    wrap (arg, options: Partial<Cypress.Loggable & Cypress.Timeoutable> = {}) {
-      const _options: InternalWrapOptions = _.defaults({}, options, {
+    wrap (arg, userOptions: Partial<Cypress.Loggable & Cypress.Timeoutable> = {}) {
+      const options: InternalWrapOptions = _.defaults({}, userOptions, {
         log: true,
         timeout: Cypress.config('defaultCommandTimeout'),
       })
@@ -63,32 +63,32 @@ export default (Commands, Cypress, cy, state) => {
       // we'll handle the timeout ourselves
       cy.clearTimeout()
 
-      if (_options.log !== false) {
-        _options._log = Cypress.log({
+      if (options.log !== false) {
+        options._log = Cypress.log({
           message: arg,
-          timeout: _options.timeout,
+          timeout: options.timeout,
         })
 
         if ($dom.isElement(arg)) {
-          _options._log.set({ $el: arg })
+          options._log.set({ $el: arg })
         }
       }
 
       return Promise.resolve(arg)
-      .timeout(_options.timeout)
+      .timeout(options.timeout)
       .catch(Promise.TimeoutError, () => {
         $errUtils.throwErrByPath('wrap.timed_out', {
-          args: { timeout: _options.timeout },
+          args: { timeout: options.timeout },
         })
       })
       .catch((err) => {
         $errUtils.throwErr(err, {
-          onFail: _options._log,
+          onFail: options._log,
         })
       })
       .then((subject) => {
         const resolveWrap = () => {
-          return cy.verifyUpcomingAssertions(subject, _options, {
+          return cy.verifyUpcomingAssertions(subject, options, {
             onRetry: resolveWrap,
           })
           .return(subject)
diff --git a/packages/driver/src/cy/commands/navigation.ts b/packages/driver/src/cy/commands/navigation.ts
index 51c17f45d70c..b402a732bb19 100644
--- a/packages/driver/src/cy/commands/navigation.ts
+++ b/packages/driver/src/cy/commands/navigation.ts
@@ -697,13 +697,11 @@ export default (Commands, Cypress, cy, state, config) => {
       return $errUtils.throwErrByPath('go.invalid_argument', { onFail: options._log })
     },
 
-    visit (url, options: Partial<Cypress.VisitOptions> = {}) {
-      if (options.url && url) {
-        $errUtils.throwErrByPath('visit.no_duplicate_url', { args: { optionsUrl: options.url, url } })
+    visit (url, userOptions: Partial<Cypress.VisitOptions> = {}) {
+      if (userOptions.url && url) {
+        $errUtils.throwErrByPath('visit.no_duplicate_url', { args: { optionsUrl: userOptions.url, url } })
       }
 
-      let userOptions = options
-
       if (_.isObject(url) && _.isEqual(userOptions, {})) {
         // options specified as only argument
         userOptions = url
@@ -720,7 +718,7 @@ export default (Commands, Cypress, cy, state, config) => {
         consoleProps['Options'] = _.pick(userOptions, VISIT_OPTS)
       }
 
-      const _options: InternalVisitOptions = _.defaults({}, userOptions, {
+      const options: InternalVisitOptions = _.defaults({}, userOptions, {
         auth: null,
         failOnStatusCode: true,
         retryOnNetworkFailure: true,
@@ -736,38 +734,38 @@ export default (Commands, Cypress, cy, state, config) => {
         onLoad () {},
       })
 
-      if (!_.isUndefined(_options.qs) && !_.isObject(_options.qs)) {
-        $errUtils.throwErrByPath('visit.invalid_qs', { args: { qs: String(_options.qs) } })
+      if (!_.isUndefined(options.qs) && !_.isObject(options.qs)) {
+        $errUtils.throwErrByPath('visit.invalid_qs', { args: { qs: String(options.qs) } })
       }
 
-      if (_options.retryOnStatusCodeFailure && !_options.failOnStatusCode) {
+      if (options.retryOnStatusCodeFailure && !options.failOnStatusCode) {
         $errUtils.throwErrByPath('visit.status_code_flags_invalid')
       }
 
-      if (!isValidVisitMethod(_options.method)) {
-        $errUtils.throwErrByPath('visit.invalid_method', { args: { method: _options.method } })
+      if (!isValidVisitMethod(options.method)) {
+        $errUtils.throwErrByPath('visit.invalid_method', { args: { method: options.method } })
       }
 
-      if (!_.isObject(_options.headers)) {
+      if (!_.isObject(options.headers)) {
         $errUtils.throwErrByPath('visit.invalid_headers')
       }
 
-      const path = whatIsCircular(_options.body)
+      const path = whatIsCircular(options.body)
 
-      if (_.isObject(_options.body) && path) {
+      if (_.isObject(options.body) && path) {
         $errUtils.throwErrByPath('visit.body_circular', { args: { path } })
       }
 
-      if (_options.log) {
+      if (options.log) {
         let message = url
 
-        if (_options.method !== 'GET') {
-          message = `${_options.method} ${message}`
+        if (options.method !== 'GET') {
+          message = `${options.method} ${message}`
         }
 
-        _options._log = Cypress.log({
+        options._log = Cypress.log({
           message,
-          timeout: _options.timeout,
+          timeout: options.timeout,
           consoleProps () {
             return consoleProps
           },
@@ -782,7 +780,7 @@ export default (Commands, Cypress, cy, state, config) => {
         url = $Location.qualifyWithBaseUrl(baseUrl, url)
       }
 
-      const qs = _options.qs
+      const qs = options.qs
 
       if (qs) {
         url = $Location.mergeUrlWithParams(url, qs)
@@ -810,7 +808,7 @@ export default (Commands, Cypress, cy, state, config) => {
                 configurable: true,
               })
 
-              _options.onBeforeLoad?.call(runnable.ctx, contentWindow)
+              options.onBeforeLoad?.call(runnable.ctx, contentWindow)
             } catch (err: any) {
               err.isCallbackError = true
               onBeforeLoadError = err
@@ -867,7 +865,7 @@ export default (Commands, Cypress, cy, state, config) => {
         // the onLoad callback should only be skipped if specified
         if (runOnLoadCallback !== false) {
           try {
-            _options.onLoad?.call(runnable.ctx, win)
+            options.onLoad?.call(runnable.ctx, win)
           } catch (err: any) {
             // mark these as user callback errors, so they're treated differently
             // than Node.js errors when caught below
@@ -876,8 +874,8 @@ export default (Commands, Cypress, cy, state, config) => {
           }
         }
 
-        if (_options._log) {
-          _options._log.set({
+        if (options._log) {
+          options._log.set({
             url,
             totalTime,
           })
@@ -893,7 +891,7 @@ export default (Commands, Cypress, cy, state, config) => {
         // TODO: $Location.resolve(existing.origin, url)
 
         if ($Location.isLocalFileUrl(url)) {
-          return specifyFileByRelativePath(url, _options._log)
+          return specifyFileByRelativePath(url, options._log)
         }
 
         let remoteUrl
@@ -911,7 +909,7 @@ export default (Commands, Cypress, cy, state, config) => {
         const a = remote.authObj
 
         if (a) {
-          _options.auth = a
+          options.auth = a
         }
 
         // store the existing hash now since
@@ -925,7 +923,7 @@ export default (Commands, Cypress, cy, state, config) => {
           // we also need to disable retries to prevent the endless loop
           $utils.getTestFromRunnable(state('runnable'))._retries = 0
 
-          return cannotVisitDifferentOrigin(remote.origin, previousDomainVisited, remote, existing, _options._log)
+          return cannotVisitDifferentOrigin(remote.origin, previousDomainVisited, remote, existing, options._log)
         }
 
         const current = $Location.create(win.location.href)
@@ -959,7 +957,7 @@ export default (Commands, Cypress, cy, state, config) => {
           url = url.replace(`${existingAuth}@`, '')
         }
 
-        return requestUrl(url, _options)
+        return requestUrl(url, options)
         .then((resp: any = {}) => {
           let { url, originalUrl, cookies, redirects, filePath } = resp
 
@@ -975,14 +973,14 @@ export default (Commands, Cypress, cy, state, config) => {
             }
           }
 
-          if (_options.log) {
-            let message = _options._log.get('message')
+          if (options.log) {
+            let message = options._log.get('message')
 
             if (redirects && redirects.length) {
               message = [message].concat(redirects).join(' -> ')
             }
 
-            _options._log.set({ message })
+            options._log.set({ message })
           }
 
           consoleProps['Resolved Url'] = url
@@ -1009,7 +1007,7 @@ export default (Commands, Cypress, cy, state, config) => {
           // if we've already visited a new origin
           // then die else we'd be in a terrible endless loop
           if (previousDomainVisited) {
-            return cannotVisitDifferentOrigin(remote.origin, previousDomainVisited, remote, existing, _options._log)
+            return cannotVisitDifferentOrigin(remote.origin, previousDomainVisited, remote, existing, options._log)
           }
 
           // tell our backend we're changing domains
@@ -1082,7 +1080,7 @@ export default (Commands, Cypress, cy, state, config) => {
               }
 
               $errUtils.throwErrByPath(msg, {
-                onFail: _options._log,
+                onFail: options._log,
                 args,
               })
             })
@@ -1099,7 +1097,7 @@ export default (Commands, Cypress, cy, state, config) => {
 
           visitFailedByErr(err, url, () => {
             $errUtils.throwErrByPath('visit.loading_network_failed', {
-              onFail: _options._log,
+              onFail: options._log,
               args: {
                 url,
                 error: err,
@@ -1137,9 +1135,9 @@ export default (Commands, Cypress, cy, state, config) => {
       }
 
       return visit()
-      .timeout(_options.timeout, 'visit')
+      .timeout(options.timeout, 'visit')
       .catch(Promise.TimeoutError, () => {
-        return timedOutWaitingForPageLoad(_options.timeout, _options._log)
+        return timedOutWaitingForPageLoad(options.timeout, options._log)
       }).finally(() => {
         if (typeof cleanup === 'function') {
           cleanup()
diff --git a/packages/driver/src/cy/commands/querying/focused.ts b/packages/driver/src/cy/commands/querying/focused.ts
index c2b716aa1e5d..0eb9b368eac6 100644
--- a/packages/driver/src/cy/commands/querying/focused.ts
+++ b/packages/driver/src/cy/commands/querying/focused.ts
@@ -10,22 +10,22 @@ interface InternalFocusedOptions extends Partial<Cypress.Loggable & Cypress.Time
 
 export default (Commands, Cypress, cy, state) => {
   Commands.addAll({
-    focused (options: Partial<Cypress.Loggable & Cypress.Timeoutable> = {}) {
-      const _options: InternalFocusedOptions = _.defaults({}, options, {
+    focused (userOptions: Partial<Cypress.Loggable & Cypress.Timeoutable> = {}) {
+      const options: InternalFocusedOptions = _.defaults({}, userOptions, {
         verify: true,
         log: true,
       })
 
-      if (_options.log) {
-        _options._log = Cypress.log({ timeout: _options.timeout })
+      if (options.log) {
+        options._log = Cypress.log({ timeout: options.timeout })
       }
 
       const log = ($el) => {
-        if (_options.log === false) {
+        if (options.log === false) {
           return
         }
 
-        _options._log.set({
+        options._log.set({
           $el,
           consoleProps () {
             const ret = $el ? $dom.getElements($el) : '--nothing--'
@@ -50,7 +50,7 @@ export default (Commands, Cypress, cy, state) => {
         return Promise
         .try(getFocused)
         .then(($el) => {
-          if (_options.verify === false) {
+          if (options.verify === false) {
             return $el
           }
 
@@ -60,7 +60,7 @@ export default (Commands, Cypress, cy, state) => {
           }
 
           // pass in a null jquery object for assertions
-          return cy.verifyUpcomingAssertions($el, _options, {
+          return cy.verifyUpcomingAssertions($el, options, {
             onRetry: resolveFocused,
           })
         })
diff --git a/packages/driver/src/cy/commands/querying/querying.ts b/packages/driver/src/cy/commands/querying/querying.ts
index f6cbefc659d0..cf0dbdaaaaa0 100644
--- a/packages/driver/src/cy/commands/querying/querying.ts
+++ b/packages/driver/src/cy/commands/querying/querying.ts
@@ -21,16 +21,16 @@ interface InternalContainsOptions extends Partial<Cypress.Loggable & Cypress.Tim
 
 export default (Commands, Cypress, cy, state) => {
   Commands.addAll({
-    get (selector, options: Partial<Cypress.Loggable & Cypress.Timeoutable & Cypress.Withinable & Cypress.Shadow> = {}) {
+    get (selector, userOptions: Partial<Cypress.Loggable & Cypress.Timeoutable & Cypress.Withinable & Cypress.Shadow> = {}) {
       const ctx = this
 
-      if ((options === null) || _.isArray(options) || !_.isPlainObject(options)) {
+      if ((userOptions === null) || _.isArray(userOptions) || !_.isPlainObject(userOptions)) {
         return $errUtils.throwErrByPath('get.invalid_options', {
-          args: { options },
+          args: { userOptions },
         })
       }
 
-      const _options: InternalGetOptions = _.defaults({}, options, {
+      const options: InternalGetOptions = _.defaults({}, userOptions, {
         retry: true,
         withinSubject: state('withinSubject'),
         log: true,
@@ -38,21 +38,21 @@ export default (Commands, Cypress, cy, state) => {
         verify: true,
       })
 
-      _options.includeShadowDom = resolveShadowDomInclusion(Cypress, _options.includeShadowDom)
+      options.includeShadowDom = resolveShadowDomInclusion(Cypress, options.includeShadowDom)
 
       let aliasObj
       const consoleProps: Record<string, any> = {}
       const start = (aliasType) => {
-        if (_options.log === false) {
+        if (options.log === false) {
           return
         }
 
-        if (_options._log == null) {
-          _options._log = Cypress.log({
+        if (options._log == null) {
+          options._log = Cypress.log({
             message: selector,
             referencesAlias: (aliasObj != null && aliasObj.alias) ? { name: aliasObj.alias } : undefined,
             aliasType,
-            timeout: _options.timeout,
+            timeout: options.timeout,
             consoleProps: () => {
               return consoleProps
             },
@@ -61,11 +61,11 @@ export default (Commands, Cypress, cy, state) => {
       }
 
       const log = (value, aliasType = 'dom') => {
-        if (_options.log === false) {
+        if (options.log === false) {
           return
         }
 
-        if (!_.isObject(_options._log)) {
+        if (!_.isObject(options._log)) {
           start(aliasType)
         }
 
@@ -74,7 +74,7 @@ export default (Commands, Cypress, cy, state) => {
         if (aliasType === 'dom') {
           _.extend(obj, {
             $el: value,
-            numRetries: _options._retries,
+            numRetries: options._retries,
           })
         }
 
@@ -110,7 +110,7 @@ export default (Commands, Cypress, cy, state) => {
           return consoleProps
         }
 
-        _options._log.set(obj)
+        options._log.set(obj)
       }
 
       let allParts
@@ -186,7 +186,7 @@ export default (Commands, Cypress, cy, state) => {
 
             log(subject)
 
-            return cy.verifyUpcomingAssertions(subject, _options, {
+            return cy.verifyUpcomingAssertions(subject, options, {
               onFail (err) {
                 // if we are failing because our aliased elements
                 // are less than what is expected then we know we
@@ -251,7 +251,7 @@ export default (Commands, Cypress, cy, state) => {
           log(subject, 'primitive')
 
           const verifyAssertions = () => {
-            return cy.verifyUpcomingAssertions(subject, _options, {
+            return cy.verifyUpcomingAssertions(subject, options, {
               ensureExistenceFor: false,
               onRetry: verifyAssertions,
             })
@@ -266,24 +266,24 @@ export default (Commands, Cypress, cy, state) => {
       start('dom')
 
       const setEl = ($el) => {
-        if (_options.log === false) {
+        if (options.log === false) {
           return
         }
 
         consoleProps.Yielded = $dom.getElements($el)
         consoleProps.Elements = $el != null ? $el.length : undefined
 
-        _options._log.set({ $el })
+        options._log.set({ $el })
       }
 
       const getElements = () => {
         let $el
 
         try {
-          let scope: (typeof _options.withinSubject) | Node[] = _options.withinSubject
+          let scope: (typeof options.withinSubject) | Node[] = options.withinSubject
 
-          if (_options.includeShadowDom) {
-            const root = _options.withinSubject ? _options.withinSubject[0] : cy.state('document')
+          if (options.includeShadowDom) {
+            const root = options.withinSubject ? options.withinSubject[0] : cy.state('document')
             const elementsWithShadow = $dom.findAllShadowRoots(root)
 
             scope = elementsWithShadow.concat(root)
@@ -301,11 +301,11 @@ export default (Commands, Cypress, cy, state) => {
         } catch (err: any) {
           // this is usually a sizzle error (invalid selector)
           err.onFail = () => {
-            if (_options.log === false) {
+            if (options.log === false) {
               return err
             }
 
-            _options._log.error(err)
+            options._log.error(err)
           }
 
           throw err
@@ -314,8 +314,8 @@ export default (Commands, Cypress, cy, state) => {
         // if that didnt find anything and we have a within subject
         // and we have been explictly told to filter
         // then just attempt to filter out elements from our within subject
-        if (!$el.length && _options.withinSubject && _options.filter) {
-          const filtered = (_options.withinSubject as JQuery).filter(selector)
+        if (!$el.length && options.withinSubject && options.filter) {
+          const filtered = (options.withinSubject as JQuery).filter(selector)
 
           // reset $el if this found anything
           if (filtered.length) {
@@ -328,8 +328,8 @@ export default (Commands, Cypress, cy, state) => {
 
         // allow retry to be a function which we ensure
         // returns truthy before returning its
-        if (_.isFunction(_options.onRetry)) {
-          const ret = _options.onRetry.call(ctx, $el)
+        if (_.isFunction(options.onRetry)) {
+          const ret = options.onRetry.call(ctx, $el)
 
           if (ret) {
             log($el)
@@ -345,11 +345,11 @@ export default (Commands, Cypress, cy, state) => {
 
       const resolveElements = () => {
         return Promise.try(getElements).then(($el) => {
-          if (_options.verify === false) {
+          if (options.verify === false) {
             return $el
           }
 
-          return cy.verifyUpcomingAssertions($el, _options, {
+          return cy.verifyUpcomingAssertions($el, options, {
             onRetry: resolveElements,
           })
         })
@@ -360,9 +360,7 @@ export default (Commands, Cypress, cy, state) => {
   })
 
   Commands.addAll({ prevSubject: ['optional', 'window', 'document', 'element'] }, {
-    contains (subject, filter, text, options: Partial<Cypress.Loggable & Cypress.Timeoutable & Cypress.CaseMatchable & Cypress.Shadow> = {}) {
-      let userOptions = options
-
+    contains (subject, filter, text, userOptions: Partial<Cypress.Loggable & Cypress.Timeoutable & Cypress.CaseMatchable & Cypress.Shadow> = {}) {
       // nuke our subject if its present but not an element.
       // in these cases its either window or document but
       // we dont care.
@@ -398,7 +396,7 @@ export default (Commands, Cypress, cy, state) => {
         $errUtils.throwErrByPath('contains.regex_conflict')
       }
 
-      const _options: InternalContainsOptions = _.defaults({}, userOptions, { log: true, matchCase: true })
+      const options: InternalContainsOptions = _.defaults({}, userOptions, { log: true, matchCase: true })
 
       if (!(_.isString(text) || _.isFinite(text) || _.isRegExp(text))) {
         $errUtils.throwErrByPath('contains.invalid_argument')
@@ -444,16 +442,16 @@ export default (Commands, Cypress, cy, state) => {
 
       let consoleProps
 
-      if (_options.log !== false) {
+      if (options.log !== false) {
         consoleProps = {
           Content: text,
           'Applied To': $dom.getElements(subject || state('withinSubject')),
         }
 
-        _options._log = Cypress.log({
+        options._log = Cypress.log({
           message: _.compact([filter, text]),
           type: subject ? 'child' : 'parent',
-          timeout: _options.timeout,
+          timeout: options.timeout,
           consoleProps: () => {
             return consoleProps
           },
@@ -461,22 +459,22 @@ export default (Commands, Cypress, cy, state) => {
       }
 
       const setEl = ($el) => {
-        if (_options.log === false) {
+        if (options.log === false) {
           return
         }
 
         consoleProps.Yielded = $dom.getElements($el)
         consoleProps.Elements = $el != null ? $el.length : undefined
 
-        _options._log.set({ $el })
+        options._log.set({ $el })
       }
 
       // find elements by the :cy-contains psuedo selector
       // and any submit inputs with the attributeContainsWord selector
-      const selector = $dom.getContainsSelector(text, filter, _options)
+      const selector = $dom.getContainsSelector(text, filter, options)
 
       const resolveElements = () => {
-        const getOptions = _.extend({}, _options, {
+        const getOptions = _.extend({}, options, {
           // error: getErr(text, phrase)
           withinSubject: subject || state('withinSubject') || cy.$$('body'),
           filter: true,
@@ -492,13 +490,13 @@ export default (Commands, Cypress, cy, state) => {
 
           setEl($el)
 
-          return cy.verifyUpcomingAssertions($el, _options, {
+          return cy.verifyUpcomingAssertions($el, options, {
             onRetry: resolveElements,
             onFail (err) {
               switch (err.type) {
                 case 'length':
                   if (err.expected > 1) {
-                    return $errUtils.throwErrByPath('contains.length_option', { onFail: _options._log })
+                    return $errUtils.throwErrByPath('contains.length_option', { onFail: options._log })
                   }
 
                   break
diff --git a/packages/driver/src/cy/commands/querying/root.ts b/packages/driver/src/cy/commands/querying/root.ts
index f9494a4c4c1c..45a74dd90271 100644
--- a/packages/driver/src/cy/commands/querying/root.ts
+++ b/packages/driver/src/cy/commands/querying/root.ts
@@ -6,19 +6,19 @@ interface InternalRootOptions extends Partial<Cypress.Loggable & Cypress.Timeout
 
 export default (Commands, Cypress, cy, state) => {
   Commands.addAll({
-    root (options: Partial<Cypress.Loggable & Cypress.Timeoutable> = {}) {
-      const _options: InternalRootOptions = _.defaults({}, options, { log: true })
+    root (userOptions: Partial<Cypress.Loggable & Cypress.Timeoutable> = {}) {
+      const options: InternalRootOptions = _.defaults({}, userOptions, { log: true })
 
-      if (_options.log !== false) {
-        _options._log = Cypress.log({
+      if (options.log !== false) {
+        options._log = Cypress.log({
           message: '',
-          timeout: _options.timeout,
+          timeout: options.timeout,
         })
       }
 
       const log = ($el) => {
-        if (_options.log) {
-          _options._log.set({ $el })
+        if (options.log) {
+          options._log.set({ $el })
         }
 
         return $el
diff --git a/packages/driver/src/cy/commands/screenshot.ts b/packages/driver/src/cy/commands/screenshot.ts
index 72e12e215777..af5ca52dc2f7 100644
--- a/packages/driver/src/cy/commands/screenshot.ts
+++ b/packages/driver/src/cy/commands/screenshot.ts
@@ -444,9 +444,7 @@ export default function (Commands, Cypress, cy, state, config) {
   })
 
   Commands.addAll({ prevSubject: ['optional', 'element', 'window', 'document'] }, {
-    screenshot (subject, name, options: Partial<Cypress.Loggable & Cypress.Timeoutable & Cypress.ScreenshotOptions> = {}) {
-      let userOptions = options
-
+    screenshot (subject, name, userOptions: Partial<Cypress.Loggable & Cypress.Timeoutable & Cypress.ScreenshotOptions> = {}) {
       if (_.isObject(name)) {
         userOptions = name
         name = null
@@ -455,7 +453,7 @@ export default function (Commands, Cypress, cy, state, config) {
       // make sure when we capture the entire test runner
       // we are not limited to "within" subject
       // https://github.com/cypress-io/cypress/issues/14253
-      if (options.capture !== 'runner') {
+      if (userOptions.capture !== 'runner') {
         const withinSubject = state('withinSubject')
 
         if (withinSubject && $dom.isElement(withinSubject)) {
@@ -466,16 +464,16 @@ export default function (Commands, Cypress, cy, state, config) {
       // TODO: handle hook titles
       const runnable = state('runnable')
 
-      const _options: InternalScreenshotOptions = _.defaults({}, userOptions, {
+      const options: InternalScreenshotOptions = _.defaults({}, userOptions, {
         log: true,
         timeout: config('responseTimeout'),
       })
 
       const isWin = $dom.isWindow(subject)
 
-      let screenshotConfig: any = _.pick(_options, 'capture', 'scale', 'disableTimersAndAnimations', 'overwrite', 'blackout', 'waitForCommandSynchronization', 'padding', 'clip', 'onBeforeScreenshot', 'onAfterScreenshot')
+      let screenshotConfig: any = _.pick(options, 'capture', 'scale', 'disableTimersAndAnimations', 'overwrite', 'blackout', 'waitForCommandSynchronization', 'padding', 'clip', 'onBeforeScreenshot', 'onAfterScreenshot')
 
-      screenshotConfig = $Screenshot.validate(screenshotConfig, 'screenshot', _options._log)
+      screenshotConfig = $Screenshot.validate(screenshotConfig, 'screenshot', options._log)
       screenshotConfig = _.extend($Screenshot.getConfig(), screenshotConfig)
 
       // set this regardless of options.log b/c its used by the
@@ -491,10 +489,10 @@ export default function (Commands, Cypress, cy, state, config) {
         consoleProps.name = name
       }
 
-      if (_options.log) {
-        _options._log = Cypress.log({
+      if (options.log) {
+        options._log = Cypress.log({
           message: name,
-          timeout: _options.timeout,
+          timeout: options.timeout,
           consoleProps () {
             return consoleProps
           },
@@ -503,7 +501,7 @@ export default function (Commands, Cypress, cy, state, config) {
 
       if (!isWin && subject && subject.length > 1) {
         $errUtils.throwErrByPath('screenshot.multiple_elements', {
-          log: _options._log,
+          log: options._log,
           args: { numElements: subject.length },
         })
       }
@@ -518,8 +516,8 @@ export default function (Commands, Cypress, cy, state, config) {
         name,
         subject,
         runnable,
-        log: _options._log,
-        timeout: _options.timeout,
+        log: options._log,
+        timeout: options.timeout,
       })
       .then((props) => {
         const { duration, path, size } = props
diff --git a/packages/driver/src/cy/commands/task.ts b/packages/driver/src/cy/commands/task.ts
index 5a42905f9aaf..680ca9bf7d79 100644
--- a/packages/driver/src/cy/commands/task.ts
+++ b/packages/driver/src/cy/commands/task.ts
@@ -11,15 +11,15 @@ interface InternalTaskOptions extends Partial<Cypress.Loggable & Cypress.Timeout
 
 export default (Commands, Cypress, cy) => {
   Commands.addAll({
-    task (task, arg, options: Partial<Cypress.Loggable & Cypress.Timeoutable> = {}) {
-      const _options: InternalTaskOptions = _.defaults({}, options, {
+    task (task, arg, userOptions: Partial<Cypress.Loggable & Cypress.Timeoutable> = {}) {
+      const options: InternalTaskOptions = _.defaults({}, userOptions, {
         log: true,
         timeout: Cypress.config('taskTimeout'),
       })
 
       let consoleOutput
 
-      if (_options.log) {
+      if (options.log) {
         consoleOutput = {
           task,
           arg,
@@ -31,9 +31,9 @@ export default (Commands, Cypress, cy) => {
           message += `, ${$utils.stringify(arg)}`
         }
 
-        _options._log = Cypress.log({
+        options._log = Cypress.log({
           message,
-          timeout: _options.timeout,
+          timeout: options.timeout,
           consoleProps () {
             return consoleOutput
           },
@@ -42,7 +42,7 @@ export default (Commands, Cypress, cy) => {
 
       if (!task || !_.isString(task)) {
         $errUtils.throwErrByPath('task.invalid_argument', {
-          onFail: _options._log,
+          onFail: options._log,
           args: { task: task || '' },
         })
       }
@@ -54,11 +54,11 @@ export default (Commands, Cypress, cy) => {
       return Cypress.backend('task', {
         task,
         arg,
-        timeout: _options.timeout,
+        timeout: options.timeout,
       })
-      .timeout(_options.timeout)
+      .timeout(options.timeout)
       .then((result) => {
-        if (_options._log) {
+        if (options._log) {
           _.extend(consoleOutput, { Yielded: result })
         }
 
@@ -66,14 +66,14 @@ export default (Commands, Cypress, cy) => {
       })
       .catch(Promise.TimeoutError, () => {
         $errUtils.throwErrByPath('task.timed_out', {
-          onFail: _options._log,
-          args: { task, timeout: _options.timeout },
+          onFail: options._log,
+          args: { task, timeout: options.timeout },
         })
       })
       .catch({ timedOut: true }, (error) => {
         $errUtils.throwErrByPath('task.server_timed_out', {
-          onFail: _options._log,
-          args: { task, timeout: _options.timeout, error: error.message },
+          onFail: options._log,
+          args: { task, timeout: options.timeout, error: error.message },
         })
       })
       .catch((err) => {
@@ -86,13 +86,13 @@ export default (Commands, Cypress, cy) => {
 
         if (err?.isKnownError) {
           $errUtils.throwErrByPath('task.known_error', {
-            onFail: _options._log,
+            onFail: options._log,
             args: { task, error: err.message },
           })
         }
 
         $errUtils.throwErrByPath('task.failed', {
-          onFail: _options._log,
+          onFail: options._log,
           args: { task, error: err?.message || err },
           errProps: {
             appendToStack: {
diff --git a/packages/driver/src/cy/commands/window.ts b/packages/driver/src/cy/commands/window.ts
index 6db9005973cd..9a65f99851ad 100644
--- a/packages/driver/src/cy/commands/window.ts
+++ b/packages/driver/src/cy/commands/window.ts
@@ -96,11 +96,11 @@ export default (Commands, Cypress, cy, state) => {
   }
 
   Commands.addAll({
-    title (options: Partial<Cypress.Loggable & Cypress.Timeoutable> = {}) {
-      const _options: InternalTitleOptions = _.defaults({}, options, { log: true })
+    title (userOptions: Partial<Cypress.Loggable & Cypress.Timeoutable> = {}) {
+      const options: InternalTitleOptions = _.defaults({}, userOptions, { log: true })
 
-      if (_options.log) {
-        _options._log = Cypress.log({ timeout: _options.timeout })
+      if (options.log) {
+        options._log = Cypress.log({ timeout: options.timeout })
       }
 
       const resolveTitle = () => {
@@ -108,7 +108,7 @@ export default (Commands, Cypress, cy, state) => {
 
         const title = (doc && doc.title) || ''
 
-        return cy.verifyUpcomingAssertions(title, _options, {
+        return cy.verifyUpcomingAssertions(title, options, {
           onRetry: resolveTitle,
         })
       }
@@ -116,18 +116,18 @@ export default (Commands, Cypress, cy, state) => {
       return resolveTitle()
     },
 
-    window (options: Partial<Cypress.Loggable & Cypress.Timeoutable> = {}) {
-      const _options: InternalWindowOptions = _.defaults({}, options, { log: true })
+    window (userOptions: Partial<Cypress.Loggable & Cypress.Timeoutable> = {}) {
+      const options: InternalWindowOptions = _.defaults({}, userOptions, { log: true })
 
-      if (_options.log) {
-        _options._log = Cypress.log({ timeout: _options.timeout })
+      if (options.log) {
+        options._log = Cypress.log({ timeout: options.timeout })
       }
 
       const getWindow = () => {
         const window = state('window')
 
         if (!window) {
-          $errUtils.throwErrByPath('window.iframe_undefined', { onFail: _options._log })
+          $errUtils.throwErrByPath('window.iframe_undefined', { onFail: options._log })
         }
 
         return window
@@ -139,15 +139,15 @@ export default (Commands, Cypress, cy, state) => {
         return Promise
         .try(getWindow)
         .catch((err) => {
-          _options.error = err
+          options.error = err
 
-          return cy.retry(retryWindow, _options)
+          return cy.retry(retryWindow, options)
         })
       }
 
       const verifyAssertions = () => {
         return Promise.try(retryWindow).then((win) => {
-          return cy.verifyUpcomingAssertions(win, _options, {
+          return cy.verifyUpcomingAssertions(win, options, {
             onRetry: verifyAssertions,
           })
         })
@@ -156,11 +156,11 @@ export default (Commands, Cypress, cy, state) => {
       return verifyAssertions()
     },
 
-    document (options: Partial<Cypress.Loggable & Cypress.Timeoutable> = {}) {
-      const _options: InternalDocumentOptions = _.defaults({}, options, { log: true })
+    document (userOptions: Partial<Cypress.Loggable & Cypress.Timeoutable> = {}) {
+      const options: InternalDocumentOptions = _.defaults({}, userOptions, { log: true })
 
-      if (_options.log) {
-        _options._log = Cypress.log({ timeout: _options.timeout })
+      if (options.log) {
+        options._log = Cypress.log({ timeout: options.timeout })
       }
 
       const getDocument = () => {
@@ -180,15 +180,15 @@ export default (Commands, Cypress, cy, state) => {
         return Promise
         .try(getDocument)
         .catch((err) => {
-          _options.error = err
+          options.error = err
 
-          return cy.retry(retryDocument, _options)
+          return cy.retry(retryDocument, options)
         })
       }
 
       const verifyAssertions = () => {
         return Promise.try(retryDocument).then((doc) => {
-          return cy.verifyUpcomingAssertions(doc, _options, {
+          return cy.verifyUpcomingAssertions(doc, options, {
             onRetry: verifyAssertions,
           })
         })
@@ -197,25 +197,23 @@ export default (Commands, Cypress, cy, state) => {
       return verifyAssertions()
     },
 
-    viewport (presetOrWidth, heightOrOrientation, options: Partial<Cypress.Loggable> = {}) {
-      const userOptions = options
-
+    viewport (presetOrWidth, heightOrOrientation, userOptions: Partial<Cypress.Loggable> = {}) {
       if (_.isObject(heightOrOrientation)) {
-        options = heightOrOrientation
+        userOptions = heightOrOrientation
       }
 
-      const _options: InternalViewportOptions = _.defaults({}, userOptions, { log: true })
+      const options: InternalViewportOptions = _.defaults({}, userOptions, { log: true })
 
       let height
       let width
 
-      if (_options.log) {
+      if (options.log) {
         // The type of presetOrWidth is either string or number
         // When preset => string
         // When width => number
         const isPreset = typeof presetOrWidth === 'string'
 
-        _options._log = Cypress.log({
+        options._log = Cypress.log({
           consoleProps () {
             const obj: Record<string, string | number> = {}
 
@@ -232,7 +230,7 @@ export default (Commands, Cypress, cy, state) => {
       }
 
       const throwErrBadArgs = () => {
-        return $errUtils.throwErrByPath('viewport.bad_args', { onFail: _options._log })
+        return $errUtils.throwErrByPath('viewport.bad_args', { onFail: options._log })
       }
 
       const widthAndHeightAreValidNumbers = (width, height) => {
@@ -248,7 +246,7 @@ export default (Commands, Cypress, cy, state) => {
       }
 
       if (_.isString(presetOrWidth) && _.isBlank(presetOrWidth)) {
-        $errUtils.throwErrByPath('viewport.empty_string', { onFail: _options._log })
+        $errUtils.throwErrByPath('viewport.empty_string', { onFail: options._log })
       } else if (_.isString(presetOrWidth)) {
         const getPresetDimensions = (preset): number[] => {
           try {
@@ -257,7 +255,7 @@ export default (Commands, Cypress, cy, state) => {
             const presets = _.keys(viewports).join(', ')
 
             $errUtils.throwErrByPath('viewport.missing_preset', {
-              onFail: _options._log,
+              onFail: options._log,
               args: { preset, presets },
             })
 
@@ -270,7 +268,7 @@ export default (Commands, Cypress, cy, state) => {
             const all = validOrientations.join('` or `')
 
             $errUtils.throwErrByPath('viewport.invalid_orientation', {
-              onFail: _options._log,
+              onFail: options._log,
               args: { all, orientation },
             })
           }
@@ -296,7 +294,7 @@ export default (Commands, Cypress, cy, state) => {
         height = heightOrOrientation
 
         if (!widthAndHeightAreWithinBounds(width, height)) {
-          $errUtils.throwErrByPath('viewport.dimensions_out_of_range', { onFail: _options._log })
+          $errUtils.throwErrByPath('viewport.dimensions_out_of_range', { onFail: options._log })
         }
       } else {
         throwErrBadArgs()
@@ -304,8 +302,8 @@ export default (Commands, Cypress, cy, state) => {
 
       return setViewportAndSynchronize(width, height)
       .then((viewport) => {
-        if (_options._log) {
-          _options._log.set(viewport)
+        if (options._log) {
+          options._log.set(viewport)
         }
 
         return null