diff --git a/packages/driver/src/cy/commands/actions/check.coffee b/packages/driver/src/cy/commands/actions/check.coffee
index f20177a68756..407ba1683956 100644
--- a/packages/driver/src/cy/commands/actions/check.coffee
+++ b/packages/driver/src/cy/commands/actions/check.coffee
@@ -18,14 +18,12 @@ checkOrUncheck = (type, subject, values = [], options = {}) ->
     ## make sure we're an array of values
     values = [].concat(values)
 
-  userOptions = Object.assign({}, options)
-
   ## keep an array of subjects which
   ## are potentially reduced down
   ## to new filtered subjects
   matchingElements = []
 
-  _.defaults options,
+  opts = _.defaults {}, options,
     $el: subject
     log: true
     force: false
@@ -58,10 +56,10 @@ checkOrUncheck = (type, subject, values = [], options = {}) ->
 
     if not isAcceptableElement($el)
       node   = $dom.stringify($el)
-      word   = $utils.plural(options.$el, "contains", "is")
+      word   = $utils.plural(opts.$el, "contains", "is")
       phrase = if type is "check" then " and :radio" else ""
       $utils.throwErrByPath "check_uncheck.invalid_element", {
-        onFail: options._log
+        onFail: opts._log
         args: { node, word, phrase, cmd: type }
       }
 
@@ -75,33 +73,33 @@ checkOrUncheck = (type, subject, values = [], options = {}) ->
       "Elements":     $el.length
     }
 
-    if options.log and isElActionable
+    if opts.log and isElActionable
 
       ## figure out the options which actually change the behavior of clicks
-      deltaOptions = $utils.filterOutOptions(options)
+      deltaOptions = $utils.filterOutOptions(opts)
 
-      options._log = Cypress.log
-        options: userOptions
+      opts._log = Cypress.log
+        options: options
         $el: $el
         consoleProps: ->
           _.extend consoleProps, {
             Options: deltaOptions
           }
 
-      options._log.snapshot("before", {next: "after"})
+      opts._log.snapshot("before", {next: "after"})
 
 
       ## if the checkbox was already checked
       ## then notify the user of this note
       ## and bail
       if isNoop($el)
-        if !options.force
+        if !opts.force
           ## still ensure visibility even if the command is noop
-          cy.ensureVisibility($el, options._log)
-        if options._log
+          cy.ensureVisibility($el, opts._log)
+        if opts._log
           inputType = if $el.is(":radio") then "radio" else "checkbox"
           consoleProps.Note = "This #{inputType} was already #{type}ed. No operation took place."
-          options._log.snapshot().end()
+          opts._log.snapshot().end()
 
         return null
 
@@ -112,26 +110,26 @@ checkOrUncheck = (type, subject, values = [], options = {}) ->
         $el: $el
         log: false
         verify: false
-        _log: options._log
-        force: options.force
-        timeout: options.timeout
-        interval: options.interval
+        _log: opts._log
+        force: opts.force
+        timeout: opts.timeout
+        interval: opts.interval
       }).then ->
-        options._log.snapshot().end() if options._log
+        opts._log.snapshot().end() if opts._log
 
         return null
 
   ## return our original subject when our promise resolves
   Promise
-  .resolve(options.$el.toArray())
+  .resolve(opts.$el.toArray())
   .each(checkOrUncheckEl)
   .then ->
     ## filter down our $el to the
     ## matching elements
-    options.$el = options.$el.filter(matchingElements)
+    opts.$el = opts.$el.filter(matchingElements)
 
     do verifyAssertions = =>
-      cy.verifyUpcomingAssertions(options.$el, options, {
+      cy.verifyUpcomingAssertions(opts.$el, opts, {
         onRetry: verifyAssertions
       })
 
diff --git a/packages/driver/src/cy/commands/actions/click.js b/packages/driver/src/cy/commands/actions/click.js
index df409eb05915..eac1a0dd2f89 100644
--- a/packages/driver/src/cy/commands/actions/click.js
+++ b/packages/driver/src/cy/commands/actions/click.js
@@ -41,14 +41,13 @@ module.exports = (Commands, Cypress, cy, state, config) => {
 
     ({ options, position, x, y } = $actionability.getPositionFromArguments(positionOrX, y, options))
 
-    const userOptions = Object.assign({}, options)
     const message = $utils.stringify([
       position ? `position: ${position}` : undefined,
       x ? `x: ${x}` : undefined,
       y ? `y: ${y}` : undefined,
     ])
 
-    _.defaults(options, {
+    const opts = _.defaults({}, options, {
       $el: subject,
       log: true,
       verify: true,
@@ -65,9 +64,9 @@ module.exports = (Commands, Cypress, cy, state, config) => {
 
     // throw if we're trying to click multiple elements
     // and we did not pass the multiple flag
-    if ((options.multiple === false) && (options.$el.length > 1)) {
+    if ((opts.multiple === false) && (opts.$el.length > 1)) {
       $utils.throwErrByPath('click.multiple_elements', {
-        args: { cmd: eventName, num: options.$el.length },
+        args: { cmd: eventName, num: opts.$el.length },
       })
     }
 
@@ -75,23 +74,23 @@ module.exports = (Commands, Cypress, cy, state, config) => {
       let deltaOptions
       const $el = $dom.wrap(el)
 
-      if (options.log) {
+      if (opts.log) {
         // figure out the options which actually change the behavior of clicks
-        deltaOptions = $utils.filterOutOptions(options, defaultOptions)
+        deltaOptions = $utils.filterOutOptions(opts, defaultOptions)
 
-        options._log = Cypress.log({
+        opts._log = Cypress.log({
           message,
-          options: userOptions,
+          options,
           $el,
         })
 
-        options._log.snapshot('before', { next: 'after' })
+        opts._log.snapshot('before', { next: 'after' })
       }
 
-      if (options.errorOnSelect && $el.is('select')) {
+      if (opts.errorOnSelect && $el.is('select')) {
         $utils.throwErrByPath('click.on_select_element', {
           args: { cmd: eventName },
-          onFail: options._log,
+          onFail: opts._log,
         })
       }
 
@@ -105,19 +104,19 @@ module.exports = (Commands, Cypress, cy, state, config) => {
 
         const elClicked = domEvents.moveEvents.el
 
-        if (options._log) {
-          consoleObj = options._log.invoke('consoleProps')
+        if (opts._log) {
+          consoleObj = opts._log.invoke('consoleProps')
         }
 
         const consoleProps = function () {
           consoleObj = _.defaults(consoleObj != null ? consoleObj : {}, {
-            'Applied To': $dom.getElements(options.$el),
-            'Elements': options.$el.length,
+            'Applied To': $dom.getElements(opts.$el),
+            'Elements': opts.$el.length,
             'Coords': _.pick(fromElWindow, 'x', 'y'), // always absolute
             'Options': deltaOptions,
           })
 
-          if (options.$el.get(0) !== elClicked) {
+          if (opts.$el.get(0) !== elClicked) {
             // only do this if $elToClick isnt $el
             consoleObj['Actual Element Clicked'] = $dom.getElements($(elClicked))
           }
@@ -131,18 +130,18 @@ module.exports = (Commands, Cypress, cy, state, config) => {
         .delay($actionability.delay, 'click')
         .then(() => {
           // display the red dot at these coords
-          if (options._log) {
+          if (opts._log) {
             // because we snapshot and output a command per click
             // we need to manually snapshot + end them
-            options._log.set({ coords: fromAutWindow, consoleProps })
+            opts._log.set({ coords: fromAutWindow, consoleProps })
           }
 
           // we need to split this up because we want the coordinates
-          // to mutate our passed in options._log but we dont necessary
+          // to mutate our passed in opts._log but we dont necessary
           // want to snapshot and end our command if we're a different
           // action like (cy.type) and we're borrowing the click action
-          if (options._log && options.log) {
-            return options._log.snapshot().end()
+          if (opts._log && opts.log) {
+            return opts._log.snapshot().end()
           }
         })
         .return(null)
@@ -152,7 +151,7 @@ module.exports = (Commands, Cypress, cy, state, config) => {
       // because we're issuing the clicks synchonrously
       // once we establish the coordinates and the element
       // passes all of the internal checks
-      return $actionability.verify(cy, $el, options, {
+      return $actionability.verify(cy, $el, opts, {
         onScroll ($el, type) {
           return Cypress.action('cy:scrolled', $el, type)
         },
@@ -160,7 +159,7 @@ module.exports = (Commands, Cypress, cy, state, config) => {
         onReady ($elToClick, coords) {
           const { fromElViewport, fromElWindow, fromAutWindow } = coords
 
-          const forceEl = options.force && $elToClick.get(0)
+          const forceEl = opts.force && $elToClick.get(0)
 
           const moveEvents = mouse.move(fromElViewport, forceEl)
 
@@ -177,26 +176,26 @@ module.exports = (Commands, Cypress, cy, state, config) => {
       .catch((err) => {
         // snapshot only on click failure
         err.onFail = function () {
-          if (options._log) {
-            return options._log.snapshot()
+          if (opts._log) {
+            return opts._log.snapshot()
           }
         }
 
         // if we give up on waiting for actionability then
         // lets throw this error and log the command
-        return $utils.throwErr(err, { onFail: options._log })
+        return $utils.throwErr(err, { onFail: opts._log })
       })
     }
 
     return Promise
-    .each(options.$el.toArray(), perform)
+    .each(opts.$el.toArray(), perform)
     .then(() => {
-      if (options.verify === false) {
-        return options.$el
+      if (opts.verify === false) {
+        return opts.$el
       }
 
       const verifyAssertions = () => {
-        return cy.verifyUpcomingAssertions(options.$el, options, {
+        return cy.verifyUpcomingAssertions(opts.$el, opts, {
           onRetry: verifyAssertions,
         })
       }
diff --git a/packages/driver/src/cy/commands/actions/focus.coffee b/packages/driver/src/cy/commands/actions/focus.coffee
index fedc2fc1d82b..61dea2da1ae3 100644
--- a/packages/driver/src/cy/commands/actions/focus.coffee
+++ b/packages/driver/src/cy/commands/actions/focus.coffee
@@ -9,74 +9,68 @@ $actionability = require("../../actionability")
 module.exports = (Commands, Cypress, cy, state, config) ->
   Commands.addAll({ prevSubject: ["element", "window"] }, {
     focus: (subject, options = {}) ->
-      userOptions = Object.assign({}, options)
-
       ## we should throw errors by default!
       ## but allow them to be silenced
-      _.defaults(options, {
+      opts = _.defaults({}, options, {
         $el: subject
         error: true
         log: true
         verify: true
       })
 
-      if isWin = $dom.isWindow(options.$el)
+      if isWin = $dom.isWindow(opts.$el)
         ## get this into a jquery object
-        options.$el = $dom.wrap(options.$el)
+        opts.$el = $dom.wrap(opts.$el)
 
-      if options.log
-        options._log = Cypress.log
-          $el: options.$el
-          options: userOptions
+      if opts.log
+        opts._log = Cypress.log
+          $el: opts.$el
+          options: options
           consoleProps: ->
-            "Applied To": $dom.getElements(options.$el)
+            "Applied To": $dom.getElements(opts.$el)
 
-      el = options.$el.get(0)
+      el = opts.$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)
-      isBody = $dom.isJquery(options.$el) &&
-        $elements.isElement(options.$el.get(0)) &&
-        $elements.isBody(options.$el.get(0))
+      isBody = $dom.isJquery(opts.$el) &&
+        $elements.isElement(opts.$el.get(0)) &&
+        $elements.isBody(opts.$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 not (isWin or isBody or $dom.isFocusable(options.$el))
-        return if options.error is false
+      if not (isWin or isBody or $dom.isFocusable(opts.$el))
+        return if opts.error is false
 
-        node = $dom.stringify(options.$el)
+        node = $dom.stringify(opts.$el)
         $utils.throwErrByPath("focus.invalid_element", {
-          onFail: options._log
+          onFail: opts._log
           args: { node }
         })
 
-      if (num = options.$el.length) and num > 1
-        return if options.error is false
+      if (num = opts.$el.length) and num > 1
+        return if opts.error is false
 
         $utils.throwErrByPath("focus.multiple_elements", {
-          onFail: options._log
+          onFail: opts._log
           args: { num }
         })
 
 
       cy.fireFocus(el)
 
-      # return options.$el if options.verify is false
-
       do verifyAssertions = ->
-        cy.verifyUpcomingAssertions(options.$el, options, {
+        cy.verifyUpcomingAssertions(opts.$el, opts, {
           onRetry: verifyAssertions
         })
 
     blur: (subject, options = {}) ->
-      userOptions = Object.assign({}, options)
-
       ## we should throw errors by default!
       ## but allow them to be silenced
-      _.defaults(options, {
+      opts = _.defaults({}, options, {
         $el: subject
         $focused: cy.getFocused()
         error: true
@@ -85,56 +79,56 @@ module.exports = (Commands, Cypress, cy, state, config) ->
         force: false
       })
 
-      { $el, $focused } = options
+      { $el, $focused } = opts
 
-      if isWin = $dom.isWindow(options.$el)
+      if isWin = $dom.isWindow(opts.$el)
         ## get this into a jquery object
-        options.$el = $dom.wrap(options.$el)
+        opts.$el = $dom.wrap(opts.$el)
 
-      isBody = options.$el.is("body")
+      isBody = opts.$el.is("body")
 
-      if options.log
-        options._log = Cypress.log
-          $el: options.$el
-          options: userOptions
+      if opts.log
+        opts._log = Cypress.log
+          $el: opts.$el
+          options: options
           consoleProps: ->
-            "Applied To": $dom.getElements(options.$el)
+            "Applied To": $dom.getElements(opts.$el)
 
-      if (num = options.$el.length) and num > 1
-        return if options.error is false
+      if (num = opts.$el.length) and num > 1
+        return if opts.error is false
 
         $utils.throwErrByPath("blur.multiple_elements", {
-          onFail: options._log
+          onFail: opts._log
           args: { num }
         })
 
       ## 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 isnt true) and (not $focused) and (not isWin) and (not isBody)
-        return if options.error is false
+      if (opts.force isnt true) and (not $focused) and (not isWin) and (not isBody)
+        return if opts.error is false
 
-        $utils.throwErrByPath("blur.no_focused_element", { onFail: options._log })
+        $utils.throwErrByPath("blur.no_focused_element", { onFail: opts._log })
 
       ## if we're currently window dont check for the wrong
       ## focused element because window will not show up
       ## as $focused
-      if (options.force isnt true) and (not isWin) and (not isBody) and (
-        options.$el.get(0) isnt $focused.get(0)
+      if (opts.force isnt true) and (not isWin) and (not isBody) and (
+        opts.$el.get(0) isnt $focused.get(0)
       )
-        return if options.error is false
+        return if opts.error is false
 
         node = $dom.stringify($focused)
         $utils.throwErrByPath("blur.wrong_focused_element", {
-          onFail: options._log
+          onFail: opts._log
           args: { node }
         })
 
-      el = options.$el.get(0)
+      el = opts.$el.get(0)
 
       cy.fireBlur(el)
 
       do verifyAssertions = ->
-        cy.verifyUpcomingAssertions(options.$el, options, {
+        cy.verifyUpcomingAssertions(opts.$el, opts, {
           onRetry: verifyAssertions
         })
   })
diff --git a/packages/driver/src/cy/commands/actions/scroll.coffee b/packages/driver/src/cy/commands/actions/scroll.coffee
index eefd6e507bab..0da4078a81c0 100644
--- a/packages/driver/src/cy/commands/actions/scroll.coffee
+++ b/packages/driver/src/cy/commands/actions/scroll.coffee
@@ -37,8 +37,7 @@ module.exports = (Commands, Cypress, cy, state, config) ->
       if subject.length > 1
         $utils.throwErrByPath("scrollIntoView.multiple_elements", {args: { num: subject.length }})
 
-      userOptions = Object.assign({}, options)
-      _.defaults(options, {
+      opts = _.defaults({}, options, {
         $el: subject
         $parent: state("window")
         log: true
@@ -48,58 +47,58 @@ module.exports = (Commands, Cypress, cy, state, config) ->
       })
 
       ## figure out the options which actually change the behavior of clicks
-      deltaOptions = $utils.filterOutOptions(options)
+      deltaOptions = $utils.filterOutOptions(opts)
 
       ## 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"))
+      opts.$parent = findScrollableParent(opts.$el, state("window"))
 
-      if options.$parent is state("window")
+      if opts.$parent is 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
+        opts.$parent.contentWindow = opts.$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)
-        $utils.throwErrByPath("scrollIntoView.invalid_duration", {args: { duration: options.duration }})
+      if isNaNOrInfinity(opts.duration)
+        $utils.throwErrByPath("scrollIntoView.invalid_duration", {args: { duration: opts.duration }})
 
-      if !(options.easing is "swing" or options.easing is "linear")
-        $utils.throwErrByPath("scrollIntoView.invalid_easing", {args: { easing: options.easing }})
+      if !(opts.easing is "swing" or opts.easing is "linear")
+        $utils.throwErrByPath("scrollIntoView.invalid_easing", {args: { easing: opts.easing }})
 
-      if options.log
+      if opts.log
         log = {
-          $el: options.$el
-          options: userOptions
+          $el: opts.$el
+          options: options
           consoleProps: ->
             obj = {
               ## merge into consoleProps without mutating it
-              "Applied To": $dom.getElements(options.$el)
-              "Scrolled Element": $dom.getElements(options.$el)
+              "Applied To": $dom.getElements(opts.$el)
+              "Scrolled Element": $dom.getElements(opts.$el)
             }
 
             return obj
         }
 
-        options._log = Cypress.log(log)
+        opts._log = Cypress.log(log)
 
       if not parentIsWin
         ## scroll the parent into view first
         ## before attemp
-        options.$parent[0].scrollIntoView()
+        opts.$parent[0].scrollIntoView()
 
       scrollIntoView = ->
         new Promise (resolve, reject) =>
           ## scroll our axes
-          $(options.$parent).scrollTo(options.$el, {
-            axis:     options.axis
-            easing:   options.easing
-            duration: options.duration
-            offset:   options.offset
+          $(opts.$parent).scrollTo(opts.$el, {
+            axis:     opts.axis
+            easing:   opts.easing
+            duration: opts.duration
+            offset:   opts.offset
             done: (animation, jumpedToEnd) ->
-              resolve(options.$el)
+              resolve(opts.$el)
             fail: (animation, jumpedToEnd) ->
               ## its Promise object is rejected
               try
@@ -108,13 +107,13 @@ module.exports = (Commands, Cypress, cy, state, config) ->
                 reject(err)
             always: ->
               if parentIsWin
-                delete options.$parent.contentWindow
+                delete opts.$parent.contentWindow
           })
 
       scrollIntoView()
       .then ($el) ->
         do verifyAssertions = ->
-          cy.verifyUpcomingAssertions($el, options, {
+          cy.verifyUpcomingAssertions($el, opts, {
             onRetry: verifyAssertions
           })
   })
@@ -195,8 +194,7 @@ module.exports = (Commands, Cypress, cy, state, config) ->
       if (!isWin && $container.length > 1)
         $utils.throwErrByPath("scrollTo.multiple_containers", {args: { num: $container.length }})
 
-      userOptions = Object.assign({}, options)
-      _.defaults(options, {
+      opts = _.defaults({}, options, {
         $el: $container
         log: true
         duration: 0
@@ -208,21 +206,21 @@ module.exports = (Commands, Cypress, cy, state, config) ->
 
       ## if we cannot parse an integer out of duration
       ## which could be 500 or "500", then it's NaN...throw
-      if isNaNOrInfinity(options.duration)
-        $utils.throwErrByPath("scrollTo.invalid_duration", {args: { duration: options.duration }})
+      if isNaNOrInfinity(opts.duration)
+        $utils.throwErrByPath("scrollTo.invalid_duration", {args: { duration: opts.duration }})
 
-      if !(options.easing is "swing" or options.easing is "linear")
-        $utils.throwErrByPath("scrollTo.invalid_easing", {args: { easing: options.easing }})
+      if !(opts.easing is "swing" or opts.easing is "linear")
+        $utils.throwErrByPath("scrollTo.invalid_easing", {args: { easing: opts.easing }})
 
       ## 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) or isNaNOrInfinity(options.x)
+      if isNaNOrInfinity(opts.y) or isNaNOrInfinity(opts.x)
         $utils.throwErrByPath("scrollTo.invalid_target", {args: { x, y }})
 
-      if options.log
+      if opts.log
         deltaOptions = $utils.stringify(
-          $utils.filterOutOptions(options, {duration: 0, easing: 'swing'})
+          $utils.filterOutOptions(opts, {duration: 0, easing: 'swing'})
         )
 
         messageArgs = []
@@ -234,7 +232,7 @@ module.exports = (Commands, Cypress, cy, state, config) ->
 
         log = {
           message: messageArgs.join(", "),
-          options: userOptions
+          options: options
           consoleProps: ->
             ## merge into consoleProps without mutating it
             obj = {}
@@ -247,32 +245,32 @@ module.exports = (Commands, Cypress, cy, state, config) ->
             if deltaOptions
               obj.Options = deltaOptions
 
-            obj["Scrolled Element"] = $dom.getElements(options.$el)
+            obj["Scrolled Element"] = $dom.getElements(opts.$el)
 
             return obj
         }
 
-        if !isWin then log.$el = options.$el
+        if !isWin then log.$el = opts.$el
 
-        options._log = Cypress.log(log)
+        opts._log = Cypress.log(log)
 
       ensureScrollability = ->
         try
           ## make sure our container can even be scrolled
           cy.ensureScrollability($container, "scrollTo")
         catch err
-          options.error = err
-          cy.retry(ensureScrollability, options)
+          opts.error = err
+          cy.retry(ensureScrollability, opts)
 
       scrollTo = ->
         new Promise (resolve, reject) ->
           ## scroll our axis'
-          $(options.$el).scrollTo({left: x, top: y}, {
-            axis:     options.axis
-            easing:   options.easing
-            duration: options.duration
+          $(opts.$el).scrollTo({left: x, top: y}, {
+            axis:     opts.axis
+            easing:   opts.easing
+            duration: opts.duration
             done: (animation, jumpedToEnd) ->
-              resolve(options.$el)
+              resolve(opts.$el)
             fail: (animation, jumpedToEnd) ->
               ## its Promise object is rejected
               try
@@ -282,14 +280,14 @@ module.exports = (Commands, Cypress, cy, state, config) ->
           })
 
           if isWin
-            delete options.$el.contentWindow
+            delete opts.$el.contentWindow
 
       Promise
       .try(ensureScrollability)
       .then(scrollTo)
       .then ($el) ->
         do verifyAssertions = ->
-          cy.verifyUpcomingAssertions($el, options, {
+          cy.verifyUpcomingAssertions($el, opts, {
             onRetry: verifyAssertions
           })
   })
diff --git a/packages/driver/src/cy/commands/actions/select.coffee b/packages/driver/src/cy/commands/actions/select.coffee
index dd8786136127..52cfbb9419d7 100644
--- a/packages/driver/src/cy/commands/actions/select.coffee
+++ b/packages/driver/src/cy/commands/actions/select.coffee
@@ -10,28 +10,27 @@ newLineRe = /\n/g
 module.exports = (Commands, Cypress, cy, state, config) ->
   Commands.addAll({ prevSubject: "element" }, {
     select: (subject, valueOrText, options = {}) ->
-      userOptions = Object.assign({}, options)
-      _.defaults options,
+      opts = _.defaults {}, options,
         $el: subject
         log: true
         force: false
 
       consoleProps = {}
 
-      if options.log
+      if opts.log
         ## figure out the options which actually change the behavior of clicks
-        deltaOptions = $utils.filterOutOptions(options)
+        deltaOptions = $utils.filterOutOptions(opts)
 
-        options._log = Cypress.log
-          options: userOptions
-          $el: options.$el
+        opts._log = Cypress.log
+          options: options
+          $el: opts.$el
           consoleProps: ->
             ## merge into consoleProps without mutating it
             _.extend {}, consoleProps,
-              "Applied To": $dom.getElements(options.$el)
+              "Applied To": $dom.getElements(opts.$el)
               "Options":    deltaOptions
 
-        options._log.snapshot("before", {next: "after"})
+        opts._log.snapshot("before", {next: "after"})
 
       ## if subject is a <select> el assume we are filtering down its
       ## options to a specific option first by value and then by text
@@ -44,16 +43,16 @@ module.exports = (Commands, Cypress, cy, state, config) ->
       ## or texts and clear the previous selections which matches jQuery's
       ## behavior
 
-      if not options.$el.is("select")
-        node = $dom.stringify(options.$el)
+      if not opts.$el.is("select")
+        node = $dom.stringify(opts.$el)
         $utils.throwErrByPath "select.invalid_element", { args: { node } }
 
-      if (num = options.$el.length) and num > 1
+      if (num = opts.$el.length) and num > 1
         $utils.throwErrByPath "select.multiple_elements", { args: { num } }
 
       ## normalize valueOrText if its not an array
       valueOrText = [].concat(valueOrText)
-      multiple    = options.$el.prop("multiple")
+      multiple    = opts.$el.prop("multiple")
 
       ## throw if we're not a multiple select and we've
       ## passed an array of values
@@ -62,13 +61,13 @@ module.exports = (Commands, Cypress, cy, state, config) ->
 
       getOptions = ->
         ## throw if <select> is disabled
-        if options.$el.prop("disabled")
-          node = $dom.stringify(options.$el)
+        if opts.$el.prop("disabled")
+          node = $dom.stringify(opts.$el)
           $utils.throwErrByPath "select.disabled", { args: { node } }
 
         values = []
         optionEls = []
-        optionsObjects = options.$el.find("option").map((index, el) ->
+        optionsObjects = opts.$el.find("option").map((index, el) ->
           ## push the value in values array if its
           ## found within the valueOrText
           value = $elements.getNativeProp(el, "value")
@@ -130,9 +129,9 @@ module.exports = (Commands, Cypress, cy, state, config) ->
         Promise
         .try(getOptions)
         .catch (err) ->
-          options.error = err
+          opts.error = err
 
-          cy.retry(retryOptions, options)
+          cy.retry(retryOptions, opts)
 
       Promise
       .try(retryOptions)
@@ -142,15 +141,15 @@ module.exports = (Commands, Cypress, cy, state, config) ->
         ## preserve the selected values
         consoleProps.Selected = values
 
-        cy.now("click", options.$el, {
-          $el: options.$el
+        cy.now("click", opts.$el, {
+          $el: opts.$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: opts._log
+          force: opts.force
+          timeout: opts.timeout
+          interval: opts.interval
         }).then( ->
 
           ## TODO:
@@ -170,8 +169,8 @@ module.exports = (Commands, Cypress, cy, state, config) ->
               log: false
               verify: false
               force: true ## always force the click to happen on the <option>
-              timeout: options.timeout
-              interval: options.interval
+              timeout: opts.timeout
+              interval: opts.interval
             })
           .then ->
             ## reset the selects value after we've
@@ -180,7 +179,7 @@ module.exports = (Commands, Cypress, cy, state, config) ->
             ## TODO: shouldn't we be updating the values
             ## as we click the <option> instead of
             ## all afterwards?
-            options.$el.val(values)
+            opts.$el.val(values)
 
             if notAllUniqueValues
               ## if all the values are the same and the user is trying to
@@ -193,15 +192,15 @@ module.exports = (Commands, Cypress, cy, state, config) ->
                 selectedIndex = index
                 $el.prop("selected", "selected")
 
-              options.$el[0].selectedIndex = selectedIndex
-              options.$el[0].selectedOptions = _.map optionEls, ($el) -> $el.get()
+              opts.$el[0].selectedIndex = selectedIndex
+              opts.$el[0].selectedOptions = _.map optionEls, ($el) -> $el.get()
 
             input = new Event "input", {
               bubbles: true
               cancelable: false
             }
 
-            options.$el.get(0).dispatchEvent(input)
+            opts.$el.get(0).dispatchEvent(input)
 
             ## yup manually create this change event
             ## 1.6.5. HTML event types
@@ -209,10 +208,10 @@ module.exports = (Commands, Cypress, cy, state, config) ->
             change = document.createEvent("HTMLEvents")
             change.initEvent("change", true, false)
 
-            options.$el.get(0).dispatchEvent(change)
+            opts.$el.get(0).dispatchEvent(change)
         ).then ->
           do verifyAssertions = ->
-            cy.verifyUpcomingAssertions(options.$el, options, {
+            cy.verifyUpcomingAssertions(opts.$el, opts, {
               onRetry: verifyAssertions
             })
   })
diff --git a/packages/driver/src/cy/commands/actions/submit.coffee b/packages/driver/src/cy/commands/actions/submit.coffee
index 3359b4ed9411..eaf3fa789978 100644
--- a/packages/driver/src/cy/commands/actions/submit.coffee
+++ b/packages/driver/src/cy/commands/actions/submit.coffee
@@ -8,8 +8,7 @@ $actionability = require("../../actionability")
 module.exports = (Commands, Cypress, cy, state, config) ->
   Commands.addAll({ prevSubject: "element" }, {
     submit: (subject, options = {}) ->
-      userOptions = Object.assign({}, options)
-      _.defaults options,
+      opts = _.defaults {}, options,
         log: true
         $el: subject
 
@@ -17,30 +16,30 @@ module.exports = (Commands, Cypress, cy, state, config) ->
       ## 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
-      form = options.$el.get(0)
+      form = opts.$el.get(0)
 
-      if options.log
-        options._log = Cypress.log({
-          $el: options.$el
-          options: userOptions
+      if opts.log
+        opts._log = Cypress.log({
+          $el: opts.$el
+          options: options
           consoleProps: ->
-            "Applied To": $dom.getElements(options.$el)
-            Elements: options.$el.length
+            "Applied To": $dom.getElements(opts.$el)
+            Elements: opts.$el.length
         })
 
-        options._log.snapshot("before", {next: "after"})
+        opts._log.snapshot("before", {next: "after"})
 
-      if not options.$el.is("form")
-        node = $dom.stringify(options.$el)
-        word = $utils.plural(options.$el, "contains", "is")
+      if not opts.$el.is("form")
+        node = $dom.stringify(opts.$el)
+        word = $utils.plural(opts.$el, "contains", "is")
         $utils.throwErrByPath("submit.not_on_form", {
-          onFail: options._log
+          onFail: opts._log
           args: { node, word }
         })
 
-      if (num = options.$el.length) and num > 1
+      if (num = opts.$el.length) and num > 1
         $utils.throwErrByPath("submit.multiple_forms", {
-          onFail: options._log
+          onFail: opts._log
           args: { num }
         })
 
@@ -61,7 +60,7 @@ module.exports = (Commands, Cypress, cy, state, config) ->
       .delay($actionability.delay, "submit")
       .then ->
         do verifyAssertions = =>
-          cy.verifyUpcomingAssertions(options.$el, options, {
+          cy.verifyUpcomingAssertions(opts.$el, opts, {
             onRetry: verifyAssertions
           })
   })
diff --git a/packages/driver/src/cy/commands/actions/trigger.coffee b/packages/driver/src/cy/commands/actions/trigger.coffee
index bfd496b68d3f..9a50777fd835 100644
--- a/packages/driver/src/cy/commands/actions/trigger.coffee
+++ b/packages/driver/src/cy/commands/actions/trigger.coffee
@@ -21,8 +21,7 @@ module.exports = (Commands, Cypress, cy, state, config) ->
     trigger: (subject, eventName, positionOrX, y, options = {}) ->
       {options, position, x, y} = $actionability.getPositionFromArguments(positionOrX, y, options)
 
-      userOptions = Object.assign({}, options)
-      _.defaults(options, {
+      opts = _.defaults({}, options, {
         log: true
         $el: subject
         bubbles: true
@@ -34,19 +33,19 @@ module.exports = (Commands, Cypress, cy, state, config) ->
         animationDistanceThreshold: config("animationDistanceThreshold")
       })
 
-      if $dom.isWindow(options.$el)
+      if $dom.isWindow(opts.$el)
         ## get this into a jquery object
-        options.$el = $dom.wrap(options.$el)
+        opts.$el = $dom.wrap(opts.$el)
 
 
       ## omit entries we know aren't part of an event, but pass anything
       ## else through so user can specify what the event object needs
-      eventOptions = _.omit(options, "log", "$el", "position", "x", "y", "waitForAnimations", "animationDistanceThreshold")
+      eventOptions = _.omit(opts, "log", "$el", "position", "x", "y", "waitForAnimations", "animationDistanceThreshold")
 
-      if options.log
-        options._log = Cypress.log({
+      if opts.log
+        opts._log = Cypress.log({
           $el: subject
-          options: userOptions
+          options: options
           consoleProps: ->
             {
               "Yielded": subject
@@ -54,18 +53,18 @@ module.exports = (Commands, Cypress, cy, state, config) ->
             }
         })
 
-        options._log.snapshot("before", {next: "after"})
+        opts._log.snapshot("before", {next: "after"})
 
       if not _.isString(eventName)
         $utils.throwErrByPath("trigger.invalid_argument", {
-          onFail: options._log
+          onFail: opts._log
           args: { eventName }
         })
 
-      if options.$el.length > 1
+      if opts.$el.length > 1
         $utils.throwErrByPath("trigger.multiple_elements", {
-          onFail: options._log
-          args: { num: options.$el.length }
+          onFail: opts._log
+          args: { num: opts.$el.length }
         })
 
       dispatchEarly = false
@@ -75,22 +74,22 @@ module.exports = (Commands, Cypress, cy, state, config) ->
       if $dom.isWindow(subject) or $dom.isDocument(subject)
         dispatchEarly = true
       else
-        subject = options.$el.first()
+        subject = opts.$el.first()
 
       trigger = ->
         if dispatchEarly
           return dispatch(subject, eventName, eventOptions)
 
-        $actionability.verify(cy, subject, options, {
+        $actionability.verify(cy, subject, opts, {
           onScroll: ($el, type) ->
             Cypress.action("cy:scrolled", $el, type)
 
           onReady: ($elToClick, coords) ->
             { fromElWindow, fromElViewport, fromAutWindow } = coords
 
-            if options._log
+            if opts._log
               ## display the red dot at these coords
-              options._log.set({
+              opts._log.set({
                 coords: fromAutWindow
               })
 
@@ -110,7 +109,7 @@ module.exports = (Commands, Cypress, cy, state, config) ->
       .try(trigger)
       .then ->
         do verifyAssertions = ->
-          cy.verifyUpcomingAssertions(subject, options, {
+          cy.verifyUpcomingAssertions(subject, opts, {
             onRetry: verifyAssertions
           })
   })
diff --git a/packages/driver/src/cy/commands/actions/type.js b/packages/driver/src/cy/commands/actions/type.js
index 889ad791420a..f6d1b06c83af 100644
--- a/packages/driver/src/cy/commands/actions/type.js
+++ b/packages/driver/src/cy/commands/actions/type.js
@@ -15,12 +15,9 @@ module.exports = function (Commands, Cypress, cy, state, config) {
   function type (subject, chars, options = {}) {
     let updateTable
 
-    const userOptions = Object.assign({}, options)
-
-    options = _.clone(options)
     // allow the el we're typing into to be
     // changed by options -- used by cy.clear()
-    _.defaults(options, {
+    const opts = _.defaults({}, options, {
       $el: subject,
       log: true,
       verify: true,
@@ -32,9 +29,9 @@ module.exports = function (Commands, Cypress, cy, state, config) {
       animationDistanceThreshold: config('animationDistanceThreshold'),
     })
 
-    if (options.log) {
+    if (opts.log) {
       // figure out the options which actually change the behavior of clicks
-      const deltaOptions = $utils.filterOutOptions(options)
+      const deltaOptions = $utils.filterOutOptions(opts)
 
       const table = {}
 
@@ -83,14 +80,14 @@ module.exports = function (Commands, Cypress, cy, state, config) {
         , {})
       }
 
-      options._log = Cypress.log({
+      opts._log = Cypress.log({
         message: [chars, deltaOptions],
-        options: userOptions,
-        $el: options.$el,
+        options,
+        $el: opts.$el,
         consoleProps () {
           return {
             'Typed': chars,
-            'Applied To': $dom.getElements(options.$el),
+            'Applied To': $dom.getElements(opts.$el),
             'Options': deltaOptions,
             'table': {
               // mouse events tables will take up slot 1 if they're present
@@ -106,26 +103,26 @@ module.exports = function (Commands, Cypress, cy, state, config) {
         },
       })
 
-      options._log.snapshot('before', { next: 'after' })
+      opts._log.snapshot('before', { next: 'after' })
     }
 
-    if (options.$el.length > 1) {
+    if (opts.$el.length > 1) {
       $utils.throwErrByPath('type.multiple_elements', {
-        onFail: options._log,
-        args: { num: options.$el.length },
+        onFail: opts._log,
+        args: { num: opts.$el.length },
       })
     }
 
     if (!(_.isString(chars) || _.isFinite(chars))) {
       $utils.throwErrByPath('type.wrong_type', {
-        onFail: options._log,
+        onFail: opts._log,
         args: { chars },
       })
     }
 
     if (_.isString(chars) && _.isEmpty(chars)) {
       $utils.throwErrByPath('type.empty_string', {
-        onFail: options._log,
+        onFail: opts._log,
         args: { chars },
       })
     }
@@ -147,7 +144,7 @@ module.exports = function (Commands, Cypress, cy, state, config) {
 
     const type = function () {
       const simulateSubmitHandler = function () {
-        const form = options.$el.parents('form')
+        const form = opts.$el.parents('form')
 
         if (!form.length) {
           return
@@ -238,18 +235,18 @@ module.exports = 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(opts.$el.get(0))
+      const isTextarea = $elements.isTextarea(opts.$el.get(0))
 
       return keyboard.type({
-        $el: options.$el,
+        $el: opts.$el,
         chars,
-        delay: options.delay,
-        release: options.release,
-        parseSpecialCharSequences: options.parseSpecialCharSequences,
+        delay: opts.delay,
+        release: opts.release,
+        parseSpecialCharSequences: opts.parseSpecialCharSequences,
         window: win,
-        force: options.force,
-        onFail: options._log,
+        force: opts.force,
+        onFail: opts._log,
 
         updateValue (el, key, charsToType) {
           // in these cases, the value must only be set after all
@@ -267,7 +264,7 @@ module.exports = function (Commands, Cypress, cy, state, config) {
         },
 
         onAfterType () {
-          if (options.release === true) {
+          if (opts.release === true) {
             state('keyboardModifiers', null)
           }
         },
@@ -276,7 +273,7 @@ module.exports = 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
-          return cy.timeout(totalKeys * options.delay, true, 'type')
+          return cy.timeout(totalKeys * opts.delay, true, 'type')
         },
 
         onEvent: updateTable || _.noop,
@@ -338,11 +335,11 @@ module.exports = function (Commands, Cypress, cy, state, config) {
 
         onNoMatchingSpecialChars (chars, allChars) {
           if (chars === 'tab') {
-            return $utils.throwErrByPath('type.tab', { onFail: options._log })
+            return $utils.throwErrByPath('type.tab', { onFail: opts._log })
           }
 
           return $utils.throwErrByPath('type.invalid', {
-            onFail: options._log,
+            onFail: opts._log,
             args: { chars: `{${chars}}`, allChars },
           })
         },
@@ -351,13 +348,13 @@ module.exports = function (Commands, Cypress, cy, state, config) {
 
     const handleFocused = function () {
       // if it's the body, don't need to worry about focus
-      const isBody = options.$el.is('body')
+      const isBody = opts.$el.is('body')
 
       if (isBody) {
         return type()
       }
 
-      options.ensure = {
+      opts.ensure = {
         position: true,
         visibility: true,
         notDisabled: true,
@@ -371,14 +368,14 @@ module.exports = 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(opts.$el.get(0))) {
         debug('element is already focused, only checking readOnly property')
-        options.ensure = {
+        opts.ensure = {
           notReadonly: true,
         }
       }
 
-      return $actionability.verify(cy, options.$el, options, {
+      return $actionability.verify(cy, opts.$el, opts, {
         onScroll ($el, type) {
           return Cypress.action('cy:scrolled', $el, type)
         },
@@ -400,16 +397,16 @@ module.exports = function (Commands, Cypress, cy, state, config) {
             $el: $elToClick,
             log: false,
             verify: false,
-            _log: options._log,
+            _log: opts._log,
             force: true, // force the click, avoid waiting
-            timeout: options.timeout,
-            interval: options.interval,
+            timeout: opts.timeout,
+            interval: opts.interval,
             errorOnSelect: false,
           })
           .then(() => {
-            if (!options.force && $elements.getActiveElByDocument($elToClick[0].ownerDocument) === null) {
+            if (!opts.force && $elements.getActiveElByDocument($elToClick[0].ownerDocument) === null) {
               const node = $dom.stringify($elToClick)
-              const onFail = options._log
+              const onFail = opts._log
 
               if ($dom.isTextLike($elToClick[0])) {
                 $utils.throwErrByPath('type.not_actionable_textlike', {
@@ -440,12 +437,12 @@ module.exports = 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 (opts.verify === false) {
+          return opts.$el
         }
 
         const verifyAssertions = () => {
-          return cy.verifyUpcomingAssertions(options.$el, options, {
+          return cy.verifyUpcomingAssertions(opts.$el, opts, {
             onRetry: verifyAssertions,
           })
         }
@@ -456,9 +453,7 @@ module.exports = function (Commands, Cypress, cy, state, config) {
   }
 
   function clear (subject, options = {}) {
-    const userOptions = Object.assign({}, options)
-
-    _.defaults(options, {
+    const opts = _.defaults({}, options, {
       log: true,
       force: false,
     })
@@ -468,12 +463,12 @@ module.exports = function (Commands, Cypress, cy, state, config) {
     const clear = function (el) {
       const $el = $dom.wrap(el)
 
-      if (options.log) {
+      if (opts.log) {
         // figure out the options which actually change the behavior of clicks
-        const deltaOptions = $utils.filterOutOptions(options)
+        const deltaOptions = $utils.filterOutOptions(opts)
 
-        options._log = Cypress.log({
-          options: userOptions,
+        opts._log = Cypress.log({
+          options,
           $el,
           consoleProps () {
             return {
@@ -491,7 +486,7 @@ module.exports = function (Commands, Cypress, cy, state, config) {
         const word = $utils.plural(subject, 'contains', 'is')
 
         $utils.throwErrByPath('clear.invalid_element', {
-          onFail: options._log,
+          onFail: opts._log,
           args: { word, node },
         })
       }
@@ -500,13 +495,13 @@ module.exports = 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,
+        _log: opts._log,
+        force: opts.force,
+        timeout: opts.timeout,
+        interval: opts.interval,
       }).then(() => {
-        if (options._log) {
-          options._log.snapshot().end()
+        if (opts._log) {
+          opts._log.snapshot().end()
         }
 
         return null
@@ -518,7 +513,7 @@ module.exports = function (Commands, Cypress, cy, state, config) {
     .each(clear)
     .then(() => {
       const verifyAssertions = () => {
-        return cy.verifyUpcomingAssertions(subject, options, {
+        return cy.verifyUpcomingAssertions(subject, opts, {
           onRetry: verifyAssertions,
         })
       }
diff --git a/packages/driver/src/cy/commands/angular.coffee b/packages/driver/src/cy/commands/angular.coffee
index f1b47f6eedd3..0a18d0fd0f54 100644
--- a/packages/driver/src/cy/commands/angular.coffee
+++ b/packages/driver/src/cy/commands/angular.coffee
@@ -77,16 +77,16 @@ module.exports = (Commands, Cypress, cy, state, config) ->
       ## system you're using
       $utils.throwErrByPath "ng.no_global" if not state("window").angular
 
-      _.defaults options, {log: true}
+      opts = _.defaults {}, options, {log: true}
 
-      if options.log
-        options._log = Cypress.log()
+      if opts.log
+        opts._log = Cypress.log()
 
       switch type
         when "model"
-          findByNgAttr("model", "model=", selector, options)
+          findByNgAttr("model", "model=", selector, opts)
         when "repeater"
-          findByNgAttr("repeater", "repeat*=", selector, options)
+          findByNgAttr("repeater", "repeat*=", selector, opts)
         when "binding"
-          findByNgBinding(selector, options)
+          findByNgBinding(selector, opts)
   })
diff --git a/packages/driver/src/cy/commands/clock.coffee b/packages/driver/src/cy/commands/clock.coffee
index 2aff5be52e08..87211bf93e85 100644
--- a/packages/driver/src/cy/commands/clock.coffee
+++ b/packages/driver/src/cy/commands/clock.coffee
@@ -51,12 +51,12 @@ module.exports = (Commands, Cypress, cy, state, config) ->
       if methods? and not (_.isArray(methods) and _.every(methods, _.isString))
         $utils.throwErrByPath("clock.invalid_2nd_arg", {args: {arg: JSON.stringify(methods)}})
 
-      _.defaults options, {
+      opts = _.defaults {}, options, {
         log: true
       }
 
       log = (name, message, snapshot = true, consoleProps = {}) ->
-        if not options.log
+        if not opts.log
           return
 
         details = clock.details()
diff --git a/packages/driver/src/cy/commands/connectors.coffee b/packages/driver/src/cy/commands/connectors.coffee
index 306dfd3d5818..123cfd2e851e 100644
--- a/packages/driver/src/cy/commands/connectors.coffee
+++ b/packages/driver/src/cy/commands/connectors.coffee
@@ -44,7 +44,7 @@ module.exports = (Commands, Cypress, cy, state, config) ->
       fn = options
       options = {}
 
-    _.defaults options,
+    opts = _.defaults {}, options,
       timeout: cy.timeout()
 
     ## clear the timeout since we are handling
@@ -111,7 +111,7 @@ module.exports = (Commands, Cypress, cy, state, config) ->
 
       if ret? and invokedCyCommand and not ret.then
         $utils.throwErrByPath("then.callback_mixes_sync_and_async", {
-          onFail: options._log
+          onFail: opts._log
           args: { value: $utils.stringify(ret) }
         })
 
@@ -119,17 +119,17 @@ module.exports = (Commands, Cypress, cy, state, config) ->
 
     Promise
     .try(getRet)
-    .timeout(options.timeout)
+    .timeout(opts.timeout)
     .then (ret) ->
       ## if ret is undefined then
       ## resolve with the existing subject
       return if _.isUndefined(ret) then subject else ret
     .catch Promise.TimeoutError, ->
       $utils.throwErrByPath "invoke_its.timed_out", {
-        onFail: options._log
+        onFail: opts._log
         args: {
           cmd: name
-          timeout: options.timeout
+          timeout: opts.timeout
           func: fn.toString()
         }
       }
diff --git a/packages/driver/src/cy/commands/cookies.coffee b/packages/driver/src/cy/commands/cookies.coffee
index 2129f404b99d..dca4ff5e4aa2 100644
--- a/packages/driver/src/cy/commands/cookies.coffee
+++ b/packages/driver/src/cy/commands/cookies.coffee
@@ -78,22 +78,20 @@ module.exports = (Commands, Cypress, cy, state, config) ->
 
   Commands.addAll({
     getCookie: (name, options = {}) ->
-      userOptions = Object.assign({}, options)
-
-      _.defaults options, {
+      opts = _.defaults {}, options, {
         log: true
         timeout: config("responseTimeout")
       }
 
-      if options.log
-        options._log = Cypress.log({
+      if opts.log
+        opts._log = Cypress.log({
           message: name
-          options: userOptions
+          options: options
           displayName: "get cookie"
           consoleProps: ->
             obj = {}
 
-            if c = options.cookie
+            if c = opts.cookie
               obj["Yielded"] = c
             else
               obj["Yielded"] = "null"
@@ -102,51 +100,48 @@ module.exports = (Commands, Cypress, cy, state, config) ->
             obj
         })
 
-      onFail = options._log
+      onFail = opts._log
 
       if not _.isString(name)
         $utils.throwErrByPath("getCookie.invalid_argument", { onFail })
 
       validateCookieName('getCookie', name, onFail)
 
-      automateCookies("get:cookie", {name: name}, options._log, options.timeout)
+      automateCookies("get:cookie", {name: name}, opts._log, opts.timeout)
       .then (resp) ->
-        options.cookie = resp
+        opts.cookie = resp
 
         return resp
 
     getCookies: (options = {}) ->
-      userOptions = Object.assign({}, options)
-
-      _.defaults options, {
+      opts = _.defaults {}, options, {
         log: true
         timeout: config("responseTimeout")
       }
 
-      if options.log
-        options._log = Cypress.log({
+      if opts.log
+        opts._log = Cypress.log({
           message: ""
-          options: userOptions
+          options: options
           displayName: "get cookies"
           consoleProps: ->
             obj = {}
 
-            if c = options.cookies
+            if c = opts.cookies
               obj["Yielded"] = c
               obj["Num Cookies"] = c.length
 
             obj
         })
 
-      automateCookies("get:cookies", _.pick(options, 'domain'), options._log, options.timeout)
+      automateCookies("get:cookies", _.pick(opts, 'domain'), opts._log, opts.timeout)
       .then (resp) ->
-        options.cookies = resp
+        opts.cookies = resp
 
         return resp
 
-    setCookie: (name, value, userOptions = {}) ->
-      options = _.clone(userOptions)
-      _.defaults options, {
+    setCookie: (name, value, options = {}) ->
+      opts = _.defaults {}, options, {
         name: name
         value: value
         path: "/"
@@ -157,23 +152,23 @@ module.exports = (Commands, Cypress, cy, state, config) ->
         timeout: config("responseTimeout")
       }
 
-      cookie = _.pick(options, COOKIE_PROPS)
+      cookie = _.pick(opts, COOKIE_PROPS)
 
-      if options.log
-        options._log = Cypress.log({
+      if opts.log
+        opts._log = Cypress.log({
           message: [name, value]
           displayName: "set cookie"
-          options: userOptions
+          options: options
           consoleProps: ->
             obj = {}
 
-            if c = options.cookie
+            if c = opts.cookie
               obj["Yielded"] = c
 
             obj
         })
 
-      onFail = options._log
+      onFail = opts._log
 
       if not _.isString(name) or not _.isString(value)
         Cypress.utils.throwErrByPath("setCookie.invalid_arguments", { onFail })
@@ -183,9 +178,9 @@ module.exports = (Commands, Cypress, cy, state, config) ->
       if cookieParser.parseCookieValue(value) == null
         Cypress.utils.throwErrByPath("setCookie.invalid_value", { args: { value }, onFail })
 
-      automateCookies("set:cookie", cookie, options._log, options.timeout)
+      automateCookies("set:cookie", cookie, opts._log, opts.timeout)
       .then (resp) ->
-        options.cookie = resp
+        opts.cookie = resp
 
         return resp
       .catch (err) ->
@@ -198,23 +193,22 @@ module.exports = (Commands, Cypress, cy, state, config) ->
         })
 
     clearCookie: (name, options = {}) ->
-      userOptions = Object.assign({}, options)
-      _.defaults options, {
+      opts = _.defaults {}, options, {
         log: true
         timeout: config("responseTimeout")
       }
 
-      if options.log
-        options._log = Cypress.log({
+      if opts.log
+        opts._log = Cypress.log({
           message: name
-          options: userOptions
+          options: options
           displayName: "clear cookie"
           consoleProps: ->
             obj = {}
 
             obj["Yielded"] = "null"
 
-            if c = options.cookie
+            if c = opts.cookie
               obj["Cleared Cookie"] = c
             else
               obj["Note"] = "No cookie with the name: '#{name}' was found or removed."
@@ -222,7 +216,7 @@ module.exports = (Commands, Cypress, cy, state, config) ->
             obj
         })
 
-      onFail = options._log
+      onFail = opts._log
 
       if not _.isString(name)
         $utils.throwErrByPath("clearCookie.invalid_argument", { onFail })
@@ -230,31 +224,30 @@ module.exports = (Commands, Cypress, cy, state, config) ->
       validateCookieName('clearCookie', name, onFail)
 
       ## TODO: prevent clearing a cypress namespace
-      automateCookies("clear:cookie", {name: name}, options._log, options.timeout)
+      automateCookies("clear:cookie", {name: name}, opts._log, opts.timeout)
       .then (resp) ->
-        options.cookie = resp
+        opts.cookie = resp
 
         ## null out the current subject
         return null
 
     clearCookies: (options = {}) ->
-      userOptions = Object.assign({}, options)
-      _.defaults options, {
+      opts = _.defaults {}, options, {
         log: true
         timeout: config("responseTimeout")
       }
 
-      if options.log
-        options._log = Cypress.log({
+      if opts.log
+        opts._log = Cypress.log({
           message: ""
-          options: userOptions
+          options: options
           displayName: "clear cookies"
           consoleProps: ->
             obj = {}
 
             obj["Yielded"] = "null"
 
-            if (c = options.cookies) and c.length
+            if (c = opts.cookies) and c.length
               obj["Cleared Cookies"] = c
               obj["Num Cookies"] = c.length
             else
@@ -263,9 +256,9 @@ module.exports = (Commands, Cypress, cy, state, config) ->
             obj
         })
 
-      getAndClear(options._log, options.timeout, { domain: options.domain })
+      getAndClear(opts._log, opts.timeout, { domain: opts.domain })
       .then (resp) ->
-        options.cookies = resp
+        opts.cookies = resp
 
         ## null out the current subject
         return null
diff --git a/packages/driver/src/cy/commands/debugging.coffee b/packages/driver/src/cy/commands/debugging.coffee
index eeba289858be..634fb132ebeb 100644
--- a/packages/driver/src/cy/commands/debugging.coffee
+++ b/packages/driver/src/cy/commands/debugging.coffee
@@ -42,10 +42,10 @@ module.exports = (Commands, Cypress, cy, state, config) ->
       ## bail if we're headless
       return subject if not config("isInteractive")
 
-      _.defaults options, {log: true}
+      opts = _.defaults {}, options, {log: true}
 
-      if options.log
-        options._log = Cypress.log({
+      if opts.log
+        opts._log = Cypress.log({
           snapshot: true
           autoEnd: false
         })
@@ -59,8 +59,8 @@ module.exports = (Commands, Cypress, cy, state, config) ->
             ## pause on the very next one
             state("onPaused", null)
 
-            if options.log
-              options._log.end()
+            if opts.log
+              opts._log.end()
 
           ## restore timeout
           cy.timeout(timeout)
@@ -85,12 +85,12 @@ module.exports = (Commands, Cypress, cy, state, config) ->
       return subject
 
     debug: (subject, options = {}) ->
-      _.defaults(options, {
+      opts = _.defaults({}, options, {
         log: true
       })
 
-      if options.log
-        options._log = Cypress.log({
+      if opts.log
+        opts._log = Cypress.log({
           snapshot: true
           end: true
         })
diff --git a/packages/driver/src/cy/commands/exec.coffee b/packages/driver/src/cy/commands/exec.coffee
index 62c73161295f..f33831c32da5 100644
--- a/packages/driver/src/cy/commands/exec.coffee
+++ b/packages/driver/src/cy/commands/exec.coffee
@@ -6,58 +6,57 @@ $utils = require("../../cypress/utils")
 module.exports = (Commands, Cypress, cy, state, config) ->
   Commands.addAll({
     exec: (cmd, options = {}) ->
-      userOptions = Object.assign({}, options)
-      _.defaults options,
+      opts = _.defaults {}, options,
         log: true
         timeout: Cypress.config("execTimeout")
         failOnNonZeroExit: true
         env: {}
 
-      if options.log
+      if opts.log
         consoleOutput = {}
 
-        options._log = Cypress.log({
+        opts._log = Cypress.log({
           message: _.truncate(cmd, { length: 25 })
-          options: userOptions
+          options: options
           consoleProps: ->
             consoleOutput
         })
 
       if not cmd or not _.isString(cmd)
         $utils.throwErrByPath("exec.invalid_argument", {
-          onFail: options._log,
+          onFail: opts._log,
           args: { cmd: cmd ? '' }
         })
 
-      options.cmd = cmd
+      opts.cmd = cmd
 
       ## need to remove the current timeout
       ## because we're handling timeouts ourselves
       cy.clearTimeout()
 
-      Cypress.backend("exec", _.pick(options, "cmd", "timeout", "env"))
-      .timeout(options.timeout)
+      Cypress.backend("exec", _.pick(opts, "cmd", "timeout", "env"))
+      .timeout(opts.timeout)
       .then (result) ->
-        if options._log
+        if opts._log
           _.extend(consoleOutput, { Yielded: _.omit(result, "shell") })
 
           consoleOutput["Shell Used"] = result.shell
 
-        return result if result.code is 0 or not options.failOnNonZeroExit
+        return result if result.code is 0 or not opts.failOnNonZeroExit
 
         output = ""
         output += "\nStdout:\n#{_.truncate(result.stdout, { length: 200 })}" if result.stdout
         output += "\nStderr:\n#{_.truncate(result.stderr, { length: 200 })}" if result.stderr
 
         $utils.throwErrByPath "exec.non_zero_exit", {
-          onFail: options._log
+          onFail: opts._log
           args: { cmd, output, code: result.code }
         }
 
       .catch Promise.TimeoutError, { timedOut: true }, (err) ->
         $utils.throwErrByPath "exec.timed_out", {
-          onFail: options._log
-          args: { cmd, timeout: options.timeout }
+          onFail: opts._log
+          args: { cmd, timeout: opts.timeout }
         }
 
       .catch (error) ->
@@ -65,7 +64,7 @@ module.exports = (Commands, Cypress, cy, state, config) ->
         throw error if error.name is "CypressError"
 
         $utils.throwErrByPath("exec.failed", {
-          onFail: options._log
+          onFail: opts._log
           args: { cmd, error }
         })
   })
diff --git a/packages/driver/src/cy/commands/files.coffee b/packages/driver/src/cy/commands/files.coffee
index 791c978c0110..0786361cc528 100644
--- a/packages/driver/src/cy/commands/files.coffee
+++ b/packages/driver/src/cy/commands/files.coffee
@@ -10,28 +10,27 @@ module.exports = (Commands, Cypress, cy, state, config) ->
         options = encoding
         encoding = null
 
-      userOptions = Object.assign({}, options)
-      _.defaults options,
+      opts = _.defaults {}, options,
         encoding: encoding ? "utf8"
         log: true
 
       consoleProps = {}
 
-      if options.log
-        options._log = Cypress.log({
+      if opts.log
+        opts._log = Cypress.log({
           message: file
-          options: userOptions
+          options: options
           consoleProps: -> consoleProps
         })
 
       if not file or not _.isString(file)
         $utils.throwErrByPath("files.invalid_argument", {
-          onFail: options._log,
+          onFail: opts._log,
           args: { cmd: "readFile", file }
         })
 
       do verifyAssertions = =>
-        Cypress.backend("read:file", file, _.pick(options, "encoding"))
+        Cypress.backend("read:file", file, _.pick(opts, "encoding"))
         .catch (err) =>
           if err.code is "ENOENT"
             return {
@@ -40,14 +39,14 @@ module.exports = (Commands, Cypress, cy, state, config) ->
             }
           else
             $utils.throwErrByPath("files.unexpected_error", {
-              onFail: options._log,
+              onFail: opts._log,
               args: { cmd: "readFile", action: "read", file, filePath: err.filePath, error: err.message }
             })
         .then ({ contents, filePath }) =>
           consoleProps["File Path"] = filePath
           consoleProps["Contents"] = contents
 
-          cy.verifyUpcomingAssertions(contents, options, {
+          cy.verifyUpcomingAssertions(contents, opts, {
             ensureExistenceFor: "subject"
             onFail: (err) ->
               return unless err.type is "existence"
@@ -70,30 +69,29 @@ module.exports = (Commands, Cypress, cy, state, config) ->
         options = encoding
         encoding = null
 
-      userOptions = Object.assign({}, options)
-      _.defaults options,
+      opts = _.defaults {}, options,
         encoding: encoding ? "utf8"
         flag: options.flag ? "w"
         log: true
 
       consoleProps = {}
 
-      if options.log
-        options._log = Cypress.log({
+      if opts.log
+        opts._log = Cypress.log({
           message: fileName
-          options: userOptions
+          options: options
           consoleProps: -> consoleProps
         })
 
       if not fileName or not _.isString(fileName)
         $utils.throwErrByPath("files.invalid_argument", {
-          onFail: options._log,
+          onFail: opts._log,
           args: { cmd: "writeFile", file: fileName }
         })
 
       if not (_.isString(contents) or _.isObject(contents))
         $utils.throwErrByPath("files.invalid_contents", {
-          onFail: options._log,
+          onFail: opts._log,
           args: { contents: contents }
         })
 
@@ -101,7 +99,7 @@ module.exports = (Commands, Cypress, cy, state, config) ->
         objContents = contents
         contents = JSON.stringify(contents, null, 2)
 
-      Cypress.backend("write:file", fileName, contents, _.pick(options, ["encoding", "flag"]))
+      Cypress.backend("write:file", fileName, contents, _.pick(opts, ["encoding", "flag"]))
       .then ({ contents, filePath }) ->
         consoleProps["File Path"] = filePath
         consoleProps["Contents"] = contents
@@ -110,12 +108,12 @@ module.exports = (Commands, Cypress, cy, state, config) ->
         return contents
       .catch Promise.TimeoutError, (err) ->
         $utils.throwErrByPath "files.timed_out", {
-          onFail: options._log
-          args: { cmd: "writeFile", file: fileName, timeout: options.timeout }
+          onFail: opts._log
+          args: { cmd: "writeFile", file: fileName, timeout: opts.timeout }
         }
       .catch (err) ->
         $utils.throwErrByPath("files.unexpected_error", {
-          onFail: options._log
+          onFail: opts._log
           args: { cmd: "writeFile", action: "write", file: fileName, filePath: err.filePath, error: err.message }
         })
   })
diff --git a/packages/driver/src/cy/commands/location.coffee b/packages/driver/src/cy/commands/location.coffee
index a5b51f3a8c7f..3a1caa32ca23 100644
--- a/packages/driver/src/cy/commands/location.coffee
+++ b/packages/driver/src/cy/commands/location.coffee
@@ -7,39 +7,36 @@ $Location = require("../../cypress/location")
 module.exports = (Commands, Cypress, cy, state, config) ->
   Commands.addAll({
     url: (options = {}) ->
-      userOptions = Object.assign({}, options)
-      _.defaults options, {log: true}
+      opts = _.defaults {}, options, {log: true}
 
-      if options.log isnt false
-        options._log = Cypress.log
+      if opts.log isnt false
+        opts._log = Cypress.log
           message: ""
-          options: userOptions
+          options: options
 
       getHref = =>
         cy.getRemoteLocation("href")
 
       do resolveHref = =>
         Promise.try(getHref).then (href) =>
-          cy.verifyUpcomingAssertions(href, options, {
+          cy.verifyUpcomingAssertions(href, opts, {
             onRetry: resolveHref
           })
 
     hash: (options = {}) ->
-      userOptions = Object.assign({}, options)
+      opts = _.defaults {}, options, {log: true}
 
-      _.defaults options, {log: true}
-
-      if options.log isnt false
-        options._log = Cypress.log
+      if opts.log isnt false
+        opts._log = Cypress.log
           message: ""
-          options: userOptions
+          options: options
 
       getHash = =>
         cy.getRemoteLocation("hash")
 
       do resolveHash = =>
         Promise.try(getHash).then (hash) =>
-          cy.verifyUpcomingAssertions(hash, options, {
+          cy.verifyUpcomingAssertions(hash, opts, {
             onRetry: resolveHash
           })
 
@@ -51,8 +48,7 @@ module.exports = (Commands, Cypress, cy, state, config) ->
 
       options ?= {}
 
-      userOptions = Object.assign({}, options)
-      _.defaults options, {log: true}
+      opts = _.defaults {}, options, {log: true}
 
       getLocation = =>
         location = cy.getRemoteLocation()
@@ -65,14 +61,14 @@ module.exports = (Commands, Cypress, cy, state, config) ->
         else
           location
 
-      if options.log isnt false
-        options._log = Cypress.log
+      if opts.log isnt false
+        opts._log = Cypress.log
           message: key ? ""
-          options: userOptions
+          options: options
 
       do resolveLocation = =>
         Promise.try(getLocation).then (ret) =>
-          cy.verifyUpcomingAssertions(ret, options, {
+          cy.verifyUpcomingAssertions(ret, opts, {
             onRetry: resolveLocation
           })
   })
diff --git a/packages/driver/src/cy/commands/misc.coffee b/packages/driver/src/cy/commands/misc.coffee
index dfde34d9756c..caa6c31c38b2 100644
--- a/packages/driver/src/cy/commands/misc.coffee
+++ b/packages/driver/src/cy/commands/misc.coffee
@@ -26,20 +26,19 @@ module.exports = (Commands, Cypress, cy, state, config) ->
       return null
 
     wrap: (arg, options = {}) ->
-      userOptions = Object.assign({}, options)
-      _.defaults(options, { log: true })
+      opts = _.defaults({}, options, { log: true })
 
-      if options.log isnt false
-        options._log = Cypress.log({
+      if opts.log isnt false
+        opts._log = Cypress.log({
           message: arg
-          options: userOptions
+          options: options
         })
 
         if $dom.isElement(arg)
-          options._log.set({$el: arg})
+          opts._log.set({$el: arg})
 
       do resolveWrap = ->
-        cy.verifyUpcomingAssertions(arg, options, {
+        cy.verifyUpcomingAssertions(arg, opts, {
           onRetry: resolveWrap
         })
         .return(arg)
diff --git a/packages/driver/src/cy/commands/navigation.coffee b/packages/driver/src/cy/commands/navigation.coffee
index 9451fd139989..48682288e98c 100644
--- a/packages/driver/src/cy/commands/navigation.coffee
+++ b/packages/driver/src/cy/commands/navigation.coffee
@@ -363,14 +363,14 @@ module.exports = (Commands, Cypress, cy, state, config) ->
       cy.clearTimeout("reload")
 
       cleanup = null
+      opts = null
 
       reload = ->
         new Promise (resolve, reject) ->
           forceReload ?= false
           options     ?= {}
 
-          userOptions = Object.assign({}, options)
-          _.defaults options, {
+          opts = _.defaults {}, options, {
             log: true
             timeout: config("pageLoadTimeout")
           }
@@ -381,12 +381,12 @@ module.exports = (Commands, Cypress, cy, state, config) ->
           if not _.isObject(options)
             throwArgsErr()
 
-          if options.log
-            options._log = Cypress.log({
-              options: userOptions
+          if opts.log
+            opts._log = Cypress.log({
+              options: options
             })
 
-            options._log.snapshot("before", {next: "after"})
+            opts._log.snapshot("before", {next: "after"})
 
           cleanup = ->
             knownCommandCausedInstability = false
@@ -400,37 +400,35 @@ module.exports = (Commands, Cypress, cy, state, config) ->
           $utils.locReload(forceReload, state("window"))
 
       reload()
-      .timeout(options.timeout, "reload")
+      .timeout(opts.timeout, "reload")
       .catch Promise.TimeoutError, (err) ->
-        timedOutWaitingForPageLoad(options.timeout, options._log)
+        timedOutWaitingForPageLoad(opts.timeout, opts._log)
       .finally ->
         cleanup?()
 
         return null
 
     go: (numberOrString, options = {}) ->
-      userOptions = Object.assign({}, options)
-
-      _.defaults options, {
+      opts = _.defaults {}, options, {
         log: true
         timeout: config("pageLoadTimeout")
       }
 
-      if options.log
-        options._log = Cypress.log({
-          options: userOptions
+      if opts.log
+        opts._log = Cypress.log({
+          options: options
         })
 
       win = state("window")
 
       goNumber = (num) ->
         if num is 0
-          $utils.throwErrByPath("go.invalid_number", { onFail: options._log })
+          $utils.throwErrByPath("go.invalid_number", { onFail: opts._log })
 
         cleanup = null
 
-        if options._log
-          options._log.snapshot("before", {next: "after"})
+        if opts._log
+          opts._log.snapshot("before", {next: "after"})
 
         go = ->
           Promise.try ->
@@ -477,9 +475,9 @@ module.exports = (Commands, Cypress, cy, state, config) ->
                 retWin()
 
         go()
-        .timeout(options.timeout, "go")
+        .timeout(opts.timeout, "go")
         .catch Promise.TimeoutError, (err) ->
-          timedOutWaitingForPageLoad(options.timeout, options._log)
+          timedOutWaitingForPageLoad(opts.timeout, opts._log)
         .finally ->
           cleanup?()
 
@@ -491,7 +489,7 @@ module.exports = (Commands, Cypress, cy, state, config) ->
           when "back"    then goNumber(-1)
           else
             $utils.throwErrByPath("go.invalid_direction", {
-              onFail: options._log
+              onFail: opts._log
               args: { str }
             })
 
@@ -499,7 +497,7 @@ module.exports = (Commands, Cypress, cy, state, config) ->
         when _.isFinite(numberOrString) then goNumber(numberOrString)
         when _.isString(numberOrString) then goString(numberOrString)
         else
-          $utils.throwErrByPath("go.invalid_argument", { onFail: options._log })
+          $utils.throwErrByPath("go.invalid_argument", { onFail: opts._log })
 
     visit: (url, options = {}) ->
       if options.url and url
@@ -518,8 +516,7 @@ module.exports = (Commands, Cypress, cy, state, config) ->
       if not _.isEmpty(options)
         consoleProps["Options"] = _.pick(options, VISIT_OPTS)
 
-      userOptions = Object.assign({}, options)
-      _.defaults(options, {
+      opts = _.defaults({}, options, {
         auth: null
         failOnStatusCode: true
         retryOnNetworkFailure: true
@@ -534,30 +531,30 @@ module.exports = (Commands, Cypress, cy, state, config) ->
         onLoad: ->
       })
 
-      if !_.isUndefined(options.qs) and not _.isObject(options.qs)
-        $utils.throwErrByPath("visit.invalid_qs", { args: { qs: String(options.qs) }})
+      if !_.isUndefined(opts.qs) and not _.isObject(opts.qs)
+        $utils.throwErrByPath("visit.invalid_qs", { args: { qs: String(opts.qs) }})
 
-      if options.retryOnStatusCodeFailure and not options.failOnStatusCode
+      if opts.retryOnStatusCodeFailure and not opts.failOnStatusCode
         $utils.throwErrByPath("visit.status_code_flags_invalid")
 
-      if not isValidVisitMethod(options.method)
-        $utils.throwErrByPath("visit.invalid_method", { args: { method: options.method }})
+      if not isValidVisitMethod(opts.method)
+        $utils.throwErrByPath("visit.invalid_method", { args: { method: opts.method }})
 
-      if not _.isObject(options.headers)
+      if not _.isObject(opts.headers)
         $utils.throwErrByPath("visit.invalid_headers")
 
-      if _.isObject(options.body) and path = whatIsCircular(options.body)
+      if _.isObject(opts.body) and path = whatIsCircular(opts.body)
         $utils.throwErrByPath("visit.body_circular", { args: { path }})
 
-      if options.log
+      if opts.log
         message = url
 
-        if options.method != 'GET'
-          message = "#{options.method} #{message}"
+        if opts.method != 'GET'
+          message = "#{opts.method} #{message}"
 
-        options._log = Cypress.log({
+        opts._log = Cypress.log({
           message: message
-          options: userOptions
+          options: options
           consoleProps: -> consoleProps
         })
 
@@ -566,7 +563,7 @@ module.exports = (Commands, Cypress, cy, state, config) ->
       if baseUrl = config("baseUrl")
         url = $Location.qualifyWithBaseUrl(baseUrl, url)
 
-      if qs = options.qs
+      if qs = opts.qs
         url = $Location.mergeUrlWithParams(url, qs)
 
       cleanup = null
@@ -614,10 +611,10 @@ module.exports = (Commands, Cypress, cy, state, config) ->
 
         ## the onLoad callback should only be skipped if specified
         if runOnLoadCallback isnt false
-          options.onLoad?.call(runnable.ctx, win)
+          opts.onLoad?.call(runnable.ctx, win)
 
-        if options._log
-          options._log.set({
+        if opts._log
+          opts._log.set({
             url
             totalTime
           })
@@ -631,7 +628,7 @@ module.exports = (Commands, Cypress, cy, state, config) ->
         ## TODO: $Location.resolve(existing.origin, url)
 
         if $Location.isLocalFileUrl(url)
-          return specifyFileByRelativePath(url, options._log)
+          return specifyFileByRelativePath(url, opts._log)
 
         ## in the case we are visiting a relative url
         ## then prepend the existing origin to it
@@ -643,7 +640,7 @@ module.exports = (Commands, Cypress, cy, state, config) ->
 
         ## reset auth options if we have them
         if a = remote.authObj
-          options.auth = a
+          opts.auth = a
 
         ## store the existing hash now since
         ## we'll need to apply it later
@@ -653,7 +650,7 @@ module.exports = (Commands, Cypress, cy, state, config) ->
         if previousDomainVisited and remote.originPolicy isnt existing.originPolicy
           ## if we've already visited a new superDomain
           ## then die else we'd be in a terrible endless loop
-          return cannotVisit2ndDomain(remote.origin, previousDomainVisited, options._log)
+          return cannotVisit2ndDomain(remote.origin, previousDomainVisited, opts._log)
 
         current = $Location.create(win.location.href)
 
@@ -680,7 +677,7 @@ module.exports = (Commands, Cypress, cy, state, config) ->
           ## strip out the existing url if we have one
           url = url.replace(existingAuth + "@", "")
 
-        requestUrl(url, options)
+        requestUrl(url, opts)
         .then (resp = {}) =>
           {url, originalUrl, cookies, redirects, filePath} = resp
 
@@ -694,13 +691,13 @@ module.exports = (Commands, Cypress, cy, state, config) ->
             if url isnt originalUrl
               consoleProps["Original Url"] = originalUrl
 
-          if options.log
-            message = options._log.get('message')
+          if opts.log
+            message = opts._log.get('message')
 
             if redirects and redirects.length
               message = [message].concat(redirects).join(" -> ")
 
-            options._log.set({message: message})
+            opts._log.set({message: message})
 
           consoleProps["Resolved Url"]  = url
           consoleProps["Redirects"]     = redirects
@@ -724,7 +721,7 @@ module.exports = (Commands, Cypress, cy, state, config) ->
             ## if we've already visited a new superDomain
             ## then die else we'd be in a terrible endless loop
             if previousDomainVisited
-              return cannotVisit2ndDomain(remote.origin, previousDomainVisited, options._log)
+              return cannotVisit2ndDomain(remote.origin, previousDomainVisited, opts._log)
 
             ## tell our backend we're changing domains
             ## TODO: add in other things we want to preserve
@@ -790,13 +787,13 @@ module.exports = (Commands, Cypress, cy, state, config) ->
                     "visit.loading_invalid_content_type"
 
                 $utils.throwErrByPath(msg, {
-                  onFail: options._log
+                  onFail: opts._log
                   args: args
                 })
             else
               visitFailedByErr err, url, ->
                 $utils.throwErrByPath("visit.loading_network_failed", {
-                  onFail: options._log
+                  onFail: opts._log
                   args: {
                     url:   url
                     error: err
@@ -823,9 +820,9 @@ module.exports = (Commands, Cypress, cy, state, config) ->
           go()
 
       visit()
-      .timeout(options.timeout, "visit")
+      .timeout(opts.timeout, "visit")
       .catch Promise.TimeoutError, (err) =>
-        timedOutWaitingForPageLoad(options.timeout, options._log)
+        timedOutWaitingForPageLoad(opts.timeout, opts._log)
       .finally ->
         cleanup?()
 
diff --git a/packages/driver/src/cy/commands/querying.js b/packages/driver/src/cy/commands/querying.js
index 819213b86834..e12347bfdacd 100644
--- a/packages/driver/src/cy/commands/querying.js
+++ b/packages/driver/src/cy/commands/querying.js
@@ -23,25 +23,23 @@ module.exports = (Commands, Cypress, cy) => {
 
   Commands.addAll({
     focused (options = {}) {
-      const userOptions = Object.assign({}, options)
-
-      _.defaults(options, {
+      const opts = _.defaults({}, options, {
         verify: true,
         log: true,
       })
 
-      if (options.log) {
-        options._log = Cypress.log({
-          options: userOptions,
+      if (opts.log) {
+        opts._log = Cypress.log({
+          options,
         })
       }
 
       const log = ($el) => {
-        if (options.log === false) {
+        if (opts.log === false) {
           return
         }
 
-        options._log.set({
+        opts._log.set({
           $el,
           consoleProps () {
             const ret = $el ? $dom.getElements($el) : '--nothing--'
@@ -66,7 +64,7 @@ module.exports = (Commands, Cypress, cy) => {
         return Promise
         .try(getFocused)
         .then(($el) => {
-          if (options.verify === false) {
+          if (opts.verify === false) {
             return $el
           }
 
@@ -76,7 +74,7 @@ module.exports = (Commands, Cypress, cy) => {
           }
 
           // pass in a null jquery object for assertions
-          return cy.verifyUpcomingAssertions($el, options, {
+          return cy.verifyUpcomingAssertions($el, opts, {
             onRetry: resolveFocused,
           })
         })
@@ -94,9 +92,7 @@ module.exports = (Commands, Cypress, cy) => {
         })
       }
 
-      const userOptions = Object.assign({}, options)
-
-      _.defaults(options, {
+      const opts = _.defaults({}, options, {
         retry: true,
         withinSubject: cy.state('withinSubject'),
         log: true,
@@ -107,13 +103,14 @@ module.exports = (Commands, Cypress, cy) => {
       let aliasObj
       const consoleProps = {}
       const start = (aliasType) => {
-        if (options.log === false) {
+        if (opts.log === false) {
           return
         }
 
-        if (options._log == null) {
-          options._log = Cypress.log({
+        if (opts._log == null) {
+          opts._log = Cypress.log({
             message: selector,
+            options,
             referencesAlias: (aliasObj != null && aliasObj.alias) ? { name: aliasObj.alias } : undefined,
             aliasType,
             consoleProps: () => {
@@ -124,11 +121,11 @@ module.exports = (Commands, Cypress, cy) => {
       }
 
       const log = (value, aliasType = 'dom') => {
-        if (options.log === false) {
+        if (opts.log === false) {
           return
         }
 
-        if (!_.isObject(options._log)) {
+        if (!_.isObject(opts._log)) {
           start(aliasType)
         }
 
@@ -137,7 +134,7 @@ module.exports = (Commands, Cypress, cy) => {
         if (aliasType === 'dom') {
           _.extend(obj, {
             $el: value,
-            numRetries: options._retries,
+            numRetries: opts._retries,
           })
         }
 
@@ -173,7 +170,7 @@ module.exports = (Commands, Cypress, cy) => {
           return consoleProps
         }
 
-        options._log.set(obj)
+        opts._log.set(obj)
       }
 
       let allParts
@@ -222,7 +219,7 @@ module.exports = (Commands, Cypress, cy) => {
 
             log(subject)
 
-            return cy.verifyUpcomingAssertions(subject, options, {
+            return cy.verifyUpcomingAssertions(subject, opts, {
               onFail (err) {
                 // if we are failing because our aliased elements
                 // are less than what is expected then we know we
@@ -264,7 +261,7 @@ module.exports = (Commands, Cypress, cy) => {
           log(subject, 'primitive')
 
           const verifyAssertions = () => {
-            return cy.verifyUpcomingAssertions(subject, options, {
+            return cy.verifyUpcomingAssertions(subject, opts, {
               ensureExistenceFor: false,
               onRetry: verifyAssertions,
             })
@@ -279,14 +276,14 @@ module.exports = (Commands, Cypress, cy) => {
       start('dom')
 
       const setEl = ($el) => {
-        if (options.log === false) {
+        if (opts.log === false) {
           return
         }
 
         consoleProps.Yielded = $dom.getElements($el)
         consoleProps.Elements = $el != null ? $el.length : undefined
 
-        options._log.set({ $el })
+        opts._log.set({ $el })
       }
 
       const getElements = () => {
@@ -295,7 +292,7 @@ module.exports = (Commands, Cypress, cy) => {
         let $el
 
         try {
-          $el = cy.$$(selector, options.withinSubject)
+          $el = cy.$$(selector, opts.withinSubject)
           // jQuery v3 has removed its deprecated properties like ".selector"
           // https://jquery.com/upgrade-guide/3.0/breaking-change-deprecated-context-and-selector-properties-removed
           // but our error messages use this property to actually show the missing element
@@ -305,11 +302,11 @@ module.exports = (Commands, Cypress, cy) => {
           }
         } catch (e) {
           e.onFail = () => {
-            if (options.log === false) {
+            if (opts.log === false) {
               return e
             }
 
-            options._log.error(e)
+            opts._log.error(e)
           }
 
           throw e
@@ -318,8 +315,8 @@ module.exports = (Commands, Cypress, cy) => {
         // 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.filter(selector)
+        if (!$el.length && opts.withinSubject && opts.filter) {
+          const filtered = opts.withinSubject.filter(selector)
 
           // reset $el if this found anything
           if (filtered.length) {
@@ -332,8 +329,8 @@ module.exports = (Commands, Cypress, cy) => {
 
         // 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(opts.onRetry)) {
+          const ret = opts.onRetry.call(ctx, $el)
 
           if (ret) {
             log($el)
@@ -349,11 +346,11 @@ module.exports = (Commands, Cypress, cy) => {
 
       const resolveElements = () => {
         return Promise.try(getElements).then(($el) => {
-          if (options.verify === false) {
+          if (opts.verify === false) {
             return $el
           }
 
-          return cy.verifyUpcomingAssertions($el, options, {
+          return cy.verifyUpcomingAssertions($el, opts, {
             onRetry: resolveElements,
           })
         })
@@ -363,20 +360,18 @@ module.exports = (Commands, Cypress, cy) => {
     },
 
     root (options = {}) {
-      const userOptions = Object.assign({}, options)
+      const opts = _.defaults({}, options, { log: true })
 
-      _.defaults(options, { log: true })
-
-      if (options.log !== false) {
-        options._log = Cypress.log({
+      if (opts.log !== false) {
+        opts._log = Cypress.log({
           message: '',
-          options: userOptions,
+          options,
         })
       }
 
       const log = ($el) => {
-        if (options.log) {
-          options._log.set({ $el })
+        if (opts.log) {
+          opts._log.set({ $el })
         }
 
         return $el
@@ -418,9 +413,7 @@ module.exports = (Commands, Cypress, cy) => {
         filter = ''
       }
 
-      const userOptions = Object.assign({}, options)
-
-      _.defaults(options, { log: true })
+      const opts = _.defaults({}, options, { log: true })
 
       if (!(_.isString(text) || _.isFinite(text) || _.isRegExp(text))) {
         $utils.throwErrByPath('contains.invalid_argument')
@@ -464,15 +457,15 @@ module.exports = (Commands, Cypress, cy) => {
 
       let consoleProps
 
-      if (options.log !== false) {
+      if (opts.log !== false) {
         consoleProps = {
           Content: text,
           'Applied To': $dom.getElements(subject || cy.state('withinSubject')),
         }
 
-        options._log = Cypress.log({
+        opts._log = Cypress.log({
           message: _.compact([filter, text]),
-          options: userOptions,
+          options,
           type: subject ? 'child' : 'parent',
           consoleProps: () => {
             return consoleProps
@@ -481,14 +474,14 @@ module.exports = (Commands, Cypress, cy) => {
       }
 
       const setEl = ($el) => {
-        if (options.log === false) {
+        if (opts.log === false) {
           return
         }
 
         consoleProps.Yielded = $dom.getElements($el)
         consoleProps.Elements = $el != null ? $el.length : undefined
 
-        options._log.set({ $el })
+        opts._log.set({ $el })
       }
 
       if (_.isRegExp(text)) {
@@ -503,7 +496,7 @@ module.exports = (Commands, Cypress, cy) => {
       const selector = $dom.getContainsSelector(text, filter)
 
       const resolveElements = () => {
-        const getOpts = _.extend(_.clone(options), {
+        const getOpts = _.extend({}, opts, {
           // error: getErr(text, phrase)
           withinSubject: subject || cy.state('withinSubject') || cy.$$('body'),
           filter: true,
@@ -519,13 +512,13 @@ module.exports = (Commands, Cypress, cy) => {
 
           setEl($el)
 
-          return cy.verifyUpcomingAssertions($el, options, {
+          return cy.verifyUpcomingAssertions($el, opts, {
             onRetry: resolveElements,
             onFail (err) {
               switch (err.type) {
                 case 'length':
                   if (err.expected > 1) {
-                    return $utils.throwErrByPath('contains.length_option', { onFail: options._log })
+                    return $utils.throwErrByPath('contains.length_option', { onFail: opts._log })
                   }
 
                   break
@@ -558,17 +551,17 @@ module.exports = (Commands, Cypress, cy) => {
         options = {}
       }
 
-      _.defaults(options, { log: true })
+      const opts = _.defaults({}, options, { log: true })
 
-      if (options.log) {
-        options._log = Cypress.log({
+      if (opts.log) {
+        opts._log = Cypress.log({
           $el: subject,
           message: '',
         })
       }
 
       if (!_.isFunction(fn)) {
-        $utils.throwErrByPath('within.invalid_argument', { onFail: options._log })
+        $utils.throwErrByPath('within.invalid_argument', { onFail: opts._log })
       }
 
       // reference the next command after this
diff --git a/packages/driver/src/cy/commands/request.coffee b/packages/driver/src/cy/commands/request.coffee
index 23b1b11e792f..17e73304e612 100644
--- a/packages/driver/src/cy/commands/request.coffee
+++ b/packages/driver/src/cy/commands/request.coffee
@@ -84,52 +84,51 @@ module.exports = (Commands, Cypress, cy, state, config) ->
           o.url    = args[1]
           o.body   = args[2]
 
-      userOptions = Object.assign({}, options)
-      _.defaults(options, REQUEST_DEFAULTS, {
+      opts = _.defaults({}, options, REQUEST_DEFAULTS, {
         log: true
       })
 
       ## if timeout is not supplied, use the configured default
-      options.timeout ||= config("responseTimeout")
+      opts.timeout ||= config("responseTimeout")
 
-      options.method = options.method.toUpperCase()
+      opts.method = opts.method.toUpperCase()
 
-      if options.retryOnStatusCodeFailure and not options.failOnStatusCode
+      if opts.retryOnStatusCodeFailure and not opts.failOnStatusCode
         $utils.throwErrByPath("request.status_code_flags_invalid")
 
-      if _.has(options, "failOnStatus")
+      if _.has(opts, "failOnStatus")
         $utils.warnByPath("request.failonstatus_deprecated_warning")
-        options.failOnStatusCode = options.failOnStatus
+        opts.failOnStatusCode = opts.failOnStatus
 
       ## normalize followRedirects -> followRedirect
       ## because we are nice
-      if _.has(options, "followRedirects")
-        options.followRedirect = options.followRedirects
+      if _.has(opts, "followRedirects")
+        opts.followRedirect = opts.followRedirects
 
-      if not $utils.isValidHttpMethod(options.method)
+      if not $utils.isValidHttpMethod(opts.method)
         $utils.throwErrByPath("request.invalid_method", {
           args: { method: o.method }
         })
 
-      if not options.url
+      if not opts.url
         $utils.throwErrByPath("request.url_missing")
 
-      if not _.isString(options.url)
+      if not _.isString(opts.url)
         $utils.throwErrByPath("request.url_wrong_type")
 
       ## normalize the url by prepending it with our current origin
       ## or the baseUrl
-      ## or just using the options.url if its FQDN
+      ## or just using the opts.url if its FQDN
       ## origin may return an empty string if we haven't visited anything yet
-      options.url = $Location.normalize(options.url)
+      opts.url = $Location.normalize(opts.url)
 
       if originOrBase = config("baseUrl") or cy.getRemoteLocation("origin")
-        options.url = $Location.qualifyWithBaseUrl(originOrBase, options.url)
+        opts.url = $Location.qualifyWithBaseUrl(originOrBase, opts.url)
 
-      ## if options.url isnt FQDN then we need to throw here
+      ## if opts.url isnt FQDN then we need to throw here
       ## if we made a request prior to a visit then it needs
       ## to be filled out
-      if not $Location.isFullyQualifiedUrl(options.url)
+      if not $Location.isFullyQualifiedUrl(opts.url)
         $utils.throwErrByPath("request.url_invalid", {
           args: {
             configFile: Cypress.config("configFile")
@@ -140,46 +139,46 @@ module.exports = (Commands, Cypress, cy, state, config) ->
       ## with an object body, they meant to add 'form: true'
       ## so we are nice and do it for them :)
       ## https://github.com/cypress-io/cypress/issues/2923
-      if needsFormSpecified(options)
-        options.form = true
+      if needsFormSpecified(opts)
+        opts.form = true
 
-      if _.isObject(options.body) and path = whatIsCircular(options.body)
+      if _.isObject(opts.body) and path = whatIsCircular(opts.body)
         $utils.throwErrByPath("request.body_circular", { args: { path }})
 
       ## only set json to true if form isnt true
       ## and we have a valid object for body
-      if options.form isnt true and isValidJsonObj(options.body)
-        options.json = true
+      if opts.form isnt true and isValidJsonObj(opts.body)
+        opts.json = true
 
-      options = _.omitBy(options, whichAreOptional)
+      opts = _.omitBy(opts, whichAreOptional)
 
-      if a = options.auth
+      if a = opts.auth
         if not _.isObject(a)
           $utils.throwErrByPath("request.auth_invalid")
 
-      if h = options.headers
+      if h = opts.headers
         if _.isObject(h)
-          options.headers = h
+          opts.headers = h
         else
           $utils.throwErrByPath("request.headers_invalid")
 
-      if not _.isBoolean(options.gzip)
+      if not _.isBoolean(opts.gzip)
         $utils.throwErrByPath("request.gzip_invalid")
 
-      if f = options.form
+      if f = opts.form
         if not _.isBoolean(f)
           $utils.throwErrByPath("request.form_invalid")
 
       ## clone the requestOpts and reduce them down
       ## to the bare minimum to send to lib/request
-      requestOpts = _.pick(options, REQUEST_PROPS)
+      requestOpts = _.pick(opts, REQUEST_PROPS)
 
-      if options.log
-        options._log = Cypress.log({
+      if opts.log
+        opts._log = Cypress.log({
           message: ""
-          options: userOptions
+          options: options
           consoleProps: ->
-            resp = options.response ? {}
+            resp = opts.response ? {}
             rr   = resp.allRequestResponses ? []
 
             obj = {}
@@ -197,16 +196,16 @@ module.exports = (Commands, Cypress, cy, state, config) ->
 
           renderProps: ->
             status = switch
-              when r = options.response
+              when r = opts.response
                 r.status
               else
                 indicator = "pending"
                 "---"
 
-            indicator ?= if options.response?.isOkStatusCode then "successful" else "bad"
+            indicator ?= if opts.response?.isOkStatusCode then "successful" else "bad"
 
             {
-              message: "#{options.method} #{status} #{options.url}"
+              message: "#{opts.method} #{status} #{opts.url}"
               indicator: indicator
             }
         })
@@ -216,14 +215,14 @@ module.exports = (Commands, Cypress, cy, state, config) ->
       cy.clearTimeout("http:request")
 
       Cypress.backend("http:request", requestOpts)
-      .timeout(options.timeout)
+      .timeout(opts.timeout)
       .then (response) =>
-        options.response = response
+        opts.response = response
 
         ## bomb if we should fail on non okay status code
-        if options.failOnStatusCode and response.isOkStatusCode isnt true
+        if opts.failOnStatusCode and response.isOkStatusCode isnt true
           $utils.throwErrByPath("request.status_invalid", {
-            onFail: options._log
+            onFail: opts._log
             args: {
               method:          requestOpts.method
               url:             requestOpts.url
@@ -240,16 +239,16 @@ module.exports = (Commands, Cypress, cy, state, config) ->
         return response
       .catch Promise.TimeoutError, (err) =>
         $utils.throwErrByPath "request.timed_out", {
-          onFail: options._log
+          onFail: opts._log
           args: {
             url:     requestOpts.url
             method:  requestOpts.method
-            timeout: options.timeout
+            timeout: opts.timeout
           }
         }
       .catch { backend: true }, (err) ->
         $utils.throwErrByPath("request.loading_failed", {
-          onFail: options._log
+          onFail: opts._log
           args: {
             error:   err.message
             stack:   err.stack
diff --git a/packages/driver/src/cy/commands/screenshot.coffee b/packages/driver/src/cy/commands/screenshot.coffee
index 5f557da140e9..1c41b27997c4 100644
--- a/packages/driver/src/cy/commands/screenshot.coffee
+++ b/packages/driver/src/cy/commands/screenshot.coffee
@@ -332,9 +332,9 @@ module.exports = (Commands, Cypress, cy, state, config) ->
     })
 
   Commands.addAll({ prevSubject: ["optional", "element", "window", "document"] }, {
-    screenshot: (subject, name, userOptions = {}) ->
+    screenshot: (subject, name, options = {}) ->
       if _.isObject(name)
-        userOptions = name
+        options = name
         name = null
 
       withinSubject = state("withinSubject")
@@ -344,18 +344,18 @@ module.exports = (Commands, Cypress, cy, state, config) ->
       ## TODO: handle hook titles
       runnable = state("runnable")
 
-      options = _.defaults {}, userOptions, {
+      opts = _.defaults {}, options, {
         log: true
         timeout: config("responseTimeout")
       }
 
       isWin = $dom.isWindow(subject)
 
-      screenshotConfig = _.pick(options, "capture", "scale", "disableTimersAndAnimations", "blackout", "waitForCommandSynchronization", "padding", "clip", "onBeforeScreenshot", "onAfterScreenshot")
-      screenshotConfig = $Screenshot.validate(screenshotConfig, "cy.screenshot", options._log)
+      screenshotConfig = _.pick(opts, "capture", "scale", "disableTimersAndAnimations", "blackout", "waitForCommandSynchronization", "padding", "clip", "onBeforeScreenshot", "onAfterScreenshot")
+      screenshotConfig = $Screenshot.validate(screenshotConfig, "cy.screenshot", opts._log)
       screenshotConfig = _.extend($Screenshot.getConfig(), screenshotConfig)
 
-      ## set this regardless of options.log b/c its used by the
+      ## set this regardless of opts.log b/c its used by the
       ## yielded value below
       consoleProps = _.omit(screenshotConfig, "scale", "screenshotOnRunFailure")
       consoleProps = _.extend(consoleProps, {
@@ -366,17 +366,17 @@ module.exports = (Commands, Cypress, cy, state, config) ->
       if name
         consoleProps.name = name
 
-      if options.log
-        options._log = Cypress.log({
+      if opts.log
+        opts._log = Cypress.log({
           message: name
-          options: userOptions
+          options: options
           consoleProps: ->
             consoleProps
         })
 
       if not isWin and subject and subject.length > 1
         $utils.throwErrByPath("screenshot.multiple_elements", {
-          log: options._log
+          log: opts._log
           args: { numElements: subject.length }
         })
 
@@ -389,8 +389,8 @@ module.exports = (Commands, Cypress, cy, state, config) ->
         name
         subject
         runnable
-        log: options._log
-        timeout: options.timeout
+        log: opts._log
+        timeout: opts.timeout
       })
       .then (props) ->
         { duration, path, size } = props
diff --git a/packages/driver/src/cy/commands/task.coffee b/packages/driver/src/cy/commands/task.coffee
index 9a25e7d438f4..9fcb8cfb1981 100644
--- a/packages/driver/src/cy/commands/task.coffee
+++ b/packages/driver/src/cy/commands/task.coffee
@@ -6,12 +6,11 @@ $utils = require("../../cypress/utils")
 module.exports = (Commands, Cypress, cy, state, config) ->
   Commands.addAll({
     task: (task, arg, options = {}) ->
-      userOptions = Object.assign({}, options)
-      _.defaults options,
+      opts = _.defaults {}, options,
         log: true
         timeout: Cypress.config("taskTimeout")
 
-      if options.log
+      if opts.log
         consoleOutput = {
           task: task
           arg: arg
@@ -21,16 +20,16 @@ module.exports = (Commands, Cypress, cy, state, config) ->
         if arg
           message += ", #{$utils.stringify(arg)}"
 
-        options._log = Cypress.log({
+        opts._log = Cypress.log({
           message: message
-          options: userOptions
+          options: options
           consoleProps: ->
             consoleOutput
         })
 
       if not task or not _.isString(task)
         $utils.throwErrByPath("task.invalid_argument", {
-          onFail: options._log,
+          onFail: opts._log,
           args: { task: task ? "" }
         })
 
@@ -41,24 +40,24 @@ module.exports = (Commands, Cypress, cy, state, config) ->
       Cypress.backend("task", {
         task: task
         arg: arg
-        timeout: options.timeout
+        timeout: opts.timeout
       })
-      .timeout(options.timeout)
+      .timeout(opts.timeout)
       .then (result) ->
-        if options._log
+        if opts._log
           _.extend(consoleOutput, { Yielded: result })
         return result
 
       .catch Promise.TimeoutError, ->
         $utils.throwErrByPath "task.timed_out", {
-          onFail: options._log
-          args: { task, timeout: options.timeout }
+          onFail: opts._log
+          args: { task, timeout: opts.timeout }
         }
 
       .catch { timedOut: true }, (error) ->
         $utils.throwErrByPath "task.server_timed_out", {
-          onFail: options._log
-          args: { task, timeout: options.timeout, error: error.message }
+          onFail: opts._log
+          args: { task, timeout: opts.timeout, error: error.message }
         }
 
       .catch (error) ->
@@ -67,12 +66,12 @@ module.exports = (Commands, Cypress, cy, state, config) ->
 
         if error?.isKnownError
           $utils.throwErrByPath("task.known_error", {
-            onFail: options._log
+            onFail: opts._log
             args: { task, error: error.message }
           })
 
         $utils.throwErrByPath("task.failed", {
-          onFail: options._log
+          onFail: opts._log
           args: { task, error: error?.stack or error?.message or error }
         })
   })
diff --git a/packages/driver/src/cy/commands/traversals.coffee b/packages/driver/src/cy/commands/traversals.coffee
index d1a94a9e9a8e..ed86c2f4394d 100644
--- a/packages/driver/src/cy/commands/traversals.coffee
+++ b/packages/driver/src/cy/commands/traversals.coffee
@@ -14,9 +14,8 @@ module.exports = (Commands, Cypress, cy, state, config) ->
         options = arg2
 
       options ?= {}
-      userOptions = Object.assign({}, options)
 
-      _.defaults options, {log: true}
+      opts = _.defaults {}, options, {log: true}
 
       getSelector = ->
         args = _.chain([arg1, arg2]).reject(_.isFunction).reject(_.isObject).value()
@@ -28,19 +27,19 @@ module.exports = (Commands, Cypress, cy, state, config) ->
         "Applied To": $dom.getElements(subject)
       }
 
-      if options.log isnt false
-        options._log = Cypress.log
+      if opts.log isnt false
+        opts._log = Cypress.log
           message: getSelector()
-          options: userOptions
+          options: options
           consoleProps: -> consoleProps
 
       setEl = ($el) ->
-        return if options.log is false
+        return if opts.log is false
 
         consoleProps.Yielded = $dom.getElements($el)
         consoleProps.Elements = $el?.length
 
-        options._log.set({$el: $el})
+        opts._log.set({$el: $el})
 
       do getElements = ->
         ## catch sizzle errors here
@@ -51,12 +50,12 @@ module.exports = (Commands, Cypress, cy, state, config) ->
           ## or completely borks it
           $el.selector = getSelector()
         catch e
-          e.onFail = -> options._log.error(e)
+          e.onFail = -> opts._log.error(e)
           throw e
 
         setEl($el)
 
-        cy.verifyUpcomingAssertions($el, options, {
+        cy.verifyUpcomingAssertions($el, opts, {
           onRetry: getElements
           onFail: (err) ->
             if err.type is "existence"
diff --git a/packages/driver/src/cy/commands/waiting.coffee b/packages/driver/src/cy/commands/waiting.coffee
index 19fca55495ce..50c81ef0198b 100644
--- a/packages/driver/src/cy/commands/waiting.coffee
+++ b/packages/driver/src/cy/commands/waiting.coffee
@@ -170,10 +170,10 @@ module.exports = (Commands, Cypress, cy, state, config) ->
       if _.isString(options)
         $utils.throwErrByPath("wait.invalid_arguments")
 
-      userOptions = Object.assign({}, options)
-      _.defaults options, {log: true}
+      userOptions = options
+      opts = _.defaults {}, options, {log: true}
 
-      args = [subject, msOrFnOrAlias, options]
+      args = [subject, msOrFnOrAlias, opts]
 
       try
         switch
diff --git a/packages/driver/src/cy/commands/window.coffee b/packages/driver/src/cy/commands/window.coffee
index 018832e54a78..f55a9f329082 100644
--- a/packages/driver/src/cy/commands/window.coffee
+++ b/packages/driver/src/cy/commands/window.coffee
@@ -66,12 +66,11 @@ module.exports = (Commands, Cypress, cy, state, config) ->
 
   Commands.addAll({
     title: (options = {}) ->
-      userOptions = Object.assign({}, options)
-      _.defaults options, {log: true}
+      opts = _.defaults {}, options, {log: true}
 
-      if options.log
-        options._log = Cypress.log({
-          options: userOptions
+      if opts.log
+        opts._log = Cypress.log({
+          options: options
         })
 
       do resolveTitle = =>
@@ -79,22 +78,21 @@ module.exports = (Commands, Cypress, cy, state, config) ->
 
         title = (doc and doc.title) or ""
 
-        cy.verifyUpcomingAssertions(title, options, {
+        cy.verifyUpcomingAssertions(title, opts, {
           onRetry: resolveTitle
         })
 
     window: (options = {}) ->
-      userOptions = Object.assign({}, options)
-      _.defaults options, {log: true}
+      opts = _.defaults {}, options, {log: true}
 
-      if options.log
-        options._log = Cypress.log({
-          options: userOptions
+      if opts.log
+        opts._log = Cypress.log({
+          options: options
         })
 
       getWindow = =>
         window = state("window")
-        $utils.throwErrByPath("window.iframe_undefined", { onFail: options._log }) if not window
+        $utils.throwErrByPath("window.iframe_undefined", { onFail: opts._log }) if not window
 
         return window
 
@@ -104,22 +102,21 @@ module.exports = (Commands, Cypress, cy, state, config) ->
         Promise
         .try(getWindow)
         .catch (err) =>
-          options.error = err
-          cy.retry(retryWindow, options)
+          opts.error = err
+          cy.retry(retryWindow, opts)
 
       do verifyAssertions = =>
         Promise.try(retryWindow).then (win) =>
-          cy.verifyUpcomingAssertions(win, options, {
+          cy.verifyUpcomingAssertions(win, opts, {
             onRetry: verifyAssertions
           })
 
     document: (options = {}) ->
-      userOptions = Object.assign({}, options)
-      _.defaults options, {log: true}
+      opts = _.defaults {}, options, {log: true}
 
-      if options.log
-        options._log = Cypress.log({
-          options: userOptions
+      if opts.log
+        opts._log = Cypress.log({
+          options: options
         })
 
       getDocument = =>
@@ -135,12 +132,12 @@ module.exports = (Commands, Cypress, cy, state, config) ->
         Promise
         .try(getDocument)
         .catch (err) =>
-          options.error = err
-          cy.retry(retryDocument, options)
+          opts.error = err
+          cy.retry(retryDocument, opts)
 
       do verifyAssertions = =>
         Promise.try(retryDocument).then (doc) =>
-          cy.verifyUpcomingAssertions(doc, options, {
+          cy.verifyUpcomingAssertions(doc, opts, {
             onRetry: verifyAssertions
           })
 
@@ -148,10 +145,10 @@ module.exports = (Commands, Cypress, cy, state, config) ->
       if _.isObject(heightOrOrientation)
         options = heightOrOrientation
 
-      _.defaults options, {log: true}
+      opts = _.defaults {}, options, {log: true}
 
-      if options.log
-        options._log = Cypress.log
+      if opts.log
+        opts._log = Cypress.log
           consoleProps: ->
             obj = {}
             obj.Preset = preset if preset
@@ -160,7 +157,7 @@ module.exports = (Commands, Cypress, cy, state, config) ->
             obj
 
       throwErrBadArgs = =>
-        $utils.throwErrByPath "viewport.bad_args", { onFail: options._log }
+        $utils.throwErrByPath "viewport.bad_args", { onFail: opts._log }
 
       widthAndHeightAreValidNumbers = (width, height) ->
         _.every [width, height], (val) ->
@@ -172,7 +169,7 @@ module.exports = (Commands, Cypress, cy, state, config) ->
 
       switch
         when _.isString(presetOrWidth) and _.isBlank(presetOrWidth)
-          $utils.throwErrByPath "viewport.empty_string", { onFail: options._log }
+          $utils.throwErrByPath "viewport.empty_string", { onFail: opts._log }
 
         when _.isString(presetOrWidth)
           getPresetDimensions = (preset) =>
@@ -181,7 +178,7 @@ module.exports = (Commands, Cypress, cy, state, config) ->
             catch e
               presets = _.keys(viewports).join(", ")
               $utils.throwErrByPath "viewport.missing_preset", {
-                onFail: options._log
+                onFail: opts._log
                 args: { preset, presets }
               }
 
@@ -189,7 +186,7 @@ module.exports = (Commands, Cypress, cy, state, config) ->
             if orientation not in validOrientations
               all = validOrientations.join("' or '")
               $utils.throwErrByPath "viewport.invalid_orientation", {
-                onFail: options._log
+                onFail: opts._log
                 args: { all, orientation }
               }
 
@@ -212,15 +209,15 @@ module.exports = (Commands, Cypress, cy, state, config) ->
           height = heightOrOrientation
 
           if not widthAndHeightAreWithinBounds(width, height)
-            $utils.throwErrByPath "viewport.dimensions_out_of_range", { onFail: options._log }
+            $utils.throwErrByPath "viewport.dimensions_out_of_range", { onFail: opts._log }
 
         else
           throwErrBadArgs()
 
       setViewportAndSynchronize(width, height)
       .then (viewport) ->
-        if options._log
-          options._log.set(viewport)
+        if opts._log
+          opts._log.set(viewport)
 
         return null
 
diff --git a/packages/driver/test/cypress/integration/issues/678_spec.js b/packages/driver/test/cypress/integration/issues/678_spec.js
index 2ffc6fc058eb..9009719f3d16 100644
--- a/packages/driver/test/cypress/integration/issues/678_spec.js
+++ b/packages/driver/test/cypress/integration/issues/678_spec.js
@@ -76,7 +76,8 @@ describe('issue #678', () => {
         timeout: 3000,
       })
 
-      // Ignore cy.each(), cy.end() because they don't have options.
+      // Ignore cy.each() because it only has an option, timeout.
+      // Ignore cy.end() because it doesn't have options.
 
       cy.get('input').eq(0, {
         timeout: 1111,
@@ -236,7 +237,8 @@ describe('issue #678', () => {
         timeout: 2223,
       })
 
-      // Ignore cy.spread(), cy.spy(), cy.stub() because they don't log to reporter.
+      // Ignore cy.spread() because it only has an option, timeout
+      // cy.spy(), cy.stub() because they don't log to reporter.
 
       cy.get('form').submit({
         timeout: 2000,
@@ -314,224 +316,241 @@ describe('issue #678', () => {
       })
     }
 
+    const testOptions2 = (commandName, options, order, f) => {
+      it(commandName, () => {
+        let count = 0
+
+        cy.on('log:added', (attrs, log) => {
+          if (count === order) {
+            cy.removeAllListeners('log:added')
+            expect(log.get('options')).to.deep.eq(options)
+          }
+
+          count++
+        })
+
+        f(options)
+      })
+    }
+
     describe('A-E', () => {
-      testOptions('blur', { force: false }, 2, (options) => {
+      testOptions2('blur', { force: false }, 2, (options) => {
         cy.get('#a').focus().blur(options)
       })
 
-      testOptions('check', { force: false }, 1, (options) => {
+      testOptions2('check', { force: false }, 1, (options) => {
         cy.get('#checkbox').check(options)
       })
 
-      testOptions('children', { timeout: 2000 }, 1, (options) => {
+      testOptions2('children', { timeout: 2000 }, 1, (options) => {
         cy.get('form').children('#a', options)
       })
 
-      testOptions('clear', { force: false }, 1, (options) => {
+      testOptions2('clear', { force: false }, 1, (options) => {
         cy.get('#a').clear(options)
       })
 
-      testOptions('clearCookie', { timeout: 4000 }, 0, (options) => {
+      testOptions2('clearCookie', { timeout: 4000 }, 0, (options) => {
         cy.clearCookie('authId', options)
       })
 
-      testOptions('clearCookies', { timeout: 4000 }, 0, (options) => {
+      testOptions2('clearCookies', { timeout: 4000 }, 0, (options) => {
         cy.clearCookies(options)
       })
 
       // Ignore cy.clearLocalStorage() because it only has an option, log.
 
-      testOptions('click', { force: false }, 1, (options) => {
+      testOptions2('click', { force: false }, 1, (options) => {
         cy.contains('button').click(options)
       })
 
       // Ignore cy.clock() because it only has an option, log.
 
-      testOptions('closest', { timeout: 3000 }, 1, (options) => {
+      testOptions2('closest', { timeout: 3000 }, 1, (options) => {
         cy.get('#a').closest('form', options)
       })
 
-      testOptions('contains', { timeout: 1131 }, 0, (options) => {
+      testOptions2('contains', { timeout: 1131 }, 0, (options) => {
         cy.contains('.test', 'Hello', options)
       })
 
-      testOptions('dblclick', { force: false }, 1, (options) => {
+      testOptions2('dblclick', { force: false }, 1, (options) => {
         cy.get('button').dblclick(options)
       })
 
       // Ignore cy.debug() because it only has an option, log.
 
-      testOptions('document', { timeout: 3000 }, 0, (options) => {
+      testOptions2('document', { timeout: 3000 }, 0, (options) => {
         cy.document(options)
       })
 
       // Ignore cy.each(), cy.end() because they don't have options.
 
-      testOptions('eq', { timeout: 1111 }, 1, (options) => {
+      testOptions2('eq', { timeout: 1111 }, 1, (options) => {
         cy.get('input').eq(0, options)
       })
 
-      testOptions('exec', { env: { 'a': true } }, 0, (options) => {
+      testOptions2('exec', { env: { 'a': true } }, 0, (options) => {
         cy.exec('ls', options)
       })
     })
 
     describe('F-P', () => {
-      testOptions('filter', { timeout: 2222 }, 1, (options) => {
+      testOptions2('filter', { timeout: 2222 }, 1, (options) => {
         cy.get('input').filter('#a', options)
       })
 
-      testOptions('find', { timeout: 2345 }, 1, (options) => {
+      testOptions2('find', { timeout: 2345 }, 1, (options) => {
         cy.get('form').find('#a', options)
       })
 
-      testOptions('first', { timeout: 2000 }, 1, (options) => {
+      testOptions2('first', { timeout: 2000 }, 1, (options) => {
         cy.get('input').first(options)
       })
 
       // Ignore cy.fixture() because it doesn't log to reporter.
 
-      testOptions('focus', { timeout: 2500 }, 1, (options) => {
+      testOptions2('focus', { timeout: 2500 }, 1, (options) => {
         cy.get('#a').focus(options)
       })
 
-      testOptions('focused', { timeout: 2500 }, 2, (options) => {
+      testOptions2('focused', { timeout: 2500 }, 2, (options) => {
         cy.get('#a').focus().focused(options)
       })
 
-      testOptions('get', { withinSubject: document.forms[0] }, 0, (options) => {
+      testOptions2('get', { withinSubject: document.forms[0] }, 0, (options) => {
         cy.get('#a', options)
       })
 
-      testOptions('getCookie', { timeout: 1800 }, 0, (options) => {
+      testOptions2('getCookie', { timeout: 1800 }, 0, (options) => {
         cy.getCookie('auth_key', options)
       })
 
-      testOptions('getCookies', { timeout: 1888 }, 0, (options) => {
+      testOptions2('getCookies', { timeout: 1888 }, 0, (options) => {
         cy.getCookies(options)
       })
 
-      testOptions('go', { timeout: 4000 }, 0, (options) => {
+      testOptions2('go', { timeout: 4000 }, 0, (options) => {
         cy.go('forward', options)
       })
 
-      testOptions('hash', { timeout: 1100 }, 0, (options) => {
+      testOptions2('hash', { timeout: 1100 }, 0, (options) => {
         cy.hash(options)
       })
 
       // Ignore invoke(), its() because they don't have options.
 
-      testOptions('last', { timeout: 3000 }, 1, (options) => {
+      testOptions2('last', { timeout: 3000 }, 1, (options) => {
         cy.get('input').last(options)
       })
 
-      testOptions('location', { timeout: 2000 }, 0, (options) => {
+      testOptions2('location', { timeout: 2000 }, 0, (options) => {
         cy.location('port', options)
       })
 
       // Ignore log() because it doesn't have options.
 
-      testOptions('next', { timeout: 2300 }, 1, (options) => {
+      testOptions2('next', { timeout: 2300 }, 1, (options) => {
         cy.get('#a').next('input', options)
       })
 
-      testOptions('nextAll', { timeout: 1211 }, 1, (options) => {
+      testOptions2('nextAll', { timeout: 1211 }, 1, (options) => {
         cy.get('#a').nextAll('input', options)
       })
 
-      testOptions('nextUntil', { timeout: 1111 }, 1, (options) => {
+      testOptions2('nextUntil', { timeout: 1111 }, 1, (options) => {
         cy.get('#a').nextUntil('#b', options)
       })
 
-      testOptions('not', { timeout: 3333 }, 1, (options) => {
+      testOptions2('not', { timeout: 3333 }, 1, (options) => {
         cy.get('input').not('#a', options)
       })
 
-      testOptions('parent', { timeout: 2345 }, 1, (options) => {
+      testOptions2('parent', { timeout: 2345 }, 1, (options) => {
         cy.get('#a').parent('form', options)
       })
 
-      testOptions('parents', { timeout: 3333 }, 1, (options) => {
+      testOptions2('parents', { timeout: 3333 }, 1, (options) => {
         cy.get('#a').parents('form', options)
       })
 
-      testOptions('parentsUntil', { timeout: 1112 }, 1, (options) => {
+      testOptions2('parentsUntil', { timeout: 1112 }, 1, (options) => {
         cy.get('#a').parentsUntil('body', options)
       })
 
       // Ignore pause() because it only has an option, log.
 
-      testOptions('prev', { timeout: 1236 }, 1, (options) => {
+      testOptions2('prev', { timeout: 1236 }, 1, (options) => {
         cy.get('#b').prev('input', options)
       })
 
-      testOptions('prevAll', { timeout: 2111 }, 1, (options) => {
+      testOptions2('prevAll', { timeout: 2111 }, 1, (options) => {
         cy.get('#b').prevAll('input', options)
       })
 
-      testOptions('prevUntil', { timeout: 3111 }, 1, (options) => {
+      testOptions2('prevUntil', { timeout: 3111 }, 1, (options) => {
         cy.get('#b').prevUntil('#a', options)
       })
     })
 
     describe('Q-Z', () => {
-      testOptions('readFile', { timeout: 3000 }, 0, (options) => {
+      testOptions2('readFile', { timeout: 3000 }, 0, (options) => {
         cy.readFile('./cypress/fixtures/issue-678.html', options)
       })
 
-      testOptions('reload', { timeout: 2000 }, 0, (options) => {
+      testOptions2('reload', { timeout: 2000 }, 0, (options) => {
         cy.reload(true, options)
       })
 
-      testOptions('request', { url: '/fixtures/issue-678.html' }, 0, (options) => {
+      testOptions2('request', { url: '/fixtures/issue-678.html' }, 0, (options) => {
         cy.request(options)
       })
 
-      testOptions('rightclick', { timeout: 1144 }, 1, (options) => {
+      testOptions2('rightclick', { timeout: 1144 }, 1, (options) => {
         cy.get('button').rightclick(options)
       })
 
-      testOptions('root', { timeout: 2000 }, 0, (options) => {
+      testOptions2('root', { timeout: 2000 }, 0, (options) => {
         cy.root(options)
       })
 
       // Ignore cy.route() because it doesn't log to reporter.
 
-      testOptions('screenshot', { capture: 'viewport' }, 0, (options) => {
+      testOptions2('screenshot', { capture: 'viewport' }, 0, (options) => {
         cy.screenshot(options)
       })
 
-      testOptions('scrollIntoView', { offset: { top: 20 } }, 1, (options) => {
+      testOptions2('scrollIntoView', { offset: { top: 20 } }, 1, (options) => {
         cy.get('form').scrollIntoView(options)
       })
 
-      testOptions('scrollTo', { duration: 100 }, 0, (options) => {
+      testOptions2('scrollTo', { duration: 100 }, 0, (options) => {
         cy.scrollTo(0, 500, options)
       })
 
-      testOptions('select', { force: false }, 1, (options) => {
+      testOptions2('select', { force: false }, 1, (options) => {
         cy.get('select').select('apples', options)
       })
 
       // Ignore cy.server() because it doesn't log to reporter.
 
-      testOptions('setCookie', { httpOnly: true }, 0, (options) => {
+      testOptions2('setCookie', { httpOnly: true }, 0, (options) => {
         cy.setCookie('auth_key', '123key', options)
       })
 
       // Ignore cy.should() because it doesn't have options.
 
-      testOptions('siblings', { timeout: 2223 }, 1, (options) => {
+      testOptions2('siblings', { timeout: 2223 }, 1, (options) => {
         cy.get('#a').siblings('input', options)
       })
 
       // Ignore cy.spread(), cy.spy(), cy.stub() because they don't log to reporter.
 
-      testOptions('submit', { timeout: 2000 }, 1, (options) => {
+      testOptions2('submit', { timeout: 2000 }, 1, (options) => {
         cy.get('form').submit(options)
       })
 
-      testOptions('task', { timeout: 2000 }, 0, (options) => {
+      testOptions2('task', { timeout: 2000 }, 0, (options) => {
         cy.task('return:arg', 'hello world', options)
       })
 
@@ -539,23 +558,23 @@ describe('issue #678', () => {
 
       // Ignore cy.tick() because it doesn't have any options.
 
-      testOptions('title', { timeout: 2000 }, 0, (options) => {
+      testOptions2('title', { timeout: 2000 }, 0, (options) => {
         cy.title(options)
       })
 
-      testOptions('trigger', { cancelable: true }, 1, (options) => {
+      testOptions2('trigger', { cancelable: true }, 1, (options) => {
         cy.get('#a').trigger('mouseenter', 'top', options)
       })
 
-      testOptions('type', { delay: 10 }, 1, (options) => {
+      testOptions2('type', { delay: 10 }, 1, (options) => {
         cy.get('#a').type('hi?', options)
       })
 
-      testOptions('uncheck', { force: false }, 1, (options) => {
+      testOptions2('uncheck', { force: false }, 1, (options) => {
         cy.get('#checkbox').uncheck('good', options)
       })
 
-      testOptions('url', { timeout: 2000 }, 0, (options) => {
+      testOptions2('url', { timeout: 2000 }, 0, (options) => {
         cy.url(options)
       })
 
@@ -563,24 +582,104 @@ describe('issue #678', () => {
 
       // Ignore cy.visit() because it is tested in beforeEach().
 
-      testOptions('wait', { requestTimeout: 2000 }, 0, (options) => {
+      testOptions2('wait', { requestTimeout: 2000 }, 0, (options) => {
         cy.wait(100, options)
       })
 
-      testOptions('window', { timeout: 1500 }, 0, (options) => {
+      testOptions2('window', { timeout: 1500 }, 0, (options) => {
         cy.window(options)
       })
 
       // Ignore cy.within() because it only has an option, log.
 
-      testOptions('wrap', { timeout: 1000 }, 0, (options) => {
+      testOptions2('wrap', { timeout: 1000 }, 0, (options) => {
         cy.wrap({ name: 'John Doe' }, options)
       })
 
-      testOptions('writeFile', { timeout: 3000 }, 0, (options) => {
+      testOptions2('writeFile', { timeout: 3000 }, 0, (options) => {
         cy.writeFile('./cypress/fixtures/test.txt', 'test', options)
-        .exec('rm ./cypress/fixtures/test.txt')//*/
+        .exec('rm ./cypress/fixtures/test.txt')
+      })
+    })
+  })
+
+  describe('preserve options - other', () => {
+    it('clock', () => {
+      const options = {
+        log: true,
+      }
+
+      cy.clock(options)
+
+      expect(options).to.deep.eq({ log: true })
+    })
+
+    it('debug', () => {
+      const options = { log: false }
+
+      cy.debug(options)
+
+      expect(options).to.deep.eq({ log: false })
+    })
+
+    it('each', () => {
+      const options = { timeout: 4000 }
+
+      cy.getCookies().each(options, (c) => {})
+
+      expect(options).to.deep.eq({ timeout: 4000 })
+    })
+
+    it('then', () => {
+      const options = { timeout: 4000 }
+
+      cy.get('#a').then(options, ($a) => {})
+
+      expect(options).to.deep.eq({ timeout: 4000 })
+    })
+
+    it('pause', () => {
+      const options = { log: false }
+
+      cy.once('paused', () => {
+        expect(options).to.deep.eq({ log: false })
+
+        Cypress.emit('resume:next')
       })
+
+      cy.pause(options)
+    })
+
+    it('spread', () => {
+      const options = { timeout: 4000 }
+
+      cy.getCookies().spread(options, (c) => {})
+
+      expect(options).to.deep.eq({ timeout: 4000 })
+    })
+
+    it('viewport', () => {
+      const options = { log: false }
+
+      cy.viewport(100, 200, options)
+
+      expect(options).to.deep.eq({ log: false })
+    })
+
+    it('visit', () => {
+      const options = { timeout: 4000 }
+
+      cy.visit('/fixtures/issue-678.html', options)
+
+      expect(options).to.deep.equal({ timeout: 4000 })
+    })
+
+    it('within', () => {
+      const options = { log: false }
+
+      cy.get('form').within(options, () => {})
+
+      expect(options).to.deep.eq({ log: false })
     })
   })
 })