R Under development (unstable) (2024-07-28 r86931 ucrt) -- "Unsuffered Consequences"
Copyright (C) 2024 The R Foundation for Statistical Computing
Platform: x86_64-w64-mingw32/x64

R is free software and comes with ABSOLUTELY NO WARRANTY.
You are welcome to redistribute it under certain conditions.
Type 'license()' or 'licence()' for distribution details.

R is a collaborative project with many contributors.
Type 'contributors()' for more information and
'citation()' on how to cite R or R packages in publications.

Type 'demo()' for some demos, 'help()' for on-line help, or
'help.start()' for an HTML browser interface to help.
Type 'q()' to quit R.

> source("incl/start.R")
[17:28:00.198] plan(): Setting new future strategy stack:
[17:28:00.200] List of future strategies:
[17:28:00.200] 1. sequential:
[17:28:00.200]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:00.200]    - tweaked: FALSE
[17:28:00.200]    - call: future::plan("sequential")
[17:28:00.224] plan(): nbrOfWorkers() = 1
> 
> oopts <- c(oopts, options(
+   future.globals.resolve = TRUE,
+   future.globals.onMissing = "error"
+ ))
> 
> message("*** Globals - subassignments ...")
*** Globals - subassignments ...
> 
> message("*** Globals - subassignments w/ x$a <- value ...")
*** Globals - subassignments w/ x$a <- value ...
> 
> ## Truth:
> x <- x0 <- list()
> y0 <- list(a = 1)
> str(list(x = x, y0 = y0))
List of 2
 $ x : list()
 $ y0:List of 1
  ..$ a: num 1
> 
> y <- local({
+   x$a <- 1
+   x
+ })
> stopifnot(identical(y, y0))
> 
> y <- local({
+   x[["a"]] <- 1
+   x
+ })
> stopifnot(identical(y, y0))
> 
> y <- local({
+   x["a"] <- list(1)
+   x
+ })
> stopifnot(identical(y, y0))
> 
> stopifnot(identical(x, list()))
> 
> for (cores in 1:availCores) {
+   ## Speed up CRAN checks: Skip on CRAN Windows 32-bit
+   if (!fullTest && isWin32) next
+   
+   message(sprintf("Testing with %d cores ...", cores))
+   options(mc.cores = cores)
+ 
+   message("availableCores(): ", availableCores())
+ 
+   for (strategy in supportedStrategies(cores)) {
+     message(sprintf("- plan('%s') ...", strategy))
+     plan(strategy)
+ 
+     ## Explicit future
+     x <- list()
+     f <- future({
+       x$a <- 1
+       x
+     })
+     rm(list = "x")
+     y <- value(f)
+     print(y)
+     stopifnot(identical(y, y0))
+ 
+     ## Explicit future (lazy)
+     x <- list()
+     f <- future({
+       x$a <- 1
+       x
+     }, lazy = TRUE)
+     rm(list = "x")
+     y <- value(f)
+     print(y)
+     stopifnot(identical(y, y0))
+ 
+     ## Future assignment
+     x <- list()
+     y %<-% {
+       x$a <- 1
+       x
+     }
+     rm(list = "x")
+     print(y)
+     stopifnot(identical(y, y0))
+ 
+     ## Same with forced lazy evaluation
+     x <- list()
+     y %<-% {
+       x$a <- 1
+       x
+     } %lazy% TRUE
+     rm(list = "x")
+     print(y)
+     stopifnot(identical(y, y0))
+ 
+     ## 'x' is _not_ a global variable here
+     x <- list()
+     y %<-% {
+       x <- list(b = 2)
+       x$a <- 1
+       x
+     }
+     rm(list = "x")
+     print(y)
+     stopifnot(identical(y, list(b = 2, a = 1)))
+ 
+     ## Explicit future
+     x <- list()
+     f <- future({
+       x[["a"]] <- 1
+       x
+     })
+     rm(list = "x")
+     y <- value(f)
+     print(y)
+     stopifnot(identical(y, y0))
+ 
+     ## Explicit future (lazy)
+     x <- list()
+     f <- future({
+       x[["a"]] <- 1
+       x
+     }, lazy = TRUE)
+     rm(list = "x")
+     y <- value(f)
+     print(y)
+     stopifnot(identical(y, y0))
+ 
+     ## Future assignment
+     x <- list()
+     y %<-% {
+       x[["a"]] <- 1
+       x
+     }
+     rm(list = "x")
+     print(y)
+     stopifnot(identical(y, y0))
+     
+     ## Explicit future
+     x <- list()
+     f <- future({
+       x["a"] <- list(1)
+       x
+     })
+     rm(list = "x")
+     y <- value(f)
+     print(y)
+     stopifnot(identical(y, y0))
+ 
+     ## Explicit future (lazy)
+     x <- list()
+     f <- future({
+       x["a"] <- list(1)
+       x
+     }, lazy = TRUE)
+     rm(list = "x")
+     y <- value(f)
+     print(y)
+     stopifnot(identical(y, y0))
+ 
+     ## Future assignment
+     x <- list()
+     y %<-% {
+       x["a"] <- list(1)
+       x
+     }
+     rm(list = "x")
+     print(y)
+     stopifnot(identical(y, y0))
+ 
+     ## Future assignment
+     x <- list()
+     name <- "a"
+     y %<-% {
+       x[name] <- list(1)
+       x
+     }
+     rm(list = c("x", "name"))
+     print(y)
+     stopifnot(identical(y, y0))
+   } ## for (strategy ...)
+ 
+   message(sprintf("Testing with %d cores ... DONE", cores))
+ } ## for (cores ...)
Testing with 1 cores ...
availableCores(): 1
- plan('sequential') ...
[17:28:00.357] plan(): Setting new future strategy stack:
[17:28:00.357] List of future strategies:
[17:28:00.357] 1. sequential:
[17:28:00.357]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:00.357]    - tweaked: FALSE
[17:28:00.357]    - call: plan(strategy)
[17:28:00.379] plan(): nbrOfWorkers() = 1
Warning in getGlobalsAndPackages(expr, envir = envir, tweak = tweakExpression,  :
  R option 'future.globals.resolve' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'TRUE'
[17:28:00.381] getGlobalsAndPackages() ...
Warning in getGlobalsAndPackages(expr, envir = envir, tweak = tweakExpression,  :
  R option 'future.globals.onMissing' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'error'
[17:28:00.381] Searching for globals...
[17:28:00.395] - globals found: [5] '{', 'x', '<-', '$', '$<-'
[17:28:00.398] Searching for globals ... DONE
[17:28:00.398] Resolving globals: TRUE
[17:28:00.398] Resolving any globals that are futures ...
[17:28:00.399] - globals: [5] '{', 'x', '<-', '$', '$<-'
[17:28:00.399] Resolving any globals that are futures ... DONE
[17:28:00.400] Resolving futures part of globals (recursively) ...
[17:28:00.400] resolve() on list ...
[17:28:00.401]  recursive: 99
[17:28:00.401]  length: 1
[17:28:00.401]  elements: 'x'
[17:28:00.401]  length: 0 (resolved future 1)
[17:28:00.402] resolve() on list ... DONE
[17:28:00.402] - globals: [1] 'x'
[17:28:00.402] Resolving futures part of globals (recursively) ... DONE
[17:28:00.402] The total size of the 1 globals is 31 bytes (31 bytes)
[17:28:00.403] The total size of the 1 globals exported for future expression ('{; x$a <- 1; x; }') is 31 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (31 bytes of class 'list')
[17:28:00.403] - globals: [1] 'x'
[17:28:00.403] 
[17:28:00.404] getGlobalsAndPackages() ... DONE
[17:28:00.404] run() for 'Future' ...
[17:28:00.405] - state: 'created'
[17:28:00.405] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:28:00.405] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:28:00.406] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:28:00.406]   - Field: 'label'
[17:28:00.406]   - Field: 'local'
[17:28:00.406]   - Field: 'owner'
[17:28:00.406]   - Field: 'envir'
[17:28:00.406]   - Field: 'packages'
[17:28:00.407]   - Field: 'gc'
[17:28:00.407]   - Field: 'conditions'
[17:28:00.407]   - Field: 'expr'
[17:28:00.407]   - Field: 'uuid'
[17:28:00.407]   - Field: 'seed'
[17:28:00.408]   - Field: 'version'
[17:28:00.408]   - Field: 'result'
[17:28:00.408]   - Field: 'asynchronous'
[17:28:00.408]   - Field: 'calls'
[17:28:00.408]   - Field: 'globals'
[17:28:00.409]   - Field: 'stdout'
[17:28:00.409]   - Field: 'earlySignal'
[17:28:00.409]   - Field: 'lazy'
[17:28:00.409]   - Field: 'state'
[17:28:00.409] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:28:00.410] - Launch lazy future ...
[17:28:00.411] Packages needed by the future expression (n = 0): <none>
[17:28:00.411] Packages needed by future strategies (n = 0): <none>
[17:28:00.412] {
[17:28:00.412]     {
[17:28:00.412]         {
[17:28:00.412]             ...future.startTime <- base::Sys.time()
[17:28:00.412]             {
[17:28:00.412]                 {
[17:28:00.412]                   {
[17:28:00.412]                     base::local({
[17:28:00.412]                       has_future <- base::requireNamespace("future", 
[17:28:00.412]                         quietly = TRUE)
[17:28:00.412]                       if (has_future) {
[17:28:00.412]                         ns <- base::getNamespace("future")
[17:28:00.412]                         version <- ns[[".package"]][["version"]]
[17:28:00.412]                         if (is.null(version)) 
[17:28:00.412]                           version <- utils::packageVersion("future")
[17:28:00.412]                       }
[17:28:00.412]                       else {
[17:28:00.412]                         version <- NULL
[17:28:00.412]                       }
[17:28:00.412]                       if (!has_future || version < "1.8.0") {
[17:28:00.412]                         info <- base::c(r_version = base::gsub("R version ", 
[17:28:00.412]                           "", base::R.version$version.string), 
[17:28:00.412]                           platform = base::sprintf("%s (%s-bit)", 
[17:28:00.412]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:00.412]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:00.412]                             "release", "version")], collapse = " "), 
[17:28:00.412]                           hostname = base::Sys.info()[["nodename"]])
[17:28:00.412]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:28:00.412]                           info)
[17:28:00.412]                         info <- base::paste(info, collapse = "; ")
[17:28:00.412]                         if (!has_future) {
[17:28:00.412]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:00.412]                             info)
[17:28:00.412]                         }
[17:28:00.412]                         else {
[17:28:00.412]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:00.412]                             info, version)
[17:28:00.412]                         }
[17:28:00.412]                         base::stop(msg)
[17:28:00.412]                       }
[17:28:00.412]                     })
[17:28:00.412]                   }
[17:28:00.412]                   ...future.strategy.old <- future::plan("list")
[17:28:00.412]                   options(future.plan = NULL)
[17:28:00.412]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:00.412]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:00.412]                 }
[17:28:00.412]                 ...future.workdir <- getwd()
[17:28:00.412]             }
[17:28:00.412]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:00.412]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:00.412]         }
[17:28:00.412]         base::options(future.startup.script = FALSE, future.globals.onMissing = "error", 
[17:28:00.412]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:00.412]             future.globals.onMissing = "error", future.globals.onReference = NULL, 
[17:28:00.412]             future.globals.resolve = TRUE, future.resolve.recursive = NULL, 
[17:28:00.412]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:28:00.412]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:00.412]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:00.412]             base::names(...future.oldOptions))
[17:28:00.412]     }
[17:28:00.412]     if (FALSE) {
[17:28:00.412]     }
[17:28:00.412]     else {
[17:28:00.412]         if (TRUE) {
[17:28:00.412]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:00.412]                 open = "w")
[17:28:00.412]         }
[17:28:00.412]         else {
[17:28:00.412]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:00.412]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:00.412]         }
[17:28:00.412]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:00.412]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:00.412]             base::sink(type = "output", split = FALSE)
[17:28:00.412]             base::close(...future.stdout)
[17:28:00.412]         }, add = TRUE)
[17:28:00.412]     }
[17:28:00.412]     ...future.frame <- base::sys.nframe()
[17:28:00.412]     ...future.conditions <- base::list()
[17:28:00.412]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:00.412]     if (FALSE) {
[17:28:00.412]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:00.412]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:00.412]     }
[17:28:00.412]     ...future.result <- base::tryCatch({
[17:28:00.412]         base::withCallingHandlers({
[17:28:00.412]             ...future.value <- base::withVisible(base::local({
[17:28:00.412]                 x$a <- 1
[17:28:00.412]                 x
[17:28:00.412]             }))
[17:28:00.412]             future::FutureResult(value = ...future.value$value, 
[17:28:00.412]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:00.412]                   ...future.rng), globalenv = if (FALSE) 
[17:28:00.412]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:00.412]                     ...future.globalenv.names))
[17:28:00.412]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:00.412]         }, condition = base::local({
[17:28:00.412]             c <- base::c
[17:28:00.412]             inherits <- base::inherits
[17:28:00.412]             invokeRestart <- base::invokeRestart
[17:28:00.412]             length <- base::length
[17:28:00.412]             list <- base::list
[17:28:00.412]             seq.int <- base::seq.int
[17:28:00.412]             signalCondition <- base::signalCondition
[17:28:00.412]             sys.calls <- base::sys.calls
[17:28:00.412]             `[[` <- base::`[[`
[17:28:00.412]             `+` <- base::`+`
[17:28:00.412]             `<<-` <- base::`<<-`
[17:28:00.412]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:00.412]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:00.412]                   3L)]
[17:28:00.412]             }
[17:28:00.412]             function(cond) {
[17:28:00.412]                 is_error <- inherits(cond, "error")
[17:28:00.412]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:00.412]                   NULL)
[17:28:00.412]                 if (is_error) {
[17:28:00.412]                   sessionInformation <- function() {
[17:28:00.412]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:00.412]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:00.412]                       search = base::search(), system = base::Sys.info())
[17:28:00.412]                   }
[17:28:00.412]                   ...future.conditions[[length(...future.conditions) + 
[17:28:00.412]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:00.412]                     cond$call), session = sessionInformation(), 
[17:28:00.412]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:00.412]                   signalCondition(cond)
[17:28:00.412]                 }
[17:28:00.412]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:00.412]                 "immediateCondition"))) {
[17:28:00.412]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:00.412]                   ...future.conditions[[length(...future.conditions) + 
[17:28:00.412]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:00.412]                   if (TRUE && !signal) {
[17:28:00.412]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:00.412]                     {
[17:28:00.412]                       inherits <- base::inherits
[17:28:00.412]                       invokeRestart <- base::invokeRestart
[17:28:00.412]                       is.null <- base::is.null
[17:28:00.412]                       muffled <- FALSE
[17:28:00.412]                       if (inherits(cond, "message")) {
[17:28:00.412]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:00.412]                         if (muffled) 
[17:28:00.412]                           invokeRestart("muffleMessage")
[17:28:00.412]                       }
[17:28:00.412]                       else if (inherits(cond, "warning")) {
[17:28:00.412]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:00.412]                         if (muffled) 
[17:28:00.412]                           invokeRestart("muffleWarning")
[17:28:00.412]                       }
[17:28:00.412]                       else if (inherits(cond, "condition")) {
[17:28:00.412]                         if (!is.null(pattern)) {
[17:28:00.412]                           computeRestarts <- base::computeRestarts
[17:28:00.412]                           grepl <- base::grepl
[17:28:00.412]                           restarts <- computeRestarts(cond)
[17:28:00.412]                           for (restart in restarts) {
[17:28:00.412]                             name <- restart$name
[17:28:00.412]                             if (is.null(name)) 
[17:28:00.412]                               next
[17:28:00.412]                             if (!grepl(pattern, name)) 
[17:28:00.412]                               next
[17:28:00.412]                             invokeRestart(restart)
[17:28:00.412]                             muffled <- TRUE
[17:28:00.412]                             break
[17:28:00.412]                           }
[17:28:00.412]                         }
[17:28:00.412]                       }
[17:28:00.412]                       invisible(muffled)
[17:28:00.412]                     }
[17:28:00.412]                     muffleCondition(cond, pattern = "^muffle")
[17:28:00.412]                   }
[17:28:00.412]                 }
[17:28:00.412]                 else {
[17:28:00.412]                   if (TRUE) {
[17:28:00.412]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:00.412]                     {
[17:28:00.412]                       inherits <- base::inherits
[17:28:00.412]                       invokeRestart <- base::invokeRestart
[17:28:00.412]                       is.null <- base::is.null
[17:28:00.412]                       muffled <- FALSE
[17:28:00.412]                       if (inherits(cond, "message")) {
[17:28:00.412]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:00.412]                         if (muffled) 
[17:28:00.412]                           invokeRestart("muffleMessage")
[17:28:00.412]                       }
[17:28:00.412]                       else if (inherits(cond, "warning")) {
[17:28:00.412]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:00.412]                         if (muffled) 
[17:28:00.412]                           invokeRestart("muffleWarning")
[17:28:00.412]                       }
[17:28:00.412]                       else if (inherits(cond, "condition")) {
[17:28:00.412]                         if (!is.null(pattern)) {
[17:28:00.412]                           computeRestarts <- base::computeRestarts
[17:28:00.412]                           grepl <- base::grepl
[17:28:00.412]                           restarts <- computeRestarts(cond)
[17:28:00.412]                           for (restart in restarts) {
[17:28:00.412]                             name <- restart$name
[17:28:00.412]                             if (is.null(name)) 
[17:28:00.412]                               next
[17:28:00.412]                             if (!grepl(pattern, name)) 
[17:28:00.412]                               next
[17:28:00.412]                             invokeRestart(restart)
[17:28:00.412]                             muffled <- TRUE
[17:28:00.412]                             break
[17:28:00.412]                           }
[17:28:00.412]                         }
[17:28:00.412]                       }
[17:28:00.412]                       invisible(muffled)
[17:28:00.412]                     }
[17:28:00.412]                     muffleCondition(cond, pattern = "^muffle")
[17:28:00.412]                   }
[17:28:00.412]                 }
[17:28:00.412]             }
[17:28:00.412]         }))
[17:28:00.412]     }, error = function(ex) {
[17:28:00.412]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:00.412]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:00.412]                 ...future.rng), started = ...future.startTime, 
[17:28:00.412]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:00.412]             version = "1.8"), class = "FutureResult")
[17:28:00.412]     }, finally = {
[17:28:00.412]         if (!identical(...future.workdir, getwd())) 
[17:28:00.412]             setwd(...future.workdir)
[17:28:00.412]         {
[17:28:00.412]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:00.412]                 ...future.oldOptions$nwarnings <- NULL
[17:28:00.412]             }
[17:28:00.412]             base::options(...future.oldOptions)
[17:28:00.412]             if (.Platform$OS.type == "windows") {
[17:28:00.412]                 old_names <- names(...future.oldEnvVars)
[17:28:00.412]                 envs <- base::Sys.getenv()
[17:28:00.412]                 names <- names(envs)
[17:28:00.412]                 common <- intersect(names, old_names)
[17:28:00.412]                 added <- setdiff(names, old_names)
[17:28:00.412]                 removed <- setdiff(old_names, names)
[17:28:00.412]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:00.412]                   envs[common]]
[17:28:00.412]                 NAMES <- toupper(changed)
[17:28:00.412]                 args <- list()
[17:28:00.412]                 for (kk in seq_along(NAMES)) {
[17:28:00.412]                   name <- changed[[kk]]
[17:28:00.412]                   NAME <- NAMES[[kk]]
[17:28:00.412]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:00.412]                     next
[17:28:00.412]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:00.412]                 }
[17:28:00.412]                 NAMES <- toupper(added)
[17:28:00.412]                 for (kk in seq_along(NAMES)) {
[17:28:00.412]                   name <- added[[kk]]
[17:28:00.412]                   NAME <- NAMES[[kk]]
[17:28:00.412]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:00.412]                     next
[17:28:00.412]                   args[[name]] <- ""
[17:28:00.412]                 }
[17:28:00.412]                 NAMES <- toupper(removed)
[17:28:00.412]                 for (kk in seq_along(NAMES)) {
[17:28:00.412]                   name <- removed[[kk]]
[17:28:00.412]                   NAME <- NAMES[[kk]]
[17:28:00.412]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:00.412]                     next
[17:28:00.412]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:00.412]                 }
[17:28:00.412]                 if (length(args) > 0) 
[17:28:00.412]                   base::do.call(base::Sys.setenv, args = args)
[17:28:00.412]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:00.412]             }
[17:28:00.412]             else {
[17:28:00.412]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:00.412]             }
[17:28:00.412]             {
[17:28:00.412]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:00.412]                   0L) {
[17:28:00.412]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:00.412]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:00.412]                   base::options(opts)
[17:28:00.412]                 }
[17:28:00.412]                 {
[17:28:00.412]                   {
[17:28:00.412]                     NULL
[17:28:00.412]                     RNGkind("Mersenne-Twister")
[17:28:00.412]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:28:00.412]                       inherits = FALSE)
[17:28:00.412]                   }
[17:28:00.412]                   options(future.plan = NULL)
[17:28:00.412]                   if (is.na(NA_character_)) 
[17:28:00.412]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:00.412]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:00.412]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:00.412]                     .init = FALSE)
[17:28:00.412]                 }
[17:28:00.412]             }
[17:28:00.412]         }
[17:28:00.412]     })
[17:28:00.412]     if (TRUE) {
[17:28:00.412]         base::sink(type = "output", split = FALSE)
[17:28:00.412]         if (TRUE) {
[17:28:00.412]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:00.412]         }
[17:28:00.412]         else {
[17:28:00.412]             ...future.result["stdout"] <- base::list(NULL)
[17:28:00.412]         }
[17:28:00.412]         base::close(...future.stdout)
[17:28:00.412]         ...future.stdout <- NULL
[17:28:00.412]     }
[17:28:00.412]     ...future.result$conditions <- ...future.conditions
[17:28:00.412]     ...future.result$finished <- base::Sys.time()
[17:28:00.412]     ...future.result
[17:28:00.412] }
[17:28:00.416] assign_globals() ...
[17:28:00.417] List of 1
[17:28:00.417]  $ x: list()
[17:28:00.417]  - attr(*, "where")=List of 1
[17:28:00.417]   ..$ x:<environment: R_EmptyEnv> 
[17:28:00.417]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:28:00.417]  - attr(*, "resolved")= logi TRUE
[17:28:00.417]  - attr(*, "total_size")= int 31
[17:28:00.417]  - attr(*, "already-done")= logi TRUE
[17:28:00.420] - copied 'x' to environment
[17:28:00.420] assign_globals() ... done
[17:28:00.420] plan(): Setting new future strategy stack:
[17:28:00.421] List of future strategies:
[17:28:00.421] 1. sequential:
[17:28:00.421]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:00.421]    - tweaked: FALSE
[17:28:00.421]    - call: NULL
[17:28:00.421] plan(): nbrOfWorkers() = 1
[17:28:00.423] plan(): Setting new future strategy stack:
[17:28:00.424] List of future strategies:
[17:28:00.424] 1. sequential:
[17:28:00.424]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:00.424]    - tweaked: FALSE
[17:28:00.424]    - call: plan(strategy)
[17:28:00.425] plan(): nbrOfWorkers() = 1
[17:28:00.425] SequentialFuture started (and completed)
[17:28:00.426] - Launch lazy future ... done
[17:28:00.426] run() for 'SequentialFuture' ... done
$a
[1] 1

Warning in getGlobalsAndPackages(expr, envir = envir, tweak = tweakExpression,  :
  R option 'future.globals.resolve' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'TRUE'
[17:28:00.427] getGlobalsAndPackages() ...
Warning in getGlobalsAndPackages(expr, envir = envir, tweak = tweakExpression,  :
  R option 'future.globals.onMissing' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'error'
[17:28:00.427] Searching for globals...
[17:28:00.430] - globals found: [5] '{', 'x', '<-', '$', '$<-'
[17:28:00.430] Searching for globals ... DONE
[17:28:00.430] Resolving globals: TRUE
[17:28:00.430] Resolving any globals that are futures ...
[17:28:00.431] - globals: [5] '{', 'x', '<-', '$', '$<-'
[17:28:00.431] Resolving any globals that are futures ... DONE
[17:28:00.431] Resolving futures part of globals (recursively) ...
[17:28:00.432] resolve() on list ...
[17:28:00.432]  recursive: 99
[17:28:00.432]  length: 1
[17:28:00.432]  elements: 'x'
[17:28:00.432]  length: 0 (resolved future 1)
[17:28:00.433] resolve() on list ... DONE
[17:28:00.433] - globals: [1] 'x'
[17:28:00.433] Resolving futures part of globals (recursively) ... DONE
[17:28:00.433] The total size of the 1 globals is 31 bytes (31 bytes)
[17:28:00.434] The total size of the 1 globals exported for future expression ('{; x$a <- 1; x; }') is 31 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (31 bytes of class 'list')
[17:28:00.434] - globals: [1] 'x'
[17:28:00.435] 
[17:28:00.435] getGlobalsAndPackages() ... DONE
[17:28:00.435] run() for 'Future' ...
[17:28:00.435] - state: 'created'
[17:28:00.436] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:28:00.436] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:28:00.436] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:28:00.436]   - Field: 'label'
[17:28:00.437]   - Field: 'local'
[17:28:00.437]   - Field: 'owner'
[17:28:00.437]   - Field: 'envir'
[17:28:00.437]   - Field: 'packages'
[17:28:00.437]   - Field: 'gc'
[17:28:00.438]   - Field: 'conditions'
[17:28:00.438]   - Field: 'expr'
[17:28:00.438]   - Field: 'uuid'
[17:28:00.442]   - Field: 'seed'
[17:28:00.442]   - Field: 'version'
[17:28:00.443]   - Field: 'result'
[17:28:00.443]   - Field: 'asynchronous'
[17:28:00.443]   - Field: 'calls'
[17:28:00.444]   - Field: 'globals'
[17:28:00.444]   - Field: 'stdout'
[17:28:00.444]   - Field: 'earlySignal'
[17:28:00.445]   - Field: 'lazy'
[17:28:00.445]   - Field: 'state'
[17:28:00.445] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:28:00.446] - Launch lazy future ...
[17:28:00.446] Packages needed by the future expression (n = 0): <none>
[17:28:00.447] Packages needed by future strategies (n = 0): <none>
[17:28:00.448] {
[17:28:00.448]     {
[17:28:00.448]         {
[17:28:00.448]             ...future.startTime <- base::Sys.time()
[17:28:00.448]             {
[17:28:00.448]                 {
[17:28:00.448]                   {
[17:28:00.448]                     base::local({
[17:28:00.448]                       has_future <- base::requireNamespace("future", 
[17:28:00.448]                         quietly = TRUE)
[17:28:00.448]                       if (has_future) {
[17:28:00.448]                         ns <- base::getNamespace("future")
[17:28:00.448]                         version <- ns[[".package"]][["version"]]
[17:28:00.448]                         if (is.null(version)) 
[17:28:00.448]                           version <- utils::packageVersion("future")
[17:28:00.448]                       }
[17:28:00.448]                       else {
[17:28:00.448]                         version <- NULL
[17:28:00.448]                       }
[17:28:00.448]                       if (!has_future || version < "1.8.0") {
[17:28:00.448]                         info <- base::c(r_version = base::gsub("R version ", 
[17:28:00.448]                           "", base::R.version$version.string), 
[17:28:00.448]                           platform = base::sprintf("%s (%s-bit)", 
[17:28:00.448]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:00.448]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:00.448]                             "release", "version")], collapse = " "), 
[17:28:00.448]                           hostname = base::Sys.info()[["nodename"]])
[17:28:00.448]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:28:00.448]                           info)
[17:28:00.448]                         info <- base::paste(info, collapse = "; ")
[17:28:00.448]                         if (!has_future) {
[17:28:00.448]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:00.448]                             info)
[17:28:00.448]                         }
[17:28:00.448]                         else {
[17:28:00.448]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:00.448]                             info, version)
[17:28:00.448]                         }
[17:28:00.448]                         base::stop(msg)
[17:28:00.448]                       }
[17:28:00.448]                     })
[17:28:00.448]                   }
[17:28:00.448]                   ...future.strategy.old <- future::plan("list")
[17:28:00.448]                   options(future.plan = NULL)
[17:28:00.448]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:00.448]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:00.448]                 }
[17:28:00.448]                 ...future.workdir <- getwd()
[17:28:00.448]             }
[17:28:00.448]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:00.448]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:00.448]         }
[17:28:00.448]         base::options(future.startup.script = FALSE, future.globals.onMissing = "error", 
[17:28:00.448]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:00.448]             future.globals.onMissing = "error", future.globals.onReference = NULL, 
[17:28:00.448]             future.globals.resolve = TRUE, future.resolve.recursive = NULL, 
[17:28:00.448]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:28:00.448]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:00.448]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:00.448]             base::names(...future.oldOptions))
[17:28:00.448]     }
[17:28:00.448]     if (FALSE) {
[17:28:00.448]     }
[17:28:00.448]     else {
[17:28:00.448]         if (TRUE) {
[17:28:00.448]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:00.448]                 open = "w")
[17:28:00.448]         }
[17:28:00.448]         else {
[17:28:00.448]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:00.448]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:00.448]         }
[17:28:00.448]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:00.448]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:00.448]             base::sink(type = "output", split = FALSE)
[17:28:00.448]             base::close(...future.stdout)
[17:28:00.448]         }, add = TRUE)
[17:28:00.448]     }
[17:28:00.448]     ...future.frame <- base::sys.nframe()
[17:28:00.448]     ...future.conditions <- base::list()
[17:28:00.448]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:00.448]     if (FALSE) {
[17:28:00.448]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:00.448]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:00.448]     }
[17:28:00.448]     ...future.result <- base::tryCatch({
[17:28:00.448]         base::withCallingHandlers({
[17:28:00.448]             ...future.value <- base::withVisible(base::local({
[17:28:00.448]                 x$a <- 1
[17:28:00.448]                 x
[17:28:00.448]             }))
[17:28:00.448]             future::FutureResult(value = ...future.value$value, 
[17:28:00.448]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:00.448]                   ...future.rng), globalenv = if (FALSE) 
[17:28:00.448]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:00.448]                     ...future.globalenv.names))
[17:28:00.448]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:00.448]         }, condition = base::local({
[17:28:00.448]             c <- base::c
[17:28:00.448]             inherits <- base::inherits
[17:28:00.448]             invokeRestart <- base::invokeRestart
[17:28:00.448]             length <- base::length
[17:28:00.448]             list <- base::list
[17:28:00.448]             seq.int <- base::seq.int
[17:28:00.448]             signalCondition <- base::signalCondition
[17:28:00.448]             sys.calls <- base::sys.calls
[17:28:00.448]             `[[` <- base::`[[`
[17:28:00.448]             `+` <- base::`+`
[17:28:00.448]             `<<-` <- base::`<<-`
[17:28:00.448]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:00.448]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:00.448]                   3L)]
[17:28:00.448]             }
[17:28:00.448]             function(cond) {
[17:28:00.448]                 is_error <- inherits(cond, "error")
[17:28:00.448]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:00.448]                   NULL)
[17:28:00.448]                 if (is_error) {
[17:28:00.448]                   sessionInformation <- function() {
[17:28:00.448]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:00.448]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:00.448]                       search = base::search(), system = base::Sys.info())
[17:28:00.448]                   }
[17:28:00.448]                   ...future.conditions[[length(...future.conditions) + 
[17:28:00.448]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:00.448]                     cond$call), session = sessionInformation(), 
[17:28:00.448]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:00.448]                   signalCondition(cond)
[17:28:00.448]                 }
[17:28:00.448]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:00.448]                 "immediateCondition"))) {
[17:28:00.448]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:00.448]                   ...future.conditions[[length(...future.conditions) + 
[17:28:00.448]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:00.448]                   if (TRUE && !signal) {
[17:28:00.448]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:00.448]                     {
[17:28:00.448]                       inherits <- base::inherits
[17:28:00.448]                       invokeRestart <- base::invokeRestart
[17:28:00.448]                       is.null <- base::is.null
[17:28:00.448]                       muffled <- FALSE
[17:28:00.448]                       if (inherits(cond, "message")) {
[17:28:00.448]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:00.448]                         if (muffled) 
[17:28:00.448]                           invokeRestart("muffleMessage")
[17:28:00.448]                       }
[17:28:00.448]                       else if (inherits(cond, "warning")) {
[17:28:00.448]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:00.448]                         if (muffled) 
[17:28:00.448]                           invokeRestart("muffleWarning")
[17:28:00.448]                       }
[17:28:00.448]                       else if (inherits(cond, "condition")) {
[17:28:00.448]                         if (!is.null(pattern)) {
[17:28:00.448]                           computeRestarts <- base::computeRestarts
[17:28:00.448]                           grepl <- base::grepl
[17:28:00.448]                           restarts <- computeRestarts(cond)
[17:28:00.448]                           for (restart in restarts) {
[17:28:00.448]                             name <- restart$name
[17:28:00.448]                             if (is.null(name)) 
[17:28:00.448]                               next
[17:28:00.448]                             if (!grepl(pattern, name)) 
[17:28:00.448]                               next
[17:28:00.448]                             invokeRestart(restart)
[17:28:00.448]                             muffled <- TRUE
[17:28:00.448]                             break
[17:28:00.448]                           }
[17:28:00.448]                         }
[17:28:00.448]                       }
[17:28:00.448]                       invisible(muffled)
[17:28:00.448]                     }
[17:28:00.448]                     muffleCondition(cond, pattern = "^muffle")
[17:28:00.448]                   }
[17:28:00.448]                 }
[17:28:00.448]                 else {
[17:28:00.448]                   if (TRUE) {
[17:28:00.448]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:00.448]                     {
[17:28:00.448]                       inherits <- base::inherits
[17:28:00.448]                       invokeRestart <- base::invokeRestart
[17:28:00.448]                       is.null <- base::is.null
[17:28:00.448]                       muffled <- FALSE
[17:28:00.448]                       if (inherits(cond, "message")) {
[17:28:00.448]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:00.448]                         if (muffled) 
[17:28:00.448]                           invokeRestart("muffleMessage")
[17:28:00.448]                       }
[17:28:00.448]                       else if (inherits(cond, "warning")) {
[17:28:00.448]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:00.448]                         if (muffled) 
[17:28:00.448]                           invokeRestart("muffleWarning")
[17:28:00.448]                       }
[17:28:00.448]                       else if (inherits(cond, "condition")) {
[17:28:00.448]                         if (!is.null(pattern)) {
[17:28:00.448]                           computeRestarts <- base::computeRestarts
[17:28:00.448]                           grepl <- base::grepl
[17:28:00.448]                           restarts <- computeRestarts(cond)
[17:28:00.448]                           for (restart in restarts) {
[17:28:00.448]                             name <- restart$name
[17:28:00.448]                             if (is.null(name)) 
[17:28:00.448]                               next
[17:28:00.448]                             if (!grepl(pattern, name)) 
[17:28:00.448]                               next
[17:28:00.448]                             invokeRestart(restart)
[17:28:00.448]                             muffled <- TRUE
[17:28:00.448]                             break
[17:28:00.448]                           }
[17:28:00.448]                         }
[17:28:00.448]                       }
[17:28:00.448]                       invisible(muffled)
[17:28:00.448]                     }
[17:28:00.448]                     muffleCondition(cond, pattern = "^muffle")
[17:28:00.448]                   }
[17:28:00.448]                 }
[17:28:00.448]             }
[17:28:00.448]         }))
[17:28:00.448]     }, error = function(ex) {
[17:28:00.448]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:00.448]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:00.448]                 ...future.rng), started = ...future.startTime, 
[17:28:00.448]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:00.448]             version = "1.8"), class = "FutureResult")
[17:28:00.448]     }, finally = {
[17:28:00.448]         if (!identical(...future.workdir, getwd())) 
[17:28:00.448]             setwd(...future.workdir)
[17:28:00.448]         {
[17:28:00.448]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:00.448]                 ...future.oldOptions$nwarnings <- NULL
[17:28:00.448]             }
[17:28:00.448]             base::options(...future.oldOptions)
[17:28:00.448]             if (.Platform$OS.type == "windows") {
[17:28:00.448]                 old_names <- names(...future.oldEnvVars)
[17:28:00.448]                 envs <- base::Sys.getenv()
[17:28:00.448]                 names <- names(envs)
[17:28:00.448]                 common <- intersect(names, old_names)
[17:28:00.448]                 added <- setdiff(names, old_names)
[17:28:00.448]                 removed <- setdiff(old_names, names)
[17:28:00.448]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:00.448]                   envs[common]]
[17:28:00.448]                 NAMES <- toupper(changed)
[17:28:00.448]                 args <- list()
[17:28:00.448]                 for (kk in seq_along(NAMES)) {
[17:28:00.448]                   name <- changed[[kk]]
[17:28:00.448]                   NAME <- NAMES[[kk]]
[17:28:00.448]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:00.448]                     next
[17:28:00.448]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:00.448]                 }
[17:28:00.448]                 NAMES <- toupper(added)
[17:28:00.448]                 for (kk in seq_along(NAMES)) {
[17:28:00.448]                   name <- added[[kk]]
[17:28:00.448]                   NAME <- NAMES[[kk]]
[17:28:00.448]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:00.448]                     next
[17:28:00.448]                   args[[name]] <- ""
[17:28:00.448]                 }
[17:28:00.448]                 NAMES <- toupper(removed)
[17:28:00.448]                 for (kk in seq_along(NAMES)) {
[17:28:00.448]                   name <- removed[[kk]]
[17:28:00.448]                   NAME <- NAMES[[kk]]
[17:28:00.448]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:00.448]                     next
[17:28:00.448]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:00.448]                 }
[17:28:00.448]                 if (length(args) > 0) 
[17:28:00.448]                   base::do.call(base::Sys.setenv, args = args)
[17:28:00.448]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:00.448]             }
[17:28:00.448]             else {
[17:28:00.448]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:00.448]             }
[17:28:00.448]             {
[17:28:00.448]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:00.448]                   0L) {
[17:28:00.448]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:00.448]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:00.448]                   base::options(opts)
[17:28:00.448]                 }
[17:28:00.448]                 {
[17:28:00.448]                   {
[17:28:00.448]                     NULL
[17:28:00.448]                     RNGkind("Mersenne-Twister")
[17:28:00.448]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:28:00.448]                       inherits = FALSE)
[17:28:00.448]                   }
[17:28:00.448]                   options(future.plan = NULL)
[17:28:00.448]                   if (is.na(NA_character_)) 
[17:28:00.448]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:00.448]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:00.448]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:00.448]                     .init = FALSE)
[17:28:00.448]                 }
[17:28:00.448]             }
[17:28:00.448]         }
[17:28:00.448]     })
[17:28:00.448]     if (TRUE) {
[17:28:00.448]         base::sink(type = "output", split = FALSE)
[17:28:00.448]         if (TRUE) {
[17:28:00.448]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:00.448]         }
[17:28:00.448]         else {
[17:28:00.448]             ...future.result["stdout"] <- base::list(NULL)
[17:28:00.448]         }
[17:28:00.448]         base::close(...future.stdout)
[17:28:00.448]         ...future.stdout <- NULL
[17:28:00.448]     }
[17:28:00.448]     ...future.result$conditions <- ...future.conditions
[17:28:00.448]     ...future.result$finished <- base::Sys.time()
[17:28:00.448]     ...future.result
[17:28:00.448] }
[17:28:00.454] assign_globals() ...
[17:28:00.455] List of 1
[17:28:00.455]  $ x: list()
[17:28:00.455]  - attr(*, "where")=List of 1
[17:28:00.455]   ..$ x:<environment: R_EmptyEnv> 
[17:28:00.455]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:28:00.455]  - attr(*, "resolved")= logi TRUE
[17:28:00.455]  - attr(*, "total_size")= int 31
[17:28:00.455]  - attr(*, "already-done")= logi TRUE
[17:28:00.461] - copied 'x' to environment
[17:28:00.462] assign_globals() ... done
[17:28:00.463] plan(): Setting new future strategy stack:
[17:28:00.463] List of future strategies:
[17:28:00.463] 1. sequential:
[17:28:00.463]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:00.463]    - tweaked: FALSE
[17:28:00.463]    - call: NULL
[17:28:00.464] plan(): nbrOfWorkers() = 1
[17:28:00.467] plan(): Setting new future strategy stack:
[17:28:00.467] List of future strategies:
[17:28:00.467] 1. sequential:
[17:28:00.467]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:00.467]    - tweaked: FALSE
[17:28:00.467]    - call: plan(strategy)
[17:28:00.468] plan(): nbrOfWorkers() = 1
[17:28:00.469] SequentialFuture started (and completed)
[17:28:00.469] - Launch lazy future ... done
[17:28:00.469] run() for 'SequentialFuture' ... done
$a
[1] 1

Warning in getGlobalsAndPackages(expr, envir = envir, tweak = tweakExpression,  :
  R option 'future.globals.resolve' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'TRUE'
[17:28:00.472] getGlobalsAndPackages() ...
Warning in getGlobalsAndPackages(expr, envir = envir, tweak = tweakExpression,  :
  R option 'future.globals.onMissing' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'error'
[17:28:00.473] Searching for globals...
[17:28:00.479] - globals found: [5] '{', 'x', '<-', '$', '$<-'
[17:28:00.479] Searching for globals ... DONE
[17:28:00.479] Resolving globals: TRUE
[17:28:00.480] Resolving any globals that are futures ...
[17:28:00.480] - globals: [5] '{', 'x', '<-', '$', '$<-'
[17:28:00.481] Resolving any globals that are futures ... DONE
[17:28:00.482] Resolving futures part of globals (recursively) ...
[17:28:00.482] resolve() on list ...
[17:28:00.483]  recursive: 99
[17:28:00.483]  length: 1
[17:28:00.483]  elements: 'x'
[17:28:00.484]  length: 0 (resolved future 1)
[17:28:00.484] resolve() on list ... DONE
[17:28:00.485] - globals: [1] 'x'
[17:28:00.485] Resolving futures part of globals (recursively) ... DONE
[17:28:00.486] The total size of the 1 globals is 31 bytes (31 bytes)
[17:28:00.486] The total size of the 1 globals exported for future expression ('{; x$a <- 1; x; }') is 31 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (31 bytes of class 'list')
[17:28:00.487] - globals: [1] 'x'
[17:28:00.487] 
[17:28:00.488] getGlobalsAndPackages() ... DONE
[17:28:00.488] run() for 'Future' ...
[17:28:00.489] - state: 'created'
[17:28:00.489] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:28:00.490] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:28:00.490] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:28:00.491]   - Field: 'label'
[17:28:00.491]   - Field: 'local'
[17:28:00.491]   - Field: 'owner'
[17:28:00.492]   - Field: 'envir'
[17:28:00.492]   - Field: 'packages'
[17:28:00.493]   - Field: 'gc'
[17:28:00.493]   - Field: 'conditions'
[17:28:00.493]   - Field: 'expr'
[17:28:00.494]   - Field: 'uuid'
[17:28:00.494]   - Field: 'seed'
[17:28:00.494]   - Field: 'version'
[17:28:00.495]   - Field: 'result'
[17:28:00.495]   - Field: 'asynchronous'
[17:28:00.495]   - Field: 'calls'
[17:28:00.496]   - Field: 'globals'
[17:28:00.496]   - Field: 'stdout'
[17:28:00.496]   - Field: 'earlySignal'
[17:28:00.497]   - Field: 'lazy'
[17:28:00.497]   - Field: 'state'
[17:28:00.497] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:28:00.498] - Launch lazy future ...
[17:28:00.498] Packages needed by the future expression (n = 0): <none>
[17:28:00.499] Packages needed by future strategies (n = 0): <none>
[17:28:00.500] {
[17:28:00.500]     {
[17:28:00.500]         {
[17:28:00.500]             ...future.startTime <- base::Sys.time()
[17:28:00.500]             {
[17:28:00.500]                 {
[17:28:00.500]                   {
[17:28:00.500]                     base::local({
[17:28:00.500]                       has_future <- base::requireNamespace("future", 
[17:28:00.500]                         quietly = TRUE)
[17:28:00.500]                       if (has_future) {
[17:28:00.500]                         ns <- base::getNamespace("future")
[17:28:00.500]                         version <- ns[[".package"]][["version"]]
[17:28:00.500]                         if (is.null(version)) 
[17:28:00.500]                           version <- utils::packageVersion("future")
[17:28:00.500]                       }
[17:28:00.500]                       else {
[17:28:00.500]                         version <- NULL
[17:28:00.500]                       }
[17:28:00.500]                       if (!has_future || version < "1.8.0") {
[17:28:00.500]                         info <- base::c(r_version = base::gsub("R version ", 
[17:28:00.500]                           "", base::R.version$version.string), 
[17:28:00.500]                           platform = base::sprintf("%s (%s-bit)", 
[17:28:00.500]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:00.500]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:00.500]                             "release", "version")], collapse = " "), 
[17:28:00.500]                           hostname = base::Sys.info()[["nodename"]])
[17:28:00.500]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:28:00.500]                           info)
[17:28:00.500]                         info <- base::paste(info, collapse = "; ")
[17:28:00.500]                         if (!has_future) {
[17:28:00.500]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:00.500]                             info)
[17:28:00.500]                         }
[17:28:00.500]                         else {
[17:28:00.500]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:00.500]                             info, version)
[17:28:00.500]                         }
[17:28:00.500]                         base::stop(msg)
[17:28:00.500]                       }
[17:28:00.500]                     })
[17:28:00.500]                   }
[17:28:00.500]                   ...future.strategy.old <- future::plan("list")
[17:28:00.500]                   options(future.plan = NULL)
[17:28:00.500]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:00.500]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:00.500]                 }
[17:28:00.500]                 ...future.workdir <- getwd()
[17:28:00.500]             }
[17:28:00.500]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:00.500]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:00.500]         }
[17:28:00.500]         base::options(future.startup.script = FALSE, future.globals.onMissing = "error", 
[17:28:00.500]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:00.500]             future.globals.onMissing = "error", future.globals.onReference = NULL, 
[17:28:00.500]             future.globals.resolve = TRUE, future.resolve.recursive = NULL, 
[17:28:00.500]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:28:00.500]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:00.500]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:00.500]             base::names(...future.oldOptions))
[17:28:00.500]     }
[17:28:00.500]     if (FALSE) {
[17:28:00.500]     }
[17:28:00.500]     else {
[17:28:00.500]         if (TRUE) {
[17:28:00.500]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:00.500]                 open = "w")
[17:28:00.500]         }
[17:28:00.500]         else {
[17:28:00.500]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:00.500]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:00.500]         }
[17:28:00.500]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:00.500]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:00.500]             base::sink(type = "output", split = FALSE)
[17:28:00.500]             base::close(...future.stdout)
[17:28:00.500]         }, add = TRUE)
[17:28:00.500]     }
[17:28:00.500]     ...future.frame <- base::sys.nframe()
[17:28:00.500]     ...future.conditions <- base::list()
[17:28:00.500]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:00.500]     if (FALSE) {
[17:28:00.500]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:00.500]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:00.500]     }
[17:28:00.500]     ...future.result <- base::tryCatch({
[17:28:00.500]         base::withCallingHandlers({
[17:28:00.500]             ...future.value <- base::withVisible(base::local({
[17:28:00.500]                 x$a <- 1
[17:28:00.500]                 x
[17:28:00.500]             }))
[17:28:00.500]             future::FutureResult(value = ...future.value$value, 
[17:28:00.500]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:00.500]                   ...future.rng), globalenv = if (FALSE) 
[17:28:00.500]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:00.500]                     ...future.globalenv.names))
[17:28:00.500]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:00.500]         }, condition = base::local({
[17:28:00.500]             c <- base::c
[17:28:00.500]             inherits <- base::inherits
[17:28:00.500]             invokeRestart <- base::invokeRestart
[17:28:00.500]             length <- base::length
[17:28:00.500]             list <- base::list
[17:28:00.500]             seq.int <- base::seq.int
[17:28:00.500]             signalCondition <- base::signalCondition
[17:28:00.500]             sys.calls <- base::sys.calls
[17:28:00.500]             `[[` <- base::`[[`
[17:28:00.500]             `+` <- base::`+`
[17:28:00.500]             `<<-` <- base::`<<-`
[17:28:00.500]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:00.500]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:00.500]                   3L)]
[17:28:00.500]             }
[17:28:00.500]             function(cond) {
[17:28:00.500]                 is_error <- inherits(cond, "error")
[17:28:00.500]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:00.500]                   NULL)
[17:28:00.500]                 if (is_error) {
[17:28:00.500]                   sessionInformation <- function() {
[17:28:00.500]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:00.500]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:00.500]                       search = base::search(), system = base::Sys.info())
[17:28:00.500]                   }
[17:28:00.500]                   ...future.conditions[[length(...future.conditions) + 
[17:28:00.500]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:00.500]                     cond$call), session = sessionInformation(), 
[17:28:00.500]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:00.500]                   signalCondition(cond)
[17:28:00.500]                 }
[17:28:00.500]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:00.500]                 "immediateCondition"))) {
[17:28:00.500]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:00.500]                   ...future.conditions[[length(...future.conditions) + 
[17:28:00.500]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:00.500]                   if (TRUE && !signal) {
[17:28:00.500]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:00.500]                     {
[17:28:00.500]                       inherits <- base::inherits
[17:28:00.500]                       invokeRestart <- base::invokeRestart
[17:28:00.500]                       is.null <- base::is.null
[17:28:00.500]                       muffled <- FALSE
[17:28:00.500]                       if (inherits(cond, "message")) {
[17:28:00.500]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:00.500]                         if (muffled) 
[17:28:00.500]                           invokeRestart("muffleMessage")
[17:28:00.500]                       }
[17:28:00.500]                       else if (inherits(cond, "warning")) {
[17:28:00.500]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:00.500]                         if (muffled) 
[17:28:00.500]                           invokeRestart("muffleWarning")
[17:28:00.500]                       }
[17:28:00.500]                       else if (inherits(cond, "condition")) {
[17:28:00.500]                         if (!is.null(pattern)) {
[17:28:00.500]                           computeRestarts <- base::computeRestarts
[17:28:00.500]                           grepl <- base::grepl
[17:28:00.500]                           restarts <- computeRestarts(cond)
[17:28:00.500]                           for (restart in restarts) {
[17:28:00.500]                             name <- restart$name
[17:28:00.500]                             if (is.null(name)) 
[17:28:00.500]                               next
[17:28:00.500]                             if (!grepl(pattern, name)) 
[17:28:00.500]                               next
[17:28:00.500]                             invokeRestart(restart)
[17:28:00.500]                             muffled <- TRUE
[17:28:00.500]                             break
[17:28:00.500]                           }
[17:28:00.500]                         }
[17:28:00.500]                       }
[17:28:00.500]                       invisible(muffled)
[17:28:00.500]                     }
[17:28:00.500]                     muffleCondition(cond, pattern = "^muffle")
[17:28:00.500]                   }
[17:28:00.500]                 }
[17:28:00.500]                 else {
[17:28:00.500]                   if (TRUE) {
[17:28:00.500]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:00.500]                     {
[17:28:00.500]                       inherits <- base::inherits
[17:28:00.500]                       invokeRestart <- base::invokeRestart
[17:28:00.500]                       is.null <- base::is.null
[17:28:00.500]                       muffled <- FALSE
[17:28:00.500]                       if (inherits(cond, "message")) {
[17:28:00.500]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:00.500]                         if (muffled) 
[17:28:00.500]                           invokeRestart("muffleMessage")
[17:28:00.500]                       }
[17:28:00.500]                       else if (inherits(cond, "warning")) {
[17:28:00.500]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:00.500]                         if (muffled) 
[17:28:00.500]                           invokeRestart("muffleWarning")
[17:28:00.500]                       }
[17:28:00.500]                       else if (inherits(cond, "condition")) {
[17:28:00.500]                         if (!is.null(pattern)) {
[17:28:00.500]                           computeRestarts <- base::computeRestarts
[17:28:00.500]                           grepl <- base::grepl
[17:28:00.500]                           restarts <- computeRestarts(cond)
[17:28:00.500]                           for (restart in restarts) {
[17:28:00.500]                             name <- restart$name
[17:28:00.500]                             if (is.null(name)) 
[17:28:00.500]                               next
[17:28:00.500]                             if (!grepl(pattern, name)) 
[17:28:00.500]                               next
[17:28:00.500]                             invokeRestart(restart)
[17:28:00.500]                             muffled <- TRUE
[17:28:00.500]                             break
[17:28:00.500]                           }
[17:28:00.500]                         }
[17:28:00.500]                       }
[17:28:00.500]                       invisible(muffled)
[17:28:00.500]                     }
[17:28:00.500]                     muffleCondition(cond, pattern = "^muffle")
[17:28:00.500]                   }
[17:28:00.500]                 }
[17:28:00.500]             }
[17:28:00.500]         }))
[17:28:00.500]     }, error = function(ex) {
[17:28:00.500]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:00.500]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:00.500]                 ...future.rng), started = ...future.startTime, 
[17:28:00.500]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:00.500]             version = "1.8"), class = "FutureResult")
[17:28:00.500]     }, finally = {
[17:28:00.500]         if (!identical(...future.workdir, getwd())) 
[17:28:00.500]             setwd(...future.workdir)
[17:28:00.500]         {
[17:28:00.500]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:00.500]                 ...future.oldOptions$nwarnings <- NULL
[17:28:00.500]             }
[17:28:00.500]             base::options(...future.oldOptions)
[17:28:00.500]             if (.Platform$OS.type == "windows") {
[17:28:00.500]                 old_names <- names(...future.oldEnvVars)
[17:28:00.500]                 envs <- base::Sys.getenv()
[17:28:00.500]                 names <- names(envs)
[17:28:00.500]                 common <- intersect(names, old_names)
[17:28:00.500]                 added <- setdiff(names, old_names)
[17:28:00.500]                 removed <- setdiff(old_names, names)
[17:28:00.500]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:00.500]                   envs[common]]
[17:28:00.500]                 NAMES <- toupper(changed)
[17:28:00.500]                 args <- list()
[17:28:00.500]                 for (kk in seq_along(NAMES)) {
[17:28:00.500]                   name <- changed[[kk]]
[17:28:00.500]                   NAME <- NAMES[[kk]]
[17:28:00.500]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:00.500]                     next
[17:28:00.500]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:00.500]                 }
[17:28:00.500]                 NAMES <- toupper(added)
[17:28:00.500]                 for (kk in seq_along(NAMES)) {
[17:28:00.500]                   name <- added[[kk]]
[17:28:00.500]                   NAME <- NAMES[[kk]]
[17:28:00.500]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:00.500]                     next
[17:28:00.500]                   args[[name]] <- ""
[17:28:00.500]                 }
[17:28:00.500]                 NAMES <- toupper(removed)
[17:28:00.500]                 for (kk in seq_along(NAMES)) {
[17:28:00.500]                   name <- removed[[kk]]
[17:28:00.500]                   NAME <- NAMES[[kk]]
[17:28:00.500]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:00.500]                     next
[17:28:00.500]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:00.500]                 }
[17:28:00.500]                 if (length(args) > 0) 
[17:28:00.500]                   base::do.call(base::Sys.setenv, args = args)
[17:28:00.500]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:00.500]             }
[17:28:00.500]             else {
[17:28:00.500]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:00.500]             }
[17:28:00.500]             {
[17:28:00.500]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:00.500]                   0L) {
[17:28:00.500]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:00.500]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:00.500]                   base::options(opts)
[17:28:00.500]                 }
[17:28:00.500]                 {
[17:28:00.500]                   {
[17:28:00.500]                     NULL
[17:28:00.500]                     RNGkind("Mersenne-Twister")
[17:28:00.500]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:28:00.500]                       inherits = FALSE)
[17:28:00.500]                   }
[17:28:00.500]                   options(future.plan = NULL)
[17:28:00.500]                   if (is.na(NA_character_)) 
[17:28:00.500]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:00.500]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:00.500]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:00.500]                     .init = FALSE)
[17:28:00.500]                 }
[17:28:00.500]             }
[17:28:00.500]         }
[17:28:00.500]     })
[17:28:00.500]     if (TRUE) {
[17:28:00.500]         base::sink(type = "output", split = FALSE)
[17:28:00.500]         if (TRUE) {
[17:28:00.500]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:00.500]         }
[17:28:00.500]         else {
[17:28:00.500]             ...future.result["stdout"] <- base::list(NULL)
[17:28:00.500]         }
[17:28:00.500]         base::close(...future.stdout)
[17:28:00.500]         ...future.stdout <- NULL
[17:28:00.500]     }
[17:28:00.500]     ...future.result$conditions <- ...future.conditions
[17:28:00.500]     ...future.result$finished <- base::Sys.time()
[17:28:00.500]     ...future.result
[17:28:00.500] }
[17:28:00.507] assign_globals() ...
[17:28:00.507] List of 1
[17:28:00.507]  $ x: list()
[17:28:00.507]  - attr(*, "where")=List of 1
[17:28:00.507]   ..$ x:<environment: R_EmptyEnv> 
[17:28:00.507]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:28:00.507]  - attr(*, "resolved")= logi TRUE
[17:28:00.507]  - attr(*, "total_size")= int 31
[17:28:00.507]  - attr(*, "already-done")= logi TRUE
[17:28:00.517] - copied 'x' to environment
[17:28:00.517] assign_globals() ... done
[17:28:00.518] plan(): Setting new future strategy stack:
[17:28:00.518] List of future strategies:
[17:28:00.518] 1. sequential:
[17:28:00.518]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:00.518]    - tweaked: FALSE
[17:28:00.518]    - call: NULL
[17:28:00.519] plan(): nbrOfWorkers() = 1
[17:28:00.521] plan(): Setting new future strategy stack:
[17:28:00.522] List of future strategies:
[17:28:00.522] 1. sequential:
[17:28:00.522]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:00.522]    - tweaked: FALSE
[17:28:00.522]    - call: plan(strategy)
[17:28:00.523] plan(): nbrOfWorkers() = 1
[17:28:00.524] SequentialFuture started (and completed)
[17:28:00.524] - Launch lazy future ... done
[17:28:00.524] run() for 'SequentialFuture' ... done
$a
[1] 1

Warning in getGlobalsAndPackages(expr, envir = envir, tweak = tweakExpression,  :
  R option 'future.globals.resolve' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'TRUE'
[17:28:00.526] getGlobalsAndPackages() ...
Warning in getGlobalsAndPackages(expr, envir = envir, tweak = tweakExpression,  :
  R option 'future.globals.onMissing' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'error'
[17:28:00.526] Searching for globals...
[17:28:00.531] - globals found: [5] '{', 'x', '<-', '$', '$<-'
[17:28:00.531] Searching for globals ... DONE
[17:28:00.532] Resolving globals: TRUE
[17:28:00.532] Resolving any globals that are futures ...
[17:28:00.532] - globals: [5] '{', 'x', '<-', '$', '$<-'
[17:28:00.533] Resolving any globals that are futures ... DONE
[17:28:00.533] Resolving futures part of globals (recursively) ...
[17:28:00.534] resolve() on list ...
[17:28:00.534]  recursive: 99
[17:28:00.535]  length: 1
[17:28:00.535]  elements: 'x'
[17:28:00.535]  length: 0 (resolved future 1)
[17:28:00.536] resolve() on list ... DONE
[17:28:00.536] - globals: [1] 'x'
[17:28:00.536] Resolving futures part of globals (recursively) ... DONE
[17:28:00.537] The total size of the 1 globals is 31 bytes (31 bytes)
[17:28:00.538] The total size of the 1 globals exported for future expression ('{; x$a <- 1; x; }') is 31 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (31 bytes of class 'list')
[17:28:00.538] - globals: [1] 'x'
[17:28:00.538] 
[17:28:00.539] getGlobalsAndPackages() ... DONE
[17:28:00.539] run() for 'Future' ...
[17:28:00.540] - state: 'created'
[17:28:00.540] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:28:00.541] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:28:00.541] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:28:00.542]   - Field: 'label'
[17:28:00.542]   - Field: 'local'
[17:28:00.542]   - Field: 'owner'
[17:28:00.543]   - Field: 'envir'
[17:28:00.543]   - Field: 'packages'
[17:28:00.543]   - Field: 'gc'
[17:28:00.544]   - Field: 'conditions'
[17:28:00.544]   - Field: 'expr'
[17:28:00.544]   - Field: 'uuid'
[17:28:00.545]   - Field: 'seed'
[17:28:00.545]   - Field: 'version'
[17:28:00.545]   - Field: 'result'
[17:28:00.546]   - Field: 'asynchronous'
[17:28:00.546]   - Field: 'calls'
[17:28:00.546]   - Field: 'globals'
[17:28:00.547]   - Field: 'stdout'
[17:28:00.547]   - Field: 'earlySignal'
[17:28:00.547]   - Field: 'lazy'
[17:28:00.548]   - Field: 'state'
[17:28:00.548] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:28:00.548] - Launch lazy future ...
[17:28:00.549] Packages needed by the future expression (n = 0): <none>
[17:28:00.549] Packages needed by future strategies (n = 0): <none>
[17:28:00.550] {
[17:28:00.550]     {
[17:28:00.550]         {
[17:28:00.550]             ...future.startTime <- base::Sys.time()
[17:28:00.550]             {
[17:28:00.550]                 {
[17:28:00.550]                   {
[17:28:00.550]                     base::local({
[17:28:00.550]                       has_future <- base::requireNamespace("future", 
[17:28:00.550]                         quietly = TRUE)
[17:28:00.550]                       if (has_future) {
[17:28:00.550]                         ns <- base::getNamespace("future")
[17:28:00.550]                         version <- ns[[".package"]][["version"]]
[17:28:00.550]                         if (is.null(version)) 
[17:28:00.550]                           version <- utils::packageVersion("future")
[17:28:00.550]                       }
[17:28:00.550]                       else {
[17:28:00.550]                         version <- NULL
[17:28:00.550]                       }
[17:28:00.550]                       if (!has_future || version < "1.8.0") {
[17:28:00.550]                         info <- base::c(r_version = base::gsub("R version ", 
[17:28:00.550]                           "", base::R.version$version.string), 
[17:28:00.550]                           platform = base::sprintf("%s (%s-bit)", 
[17:28:00.550]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:00.550]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:00.550]                             "release", "version")], collapse = " "), 
[17:28:00.550]                           hostname = base::Sys.info()[["nodename"]])
[17:28:00.550]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:28:00.550]                           info)
[17:28:00.550]                         info <- base::paste(info, collapse = "; ")
[17:28:00.550]                         if (!has_future) {
[17:28:00.550]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:00.550]                             info)
[17:28:00.550]                         }
[17:28:00.550]                         else {
[17:28:00.550]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:00.550]                             info, version)
[17:28:00.550]                         }
[17:28:00.550]                         base::stop(msg)
[17:28:00.550]                       }
[17:28:00.550]                     })
[17:28:00.550]                   }
[17:28:00.550]                   ...future.strategy.old <- future::plan("list")
[17:28:00.550]                   options(future.plan = NULL)
[17:28:00.550]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:00.550]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:00.550]                 }
[17:28:00.550]                 ...future.workdir <- getwd()
[17:28:00.550]             }
[17:28:00.550]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:00.550]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:00.550]         }
[17:28:00.550]         base::options(future.startup.script = FALSE, future.globals.onMissing = "error", 
[17:28:00.550]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:00.550]             future.globals.onMissing = "error", future.globals.onReference = NULL, 
[17:28:00.550]             future.globals.resolve = TRUE, future.resolve.recursive = NULL, 
[17:28:00.550]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:28:00.550]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:00.550]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:00.550]             base::names(...future.oldOptions))
[17:28:00.550]     }
[17:28:00.550]     if (FALSE) {
[17:28:00.550]     }
[17:28:00.550]     else {
[17:28:00.550]         if (TRUE) {
[17:28:00.550]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:00.550]                 open = "w")
[17:28:00.550]         }
[17:28:00.550]         else {
[17:28:00.550]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:00.550]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:00.550]         }
[17:28:00.550]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:00.550]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:00.550]             base::sink(type = "output", split = FALSE)
[17:28:00.550]             base::close(...future.stdout)
[17:28:00.550]         }, add = TRUE)
[17:28:00.550]     }
[17:28:00.550]     ...future.frame <- base::sys.nframe()
[17:28:00.550]     ...future.conditions <- base::list()
[17:28:00.550]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:00.550]     if (FALSE) {
[17:28:00.550]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:00.550]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:00.550]     }
[17:28:00.550]     ...future.result <- base::tryCatch({
[17:28:00.550]         base::withCallingHandlers({
[17:28:00.550]             ...future.value <- base::withVisible(base::local({
[17:28:00.550]                 x$a <- 1
[17:28:00.550]                 x
[17:28:00.550]             }))
[17:28:00.550]             future::FutureResult(value = ...future.value$value, 
[17:28:00.550]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:00.550]                   ...future.rng), globalenv = if (FALSE) 
[17:28:00.550]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:00.550]                     ...future.globalenv.names))
[17:28:00.550]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:00.550]         }, condition = base::local({
[17:28:00.550]             c <- base::c
[17:28:00.550]             inherits <- base::inherits
[17:28:00.550]             invokeRestart <- base::invokeRestart
[17:28:00.550]             length <- base::length
[17:28:00.550]             list <- base::list
[17:28:00.550]             seq.int <- base::seq.int
[17:28:00.550]             signalCondition <- base::signalCondition
[17:28:00.550]             sys.calls <- base::sys.calls
[17:28:00.550]             `[[` <- base::`[[`
[17:28:00.550]             `+` <- base::`+`
[17:28:00.550]             `<<-` <- base::`<<-`
[17:28:00.550]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:00.550]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:00.550]                   3L)]
[17:28:00.550]             }
[17:28:00.550]             function(cond) {
[17:28:00.550]                 is_error <- inherits(cond, "error")
[17:28:00.550]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:00.550]                   NULL)
[17:28:00.550]                 if (is_error) {
[17:28:00.550]                   sessionInformation <- function() {
[17:28:00.550]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:00.550]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:00.550]                       search = base::search(), system = base::Sys.info())
[17:28:00.550]                   }
[17:28:00.550]                   ...future.conditions[[length(...future.conditions) + 
[17:28:00.550]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:00.550]                     cond$call), session = sessionInformation(), 
[17:28:00.550]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:00.550]                   signalCondition(cond)
[17:28:00.550]                 }
[17:28:00.550]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:00.550]                 "immediateCondition"))) {
[17:28:00.550]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:00.550]                   ...future.conditions[[length(...future.conditions) + 
[17:28:00.550]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:00.550]                   if (TRUE && !signal) {
[17:28:00.550]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:00.550]                     {
[17:28:00.550]                       inherits <- base::inherits
[17:28:00.550]                       invokeRestart <- base::invokeRestart
[17:28:00.550]                       is.null <- base::is.null
[17:28:00.550]                       muffled <- FALSE
[17:28:00.550]                       if (inherits(cond, "message")) {
[17:28:00.550]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:00.550]                         if (muffled) 
[17:28:00.550]                           invokeRestart("muffleMessage")
[17:28:00.550]                       }
[17:28:00.550]                       else if (inherits(cond, "warning")) {
[17:28:00.550]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:00.550]                         if (muffled) 
[17:28:00.550]                           invokeRestart("muffleWarning")
[17:28:00.550]                       }
[17:28:00.550]                       else if (inherits(cond, "condition")) {
[17:28:00.550]                         if (!is.null(pattern)) {
[17:28:00.550]                           computeRestarts <- base::computeRestarts
[17:28:00.550]                           grepl <- base::grepl
[17:28:00.550]                           restarts <- computeRestarts(cond)
[17:28:00.550]                           for (restart in restarts) {
[17:28:00.550]                             name <- restart$name
[17:28:00.550]                             if (is.null(name)) 
[17:28:00.550]                               next
[17:28:00.550]                             if (!grepl(pattern, name)) 
[17:28:00.550]                               next
[17:28:00.550]                             invokeRestart(restart)
[17:28:00.550]                             muffled <- TRUE
[17:28:00.550]                             break
[17:28:00.550]                           }
[17:28:00.550]                         }
[17:28:00.550]                       }
[17:28:00.550]                       invisible(muffled)
[17:28:00.550]                     }
[17:28:00.550]                     muffleCondition(cond, pattern = "^muffle")
[17:28:00.550]                   }
[17:28:00.550]                 }
[17:28:00.550]                 else {
[17:28:00.550]                   if (TRUE) {
[17:28:00.550]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:00.550]                     {
[17:28:00.550]                       inherits <- base::inherits
[17:28:00.550]                       invokeRestart <- base::invokeRestart
[17:28:00.550]                       is.null <- base::is.null
[17:28:00.550]                       muffled <- FALSE
[17:28:00.550]                       if (inherits(cond, "message")) {
[17:28:00.550]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:00.550]                         if (muffled) 
[17:28:00.550]                           invokeRestart("muffleMessage")
[17:28:00.550]                       }
[17:28:00.550]                       else if (inherits(cond, "warning")) {
[17:28:00.550]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:00.550]                         if (muffled) 
[17:28:00.550]                           invokeRestart("muffleWarning")
[17:28:00.550]                       }
[17:28:00.550]                       else if (inherits(cond, "condition")) {
[17:28:00.550]                         if (!is.null(pattern)) {
[17:28:00.550]                           computeRestarts <- base::computeRestarts
[17:28:00.550]                           grepl <- base::grepl
[17:28:00.550]                           restarts <- computeRestarts(cond)
[17:28:00.550]                           for (restart in restarts) {
[17:28:00.550]                             name <- restart$name
[17:28:00.550]                             if (is.null(name)) 
[17:28:00.550]                               next
[17:28:00.550]                             if (!grepl(pattern, name)) 
[17:28:00.550]                               next
[17:28:00.550]                             invokeRestart(restart)
[17:28:00.550]                             muffled <- TRUE
[17:28:00.550]                             break
[17:28:00.550]                           }
[17:28:00.550]                         }
[17:28:00.550]                       }
[17:28:00.550]                       invisible(muffled)
[17:28:00.550]                     }
[17:28:00.550]                     muffleCondition(cond, pattern = "^muffle")
[17:28:00.550]                   }
[17:28:00.550]                 }
[17:28:00.550]             }
[17:28:00.550]         }))
[17:28:00.550]     }, error = function(ex) {
[17:28:00.550]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:00.550]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:00.550]                 ...future.rng), started = ...future.startTime, 
[17:28:00.550]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:00.550]             version = "1.8"), class = "FutureResult")
[17:28:00.550]     }, finally = {
[17:28:00.550]         if (!identical(...future.workdir, getwd())) 
[17:28:00.550]             setwd(...future.workdir)
[17:28:00.550]         {
[17:28:00.550]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:00.550]                 ...future.oldOptions$nwarnings <- NULL
[17:28:00.550]             }
[17:28:00.550]             base::options(...future.oldOptions)
[17:28:00.550]             if (.Platform$OS.type == "windows") {
[17:28:00.550]                 old_names <- names(...future.oldEnvVars)
[17:28:00.550]                 envs <- base::Sys.getenv()
[17:28:00.550]                 names <- names(envs)
[17:28:00.550]                 common <- intersect(names, old_names)
[17:28:00.550]                 added <- setdiff(names, old_names)
[17:28:00.550]                 removed <- setdiff(old_names, names)
[17:28:00.550]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:00.550]                   envs[common]]
[17:28:00.550]                 NAMES <- toupper(changed)
[17:28:00.550]                 args <- list()
[17:28:00.550]                 for (kk in seq_along(NAMES)) {
[17:28:00.550]                   name <- changed[[kk]]
[17:28:00.550]                   NAME <- NAMES[[kk]]
[17:28:00.550]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:00.550]                     next
[17:28:00.550]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:00.550]                 }
[17:28:00.550]                 NAMES <- toupper(added)
[17:28:00.550]                 for (kk in seq_along(NAMES)) {
[17:28:00.550]                   name <- added[[kk]]
[17:28:00.550]                   NAME <- NAMES[[kk]]
[17:28:00.550]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:00.550]                     next
[17:28:00.550]                   args[[name]] <- ""
[17:28:00.550]                 }
[17:28:00.550]                 NAMES <- toupper(removed)
[17:28:00.550]                 for (kk in seq_along(NAMES)) {
[17:28:00.550]                   name <- removed[[kk]]
[17:28:00.550]                   NAME <- NAMES[[kk]]
[17:28:00.550]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:00.550]                     next
[17:28:00.550]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:00.550]                 }
[17:28:00.550]                 if (length(args) > 0) 
[17:28:00.550]                   base::do.call(base::Sys.setenv, args = args)
[17:28:00.550]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:00.550]             }
[17:28:00.550]             else {
[17:28:00.550]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:00.550]             }
[17:28:00.550]             {
[17:28:00.550]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:00.550]                   0L) {
[17:28:00.550]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:00.550]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:00.550]                   base::options(opts)
[17:28:00.550]                 }
[17:28:00.550]                 {
[17:28:00.550]                   {
[17:28:00.550]                     NULL
[17:28:00.550]                     RNGkind("Mersenne-Twister")
[17:28:00.550]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:28:00.550]                       inherits = FALSE)
[17:28:00.550]                   }
[17:28:00.550]                   options(future.plan = NULL)
[17:28:00.550]                   if (is.na(NA_character_)) 
[17:28:00.550]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:00.550]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:00.550]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:00.550]                     .init = FALSE)
[17:28:00.550]                 }
[17:28:00.550]             }
[17:28:00.550]         }
[17:28:00.550]     })
[17:28:00.550]     if (TRUE) {
[17:28:00.550]         base::sink(type = "output", split = FALSE)
[17:28:00.550]         if (TRUE) {
[17:28:00.550]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:00.550]         }
[17:28:00.550]         else {
[17:28:00.550]             ...future.result["stdout"] <- base::list(NULL)
[17:28:00.550]         }
[17:28:00.550]         base::close(...future.stdout)
[17:28:00.550]         ...future.stdout <- NULL
[17:28:00.550]     }
[17:28:00.550]     ...future.result$conditions <- ...future.conditions
[17:28:00.550]     ...future.result$finished <- base::Sys.time()
[17:28:00.550]     ...future.result
[17:28:00.550] }
[17:28:00.557] assign_globals() ...
[17:28:00.557] List of 1
[17:28:00.557]  $ x: list()
[17:28:00.557]  - attr(*, "where")=List of 1
[17:28:00.557]   ..$ x:<environment: R_EmptyEnv> 
[17:28:00.557]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:28:00.557]  - attr(*, "resolved")= logi TRUE
[17:28:00.557]  - attr(*, "total_size")= int 31
[17:28:00.557]  - attr(*, "already-done")= logi TRUE
[17:28:00.563] - copied 'x' to environment
[17:28:00.563] assign_globals() ... done
[17:28:00.564] plan(): Setting new future strategy stack:
[17:28:00.564] List of future strategies:
[17:28:00.564] 1. sequential:
[17:28:00.564]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:00.564]    - tweaked: FALSE
[17:28:00.564]    - call: NULL
[17:28:00.565] plan(): nbrOfWorkers() = 1
[17:28:00.568] plan(): Setting new future strategy stack:
[17:28:00.568] List of future strategies:
[17:28:00.568] 1. sequential:
[17:28:00.568]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:00.568]    - tweaked: FALSE
[17:28:00.568]    - call: plan(strategy)
[17:28:00.569] plan(): nbrOfWorkers() = 1
[17:28:00.570] SequentialFuture started (and completed)
[17:28:00.570] - Launch lazy future ... done
[17:28:00.570] run() for 'SequentialFuture' ... done
$a
[1] 1

Warning in getGlobalsAndPackages(expr, envir = envir, tweak = tweakExpression,  :
  R option 'future.globals.resolve' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'TRUE'
[17:28:00.572] getGlobalsAndPackages() ...
Warning in getGlobalsAndPackages(expr, envir = envir, tweak = tweakExpression,  :
  R option 'future.globals.onMissing' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'error'
[17:28:00.576] Searching for globals...
[17:28:00.582] - globals found: [5] '{', '<-', 'list', '$', '$<-'
[17:28:00.582] Searching for globals ... DONE
[17:28:00.583] Resolving globals: TRUE
[17:28:00.583] Resolving any globals that are futures ...
[17:28:00.583] - globals: [5] '{', '<-', 'list', '$', '$<-'
[17:28:00.584] Resolving any globals that are futures ... DONE
[17:28:00.585] 
[17:28:00.585] 
[17:28:00.585] getGlobalsAndPackages() ... DONE
[17:28:00.586] run() for 'Future' ...
[17:28:00.586] - state: 'created'
[17:28:00.587] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:28:00.587] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:28:00.588] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:28:00.588]   - Field: 'label'
[17:28:00.588]   - Field: 'local'
[17:28:00.589]   - Field: 'owner'
[17:28:00.589]   - Field: 'envir'
[17:28:00.589]   - Field: 'packages'
[17:28:00.590]   - Field: 'gc'
[17:28:00.590]   - Field: 'conditions'
[17:28:00.590]   - Field: 'expr'
[17:28:00.591]   - Field: 'uuid'
[17:28:00.591]   - Field: 'seed'
[17:28:00.591]   - Field: 'version'
[17:28:00.592]   - Field: 'result'
[17:28:00.592]   - Field: 'asynchronous'
[17:28:00.592]   - Field: 'calls'
[17:28:00.593]   - Field: 'globals'
[17:28:00.593]   - Field: 'stdout'
[17:28:00.593]   - Field: 'earlySignal'
[17:28:00.594]   - Field: 'lazy'
[17:28:00.594]   - Field: 'state'
[17:28:00.594] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:28:00.595] - Launch lazy future ...
[17:28:00.595] Packages needed by the future expression (n = 0): <none>
[17:28:00.595] Packages needed by future strategies (n = 0): <none>
[17:28:00.596] {
[17:28:00.596]     {
[17:28:00.596]         {
[17:28:00.596]             ...future.startTime <- base::Sys.time()
[17:28:00.596]             {
[17:28:00.596]                 {
[17:28:00.596]                   {
[17:28:00.596]                     base::local({
[17:28:00.596]                       has_future <- base::requireNamespace("future", 
[17:28:00.596]                         quietly = TRUE)
[17:28:00.596]                       if (has_future) {
[17:28:00.596]                         ns <- base::getNamespace("future")
[17:28:00.596]                         version <- ns[[".package"]][["version"]]
[17:28:00.596]                         if (is.null(version)) 
[17:28:00.596]                           version <- utils::packageVersion("future")
[17:28:00.596]                       }
[17:28:00.596]                       else {
[17:28:00.596]                         version <- NULL
[17:28:00.596]                       }
[17:28:00.596]                       if (!has_future || version < "1.8.0") {
[17:28:00.596]                         info <- base::c(r_version = base::gsub("R version ", 
[17:28:00.596]                           "", base::R.version$version.string), 
[17:28:00.596]                           platform = base::sprintf("%s (%s-bit)", 
[17:28:00.596]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:00.596]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:00.596]                             "release", "version")], collapse = " "), 
[17:28:00.596]                           hostname = base::Sys.info()[["nodename"]])
[17:28:00.596]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:28:00.596]                           info)
[17:28:00.596]                         info <- base::paste(info, collapse = "; ")
[17:28:00.596]                         if (!has_future) {
[17:28:00.596]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:00.596]                             info)
[17:28:00.596]                         }
[17:28:00.596]                         else {
[17:28:00.596]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:00.596]                             info, version)
[17:28:00.596]                         }
[17:28:00.596]                         base::stop(msg)
[17:28:00.596]                       }
[17:28:00.596]                     })
[17:28:00.596]                   }
[17:28:00.596]                   ...future.strategy.old <- future::plan("list")
[17:28:00.596]                   options(future.plan = NULL)
[17:28:00.596]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:00.596]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:00.596]                 }
[17:28:00.596]                 ...future.workdir <- getwd()
[17:28:00.596]             }
[17:28:00.596]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:00.596]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:00.596]         }
[17:28:00.596]         base::options(future.startup.script = FALSE, future.globals.onMissing = "error", 
[17:28:00.596]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:00.596]             future.globals.onMissing = "error", future.globals.onReference = NULL, 
[17:28:00.596]             future.globals.resolve = TRUE, future.resolve.recursive = NULL, 
[17:28:00.596]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:28:00.596]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:00.596]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:00.596]             base::names(...future.oldOptions))
[17:28:00.596]     }
[17:28:00.596]     if (FALSE) {
[17:28:00.596]     }
[17:28:00.596]     else {
[17:28:00.596]         if (TRUE) {
[17:28:00.596]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:00.596]                 open = "w")
[17:28:00.596]         }
[17:28:00.596]         else {
[17:28:00.596]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:00.596]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:00.596]         }
[17:28:00.596]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:00.596]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:00.596]             base::sink(type = "output", split = FALSE)
[17:28:00.596]             base::close(...future.stdout)
[17:28:00.596]         }, add = TRUE)
[17:28:00.596]     }
[17:28:00.596]     ...future.frame <- base::sys.nframe()
[17:28:00.596]     ...future.conditions <- base::list()
[17:28:00.596]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:00.596]     if (FALSE) {
[17:28:00.596]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:00.596]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:00.596]     }
[17:28:00.596]     ...future.result <- base::tryCatch({
[17:28:00.596]         base::withCallingHandlers({
[17:28:00.596]             ...future.value <- base::withVisible(base::local({
[17:28:00.596]                 x <- list(b = 2)
[17:28:00.596]                 x$a <- 1
[17:28:00.596]                 x
[17:28:00.596]             }))
[17:28:00.596]             future::FutureResult(value = ...future.value$value, 
[17:28:00.596]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:00.596]                   ...future.rng), globalenv = if (FALSE) 
[17:28:00.596]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:00.596]                     ...future.globalenv.names))
[17:28:00.596]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:00.596]         }, condition = base::local({
[17:28:00.596]             c <- base::c
[17:28:00.596]             inherits <- base::inherits
[17:28:00.596]             invokeRestart <- base::invokeRestart
[17:28:00.596]             length <- base::length
[17:28:00.596]             list <- base::list
[17:28:00.596]             seq.int <- base::seq.int
[17:28:00.596]             signalCondition <- base::signalCondition
[17:28:00.596]             sys.calls <- base::sys.calls
[17:28:00.596]             `[[` <- base::`[[`
[17:28:00.596]             `+` <- base::`+`
[17:28:00.596]             `<<-` <- base::`<<-`
[17:28:00.596]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:00.596]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:00.596]                   3L)]
[17:28:00.596]             }
[17:28:00.596]             function(cond) {
[17:28:00.596]                 is_error <- inherits(cond, "error")
[17:28:00.596]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:00.596]                   NULL)
[17:28:00.596]                 if (is_error) {
[17:28:00.596]                   sessionInformation <- function() {
[17:28:00.596]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:00.596]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:00.596]                       search = base::search(), system = base::Sys.info())
[17:28:00.596]                   }
[17:28:00.596]                   ...future.conditions[[length(...future.conditions) + 
[17:28:00.596]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:00.596]                     cond$call), session = sessionInformation(), 
[17:28:00.596]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:00.596]                   signalCondition(cond)
[17:28:00.596]                 }
[17:28:00.596]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:00.596]                 "immediateCondition"))) {
[17:28:00.596]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:00.596]                   ...future.conditions[[length(...future.conditions) + 
[17:28:00.596]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:00.596]                   if (TRUE && !signal) {
[17:28:00.596]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:00.596]                     {
[17:28:00.596]                       inherits <- base::inherits
[17:28:00.596]                       invokeRestart <- base::invokeRestart
[17:28:00.596]                       is.null <- base::is.null
[17:28:00.596]                       muffled <- FALSE
[17:28:00.596]                       if (inherits(cond, "message")) {
[17:28:00.596]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:00.596]                         if (muffled) 
[17:28:00.596]                           invokeRestart("muffleMessage")
[17:28:00.596]                       }
[17:28:00.596]                       else if (inherits(cond, "warning")) {
[17:28:00.596]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:00.596]                         if (muffled) 
[17:28:00.596]                           invokeRestart("muffleWarning")
[17:28:00.596]                       }
[17:28:00.596]                       else if (inherits(cond, "condition")) {
[17:28:00.596]                         if (!is.null(pattern)) {
[17:28:00.596]                           computeRestarts <- base::computeRestarts
[17:28:00.596]                           grepl <- base::grepl
[17:28:00.596]                           restarts <- computeRestarts(cond)
[17:28:00.596]                           for (restart in restarts) {
[17:28:00.596]                             name <- restart$name
[17:28:00.596]                             if (is.null(name)) 
[17:28:00.596]                               next
[17:28:00.596]                             if (!grepl(pattern, name)) 
[17:28:00.596]                               next
[17:28:00.596]                             invokeRestart(restart)
[17:28:00.596]                             muffled <- TRUE
[17:28:00.596]                             break
[17:28:00.596]                           }
[17:28:00.596]                         }
[17:28:00.596]                       }
[17:28:00.596]                       invisible(muffled)
[17:28:00.596]                     }
[17:28:00.596]                     muffleCondition(cond, pattern = "^muffle")
[17:28:00.596]                   }
[17:28:00.596]                 }
[17:28:00.596]                 else {
[17:28:00.596]                   if (TRUE) {
[17:28:00.596]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:00.596]                     {
[17:28:00.596]                       inherits <- base::inherits
[17:28:00.596]                       invokeRestart <- base::invokeRestart
[17:28:00.596]                       is.null <- base::is.null
[17:28:00.596]                       muffled <- FALSE
[17:28:00.596]                       if (inherits(cond, "message")) {
[17:28:00.596]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:00.596]                         if (muffled) 
[17:28:00.596]                           invokeRestart("muffleMessage")
[17:28:00.596]                       }
[17:28:00.596]                       else if (inherits(cond, "warning")) {
[17:28:00.596]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:00.596]                         if (muffled) 
[17:28:00.596]                           invokeRestart("muffleWarning")
[17:28:00.596]                       }
[17:28:00.596]                       else if (inherits(cond, "condition")) {
[17:28:00.596]                         if (!is.null(pattern)) {
[17:28:00.596]                           computeRestarts <- base::computeRestarts
[17:28:00.596]                           grepl <- base::grepl
[17:28:00.596]                           restarts <- computeRestarts(cond)
[17:28:00.596]                           for (restart in restarts) {
[17:28:00.596]                             name <- restart$name
[17:28:00.596]                             if (is.null(name)) 
[17:28:00.596]                               next
[17:28:00.596]                             if (!grepl(pattern, name)) 
[17:28:00.596]                               next
[17:28:00.596]                             invokeRestart(restart)
[17:28:00.596]                             muffled <- TRUE
[17:28:00.596]                             break
[17:28:00.596]                           }
[17:28:00.596]                         }
[17:28:00.596]                       }
[17:28:00.596]                       invisible(muffled)
[17:28:00.596]                     }
[17:28:00.596]                     muffleCondition(cond, pattern = "^muffle")
[17:28:00.596]                   }
[17:28:00.596]                 }
[17:28:00.596]             }
[17:28:00.596]         }))
[17:28:00.596]     }, error = function(ex) {
[17:28:00.596]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:00.596]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:00.596]                 ...future.rng), started = ...future.startTime, 
[17:28:00.596]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:00.596]             version = "1.8"), class = "FutureResult")
[17:28:00.596]     }, finally = {
[17:28:00.596]         if (!identical(...future.workdir, getwd())) 
[17:28:00.596]             setwd(...future.workdir)
[17:28:00.596]         {
[17:28:00.596]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:00.596]                 ...future.oldOptions$nwarnings <- NULL
[17:28:00.596]             }
[17:28:00.596]             base::options(...future.oldOptions)
[17:28:00.596]             if (.Platform$OS.type == "windows") {
[17:28:00.596]                 old_names <- names(...future.oldEnvVars)
[17:28:00.596]                 envs <- base::Sys.getenv()
[17:28:00.596]                 names <- names(envs)
[17:28:00.596]                 common <- intersect(names, old_names)
[17:28:00.596]                 added <- setdiff(names, old_names)
[17:28:00.596]                 removed <- setdiff(old_names, names)
[17:28:00.596]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:00.596]                   envs[common]]
[17:28:00.596]                 NAMES <- toupper(changed)
[17:28:00.596]                 args <- list()
[17:28:00.596]                 for (kk in seq_along(NAMES)) {
[17:28:00.596]                   name <- changed[[kk]]
[17:28:00.596]                   NAME <- NAMES[[kk]]
[17:28:00.596]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:00.596]                     next
[17:28:00.596]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:00.596]                 }
[17:28:00.596]                 NAMES <- toupper(added)
[17:28:00.596]                 for (kk in seq_along(NAMES)) {
[17:28:00.596]                   name <- added[[kk]]
[17:28:00.596]                   NAME <- NAMES[[kk]]
[17:28:00.596]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:00.596]                     next
[17:28:00.596]                   args[[name]] <- ""
[17:28:00.596]                 }
[17:28:00.596]                 NAMES <- toupper(removed)
[17:28:00.596]                 for (kk in seq_along(NAMES)) {
[17:28:00.596]                   name <- removed[[kk]]
[17:28:00.596]                   NAME <- NAMES[[kk]]
[17:28:00.596]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:00.596]                     next
[17:28:00.596]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:00.596]                 }
[17:28:00.596]                 if (length(args) > 0) 
[17:28:00.596]                   base::do.call(base::Sys.setenv, args = args)
[17:28:00.596]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:00.596]             }
[17:28:00.596]             else {
[17:28:00.596]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:00.596]             }
[17:28:00.596]             {
[17:28:00.596]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:00.596]                   0L) {
[17:28:00.596]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:00.596]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:00.596]                   base::options(opts)
[17:28:00.596]                 }
[17:28:00.596]                 {
[17:28:00.596]                   {
[17:28:00.596]                     NULL
[17:28:00.596]                     RNGkind("Mersenne-Twister")
[17:28:00.596]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:28:00.596]                       inherits = FALSE)
[17:28:00.596]                   }
[17:28:00.596]                   options(future.plan = NULL)
[17:28:00.596]                   if (is.na(NA_character_)) 
[17:28:00.596]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:00.596]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:00.596]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:00.596]                     .init = FALSE)
[17:28:00.596]                 }
[17:28:00.596]             }
[17:28:00.596]         }
[17:28:00.596]     })
[17:28:00.596]     if (TRUE) {
[17:28:00.596]         base::sink(type = "output", split = FALSE)
[17:28:00.596]         if (TRUE) {
[17:28:00.596]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:00.596]         }
[17:28:00.596]         else {
[17:28:00.596]             ...future.result["stdout"] <- base::list(NULL)
[17:28:00.596]         }
[17:28:00.596]         base::close(...future.stdout)
[17:28:00.596]         ...future.stdout <- NULL
[17:28:00.596]     }
[17:28:00.596]     ...future.result$conditions <- ...future.conditions
[17:28:00.596]     ...future.result$finished <- base::Sys.time()
[17:28:00.596]     ...future.result
[17:28:00.596] }
[17:28:00.603] plan(): Setting new future strategy stack:
[17:28:00.603] List of future strategies:
[17:28:00.603] 1. sequential:
[17:28:00.603]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:00.603]    - tweaked: FALSE
[17:28:00.603]    - call: NULL
[17:28:00.604] plan(): nbrOfWorkers() = 1
[17:28:00.607] plan(): Setting new future strategy stack:
[17:28:00.607] List of future strategies:
[17:28:00.607] 1. sequential:
[17:28:00.607]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:00.607]    - tweaked: FALSE
[17:28:00.607]    - call: plan(strategy)
[17:28:00.608] plan(): nbrOfWorkers() = 1
[17:28:00.609] SequentialFuture started (and completed)
[17:28:00.609] - Launch lazy future ... done
[17:28:00.609] run() for 'SequentialFuture' ... done
$b
[1] 2

$a
[1] 1

Warning in getGlobalsAndPackages(expr, envir = envir, tweak = tweakExpression,  :
  R option 'future.globals.resolve' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'TRUE'
[17:28:00.610] getGlobalsAndPackages() ...
Warning in getGlobalsAndPackages(expr, envir = envir, tweak = tweakExpression,  :
  R option 'future.globals.onMissing' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'error'
[17:28:00.611] Searching for globals...
[17:28:00.614] - globals found: [5] '{', 'x', '<-', '[[', '[[<-'
[17:28:00.615] Searching for globals ... DONE
[17:28:00.615] Resolving globals: TRUE
[17:28:00.615] Resolving any globals that are futures ...
[17:28:00.615] - globals: [5] '{', 'x', '<-', '[[', '[[<-'
[17:28:00.615] Resolving any globals that are futures ... DONE
[17:28:00.616] Resolving futures part of globals (recursively) ...
[17:28:00.616] resolve() on list ...
[17:28:00.616]  recursive: 99
[17:28:00.617]  length: 1
[17:28:00.617]  elements: 'x'
[17:28:00.617]  length: 0 (resolved future 1)
[17:28:00.617] resolve() on list ... DONE
[17:28:00.617] - globals: [1] 'x'
[17:28:00.618] Resolving futures part of globals (recursively) ... DONE
[17:28:00.618] The total size of the 1 globals is 31 bytes (31 bytes)
[17:28:00.618] The total size of the 1 globals exported for future expression ('{; x[["a"]] <- 1; x; }') is 31 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (31 bytes of class 'list')
[17:28:00.618] - globals: [1] 'x'
[17:28:00.619] 
[17:28:00.619] getGlobalsAndPackages() ... DONE
[17:28:00.619] run() for 'Future' ...
[17:28:00.619] - state: 'created'
[17:28:00.620] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:28:00.620] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:28:00.620] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:28:00.620]   - Field: 'label'
[17:28:00.621]   - Field: 'local'
[17:28:00.621]   - Field: 'owner'
[17:28:00.621]   - Field: 'envir'
[17:28:00.621]   - Field: 'packages'
[17:28:00.621]   - Field: 'gc'
[17:28:00.622]   - Field: 'conditions'
[17:28:00.622]   - Field: 'expr'
[17:28:00.622]   - Field: 'uuid'
[17:28:00.622]   - Field: 'seed'
[17:28:00.622]   - Field: 'version'
[17:28:00.623]   - Field: 'result'
[17:28:00.625]   - Field: 'asynchronous'
[17:28:00.625]   - Field: 'calls'
[17:28:00.625]   - Field: 'globals'
[17:28:00.626]   - Field: 'stdout'
[17:28:00.626]   - Field: 'earlySignal'
[17:28:00.626]   - Field: 'lazy'
[17:28:00.626]   - Field: 'state'
[17:28:00.626] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:28:00.627] - Launch lazy future ...
[17:28:00.628] Packages needed by the future expression (n = 0): <none>
[17:28:00.628] Packages needed by future strategies (n = 0): <none>
[17:28:00.629] {
[17:28:00.629]     {
[17:28:00.629]         {
[17:28:00.629]             ...future.startTime <- base::Sys.time()
[17:28:00.629]             {
[17:28:00.629]                 {
[17:28:00.629]                   {
[17:28:00.629]                     base::local({
[17:28:00.629]                       has_future <- base::requireNamespace("future", 
[17:28:00.629]                         quietly = TRUE)
[17:28:00.629]                       if (has_future) {
[17:28:00.629]                         ns <- base::getNamespace("future")
[17:28:00.629]                         version <- ns[[".package"]][["version"]]
[17:28:00.629]                         if (is.null(version)) 
[17:28:00.629]                           version <- utils::packageVersion("future")
[17:28:00.629]                       }
[17:28:00.629]                       else {
[17:28:00.629]                         version <- NULL
[17:28:00.629]                       }
[17:28:00.629]                       if (!has_future || version < "1.8.0") {
[17:28:00.629]                         info <- base::c(r_version = base::gsub("R version ", 
[17:28:00.629]                           "", base::R.version$version.string), 
[17:28:00.629]                           platform = base::sprintf("%s (%s-bit)", 
[17:28:00.629]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:00.629]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:00.629]                             "release", "version")], collapse = " "), 
[17:28:00.629]                           hostname = base::Sys.info()[["nodename"]])
[17:28:00.629]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:28:00.629]                           info)
[17:28:00.629]                         info <- base::paste(info, collapse = "; ")
[17:28:00.629]                         if (!has_future) {
[17:28:00.629]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:00.629]                             info)
[17:28:00.629]                         }
[17:28:00.629]                         else {
[17:28:00.629]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:00.629]                             info, version)
[17:28:00.629]                         }
[17:28:00.629]                         base::stop(msg)
[17:28:00.629]                       }
[17:28:00.629]                     })
[17:28:00.629]                   }
[17:28:00.629]                   ...future.strategy.old <- future::plan("list")
[17:28:00.629]                   options(future.plan = NULL)
[17:28:00.629]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:00.629]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:00.629]                 }
[17:28:00.629]                 ...future.workdir <- getwd()
[17:28:00.629]             }
[17:28:00.629]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:00.629]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:00.629]         }
[17:28:00.629]         base::options(future.startup.script = FALSE, future.globals.onMissing = "error", 
[17:28:00.629]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:00.629]             future.globals.onMissing = "error", future.globals.onReference = NULL, 
[17:28:00.629]             future.globals.resolve = TRUE, future.resolve.recursive = NULL, 
[17:28:00.629]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:28:00.629]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:00.629]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:00.629]             base::names(...future.oldOptions))
[17:28:00.629]     }
[17:28:00.629]     if (FALSE) {
[17:28:00.629]     }
[17:28:00.629]     else {
[17:28:00.629]         if (TRUE) {
[17:28:00.629]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:00.629]                 open = "w")
[17:28:00.629]         }
[17:28:00.629]         else {
[17:28:00.629]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:00.629]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:00.629]         }
[17:28:00.629]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:00.629]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:00.629]             base::sink(type = "output", split = FALSE)
[17:28:00.629]             base::close(...future.stdout)
[17:28:00.629]         }, add = TRUE)
[17:28:00.629]     }
[17:28:00.629]     ...future.frame <- base::sys.nframe()
[17:28:00.629]     ...future.conditions <- base::list()
[17:28:00.629]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:00.629]     if (FALSE) {
[17:28:00.629]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:00.629]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:00.629]     }
[17:28:00.629]     ...future.result <- base::tryCatch({
[17:28:00.629]         base::withCallingHandlers({
[17:28:00.629]             ...future.value <- base::withVisible(base::local({
[17:28:00.629]                 x[["a"]] <- 1
[17:28:00.629]                 x
[17:28:00.629]             }))
[17:28:00.629]             future::FutureResult(value = ...future.value$value, 
[17:28:00.629]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:00.629]                   ...future.rng), globalenv = if (FALSE) 
[17:28:00.629]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:00.629]                     ...future.globalenv.names))
[17:28:00.629]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:00.629]         }, condition = base::local({
[17:28:00.629]             c <- base::c
[17:28:00.629]             inherits <- base::inherits
[17:28:00.629]             invokeRestart <- base::invokeRestart
[17:28:00.629]             length <- base::length
[17:28:00.629]             list <- base::list
[17:28:00.629]             seq.int <- base::seq.int
[17:28:00.629]             signalCondition <- base::signalCondition
[17:28:00.629]             sys.calls <- base::sys.calls
[17:28:00.629]             `[[` <- base::`[[`
[17:28:00.629]             `+` <- base::`+`
[17:28:00.629]             `<<-` <- base::`<<-`
[17:28:00.629]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:00.629]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:00.629]                   3L)]
[17:28:00.629]             }
[17:28:00.629]             function(cond) {
[17:28:00.629]                 is_error <- inherits(cond, "error")
[17:28:00.629]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:00.629]                   NULL)
[17:28:00.629]                 if (is_error) {
[17:28:00.629]                   sessionInformation <- function() {
[17:28:00.629]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:00.629]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:00.629]                       search = base::search(), system = base::Sys.info())
[17:28:00.629]                   }
[17:28:00.629]                   ...future.conditions[[length(...future.conditions) + 
[17:28:00.629]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:00.629]                     cond$call), session = sessionInformation(), 
[17:28:00.629]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:00.629]                   signalCondition(cond)
[17:28:00.629]                 }
[17:28:00.629]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:00.629]                 "immediateCondition"))) {
[17:28:00.629]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:00.629]                   ...future.conditions[[length(...future.conditions) + 
[17:28:00.629]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:00.629]                   if (TRUE && !signal) {
[17:28:00.629]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:00.629]                     {
[17:28:00.629]                       inherits <- base::inherits
[17:28:00.629]                       invokeRestart <- base::invokeRestart
[17:28:00.629]                       is.null <- base::is.null
[17:28:00.629]                       muffled <- FALSE
[17:28:00.629]                       if (inherits(cond, "message")) {
[17:28:00.629]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:00.629]                         if (muffled) 
[17:28:00.629]                           invokeRestart("muffleMessage")
[17:28:00.629]                       }
[17:28:00.629]                       else if (inherits(cond, "warning")) {
[17:28:00.629]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:00.629]                         if (muffled) 
[17:28:00.629]                           invokeRestart("muffleWarning")
[17:28:00.629]                       }
[17:28:00.629]                       else if (inherits(cond, "condition")) {
[17:28:00.629]                         if (!is.null(pattern)) {
[17:28:00.629]                           computeRestarts <- base::computeRestarts
[17:28:00.629]                           grepl <- base::grepl
[17:28:00.629]                           restarts <- computeRestarts(cond)
[17:28:00.629]                           for (restart in restarts) {
[17:28:00.629]                             name <- restart$name
[17:28:00.629]                             if (is.null(name)) 
[17:28:00.629]                               next
[17:28:00.629]                             if (!grepl(pattern, name)) 
[17:28:00.629]                               next
[17:28:00.629]                             invokeRestart(restart)
[17:28:00.629]                             muffled <- TRUE
[17:28:00.629]                             break
[17:28:00.629]                           }
[17:28:00.629]                         }
[17:28:00.629]                       }
[17:28:00.629]                       invisible(muffled)
[17:28:00.629]                     }
[17:28:00.629]                     muffleCondition(cond, pattern = "^muffle")
[17:28:00.629]                   }
[17:28:00.629]                 }
[17:28:00.629]                 else {
[17:28:00.629]                   if (TRUE) {
[17:28:00.629]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:00.629]                     {
[17:28:00.629]                       inherits <- base::inherits
[17:28:00.629]                       invokeRestart <- base::invokeRestart
[17:28:00.629]                       is.null <- base::is.null
[17:28:00.629]                       muffled <- FALSE
[17:28:00.629]                       if (inherits(cond, "message")) {
[17:28:00.629]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:00.629]                         if (muffled) 
[17:28:00.629]                           invokeRestart("muffleMessage")
[17:28:00.629]                       }
[17:28:00.629]                       else if (inherits(cond, "warning")) {
[17:28:00.629]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:00.629]                         if (muffled) 
[17:28:00.629]                           invokeRestart("muffleWarning")
[17:28:00.629]                       }
[17:28:00.629]                       else if (inherits(cond, "condition")) {
[17:28:00.629]                         if (!is.null(pattern)) {
[17:28:00.629]                           computeRestarts <- base::computeRestarts
[17:28:00.629]                           grepl <- base::grepl
[17:28:00.629]                           restarts <- computeRestarts(cond)
[17:28:00.629]                           for (restart in restarts) {
[17:28:00.629]                             name <- restart$name
[17:28:00.629]                             if (is.null(name)) 
[17:28:00.629]                               next
[17:28:00.629]                             if (!grepl(pattern, name)) 
[17:28:00.629]                               next
[17:28:00.629]                             invokeRestart(restart)
[17:28:00.629]                             muffled <- TRUE
[17:28:00.629]                             break
[17:28:00.629]                           }
[17:28:00.629]                         }
[17:28:00.629]                       }
[17:28:00.629]                       invisible(muffled)
[17:28:00.629]                     }
[17:28:00.629]                     muffleCondition(cond, pattern = "^muffle")
[17:28:00.629]                   }
[17:28:00.629]                 }
[17:28:00.629]             }
[17:28:00.629]         }))
[17:28:00.629]     }, error = function(ex) {
[17:28:00.629]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:00.629]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:00.629]                 ...future.rng), started = ...future.startTime, 
[17:28:00.629]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:00.629]             version = "1.8"), class = "FutureResult")
[17:28:00.629]     }, finally = {
[17:28:00.629]         if (!identical(...future.workdir, getwd())) 
[17:28:00.629]             setwd(...future.workdir)
[17:28:00.629]         {
[17:28:00.629]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:00.629]                 ...future.oldOptions$nwarnings <- NULL
[17:28:00.629]             }
[17:28:00.629]             base::options(...future.oldOptions)
[17:28:00.629]             if (.Platform$OS.type == "windows") {
[17:28:00.629]                 old_names <- names(...future.oldEnvVars)
[17:28:00.629]                 envs <- base::Sys.getenv()
[17:28:00.629]                 names <- names(envs)
[17:28:00.629]                 common <- intersect(names, old_names)
[17:28:00.629]                 added <- setdiff(names, old_names)
[17:28:00.629]                 removed <- setdiff(old_names, names)
[17:28:00.629]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:00.629]                   envs[common]]
[17:28:00.629]                 NAMES <- toupper(changed)
[17:28:00.629]                 args <- list()
[17:28:00.629]                 for (kk in seq_along(NAMES)) {
[17:28:00.629]                   name <- changed[[kk]]
[17:28:00.629]                   NAME <- NAMES[[kk]]
[17:28:00.629]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:00.629]                     next
[17:28:00.629]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:00.629]                 }
[17:28:00.629]                 NAMES <- toupper(added)
[17:28:00.629]                 for (kk in seq_along(NAMES)) {
[17:28:00.629]                   name <- added[[kk]]
[17:28:00.629]                   NAME <- NAMES[[kk]]
[17:28:00.629]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:00.629]                     next
[17:28:00.629]                   args[[name]] <- ""
[17:28:00.629]                 }
[17:28:00.629]                 NAMES <- toupper(removed)
[17:28:00.629]                 for (kk in seq_along(NAMES)) {
[17:28:00.629]                   name <- removed[[kk]]
[17:28:00.629]                   NAME <- NAMES[[kk]]
[17:28:00.629]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:00.629]                     next
[17:28:00.629]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:00.629]                 }
[17:28:00.629]                 if (length(args) > 0) 
[17:28:00.629]                   base::do.call(base::Sys.setenv, args = args)
[17:28:00.629]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:00.629]             }
[17:28:00.629]             else {
[17:28:00.629]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:00.629]             }
[17:28:00.629]             {
[17:28:00.629]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:00.629]                   0L) {
[17:28:00.629]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:00.629]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:00.629]                   base::options(opts)
[17:28:00.629]                 }
[17:28:00.629]                 {
[17:28:00.629]                   {
[17:28:00.629]                     NULL
[17:28:00.629]                     RNGkind("Mersenne-Twister")
[17:28:00.629]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:28:00.629]                       inherits = FALSE)
[17:28:00.629]                   }
[17:28:00.629]                   options(future.plan = NULL)
[17:28:00.629]                   if (is.na(NA_character_)) 
[17:28:00.629]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:00.629]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:00.629]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:00.629]                     .init = FALSE)
[17:28:00.629]                 }
[17:28:00.629]             }
[17:28:00.629]         }
[17:28:00.629]     })
[17:28:00.629]     if (TRUE) {
[17:28:00.629]         base::sink(type = "output", split = FALSE)
[17:28:00.629]         if (TRUE) {
[17:28:00.629]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:00.629]         }
[17:28:00.629]         else {
[17:28:00.629]             ...future.result["stdout"] <- base::list(NULL)
[17:28:00.629]         }
[17:28:00.629]         base::close(...future.stdout)
[17:28:00.629]         ...future.stdout <- NULL
[17:28:00.629]     }
[17:28:00.629]     ...future.result$conditions <- ...future.conditions
[17:28:00.629]     ...future.result$finished <- base::Sys.time()
[17:28:00.629]     ...future.result
[17:28:00.629] }
[17:28:00.635] assign_globals() ...
[17:28:00.635] List of 1
[17:28:00.635]  $ x: list()
[17:28:00.635]  - attr(*, "where")=List of 1
[17:28:00.635]   ..$ x:<environment: R_EmptyEnv> 
[17:28:00.635]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:28:00.635]  - attr(*, "resolved")= logi TRUE
[17:28:00.635]  - attr(*, "total_size")= int 31
[17:28:00.635]  - attr(*, "already-done")= logi TRUE
[17:28:00.641] - copied 'x' to environment
[17:28:00.641] assign_globals() ... done
[17:28:00.642] plan(): Setting new future strategy stack:
[17:28:00.642] List of future strategies:
[17:28:00.642] 1. sequential:
[17:28:00.642]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:00.642]    - tweaked: FALSE
[17:28:00.642]    - call: NULL
[17:28:00.643] plan(): nbrOfWorkers() = 1
[17:28:00.645] plan(): Setting new future strategy stack:
[17:28:00.645] List of future strategies:
[17:28:00.645] 1. sequential:
[17:28:00.645]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:00.645]    - tweaked: FALSE
[17:28:00.645]    - call: plan(strategy)
[17:28:00.646] plan(): nbrOfWorkers() = 1
[17:28:00.647] SequentialFuture started (and completed)
[17:28:00.647] - Launch lazy future ... done
[17:28:00.647] run() for 'SequentialFuture' ... done
$a
[1] 1

Warning in getGlobalsAndPackages(expr, envir = envir, tweak = tweakExpression,  :
  R option 'future.globals.resolve' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'TRUE'
[17:28:00.648] getGlobalsAndPackages() ...
Warning in getGlobalsAndPackages(expr, envir = envir, tweak = tweakExpression,  :
  R option 'future.globals.onMissing' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'error'
[17:28:00.649] Searching for globals...
[17:28:00.653] - globals found: [5] '{', 'x', '<-', '[[', '[[<-'
[17:28:00.653] Searching for globals ... DONE
[17:28:00.654] Resolving globals: TRUE
[17:28:00.654] Resolving any globals that are futures ...
[17:28:00.654] - globals: [5] '{', 'x', '<-', '[[', '[[<-'
[17:28:00.654] Resolving any globals that are futures ... DONE
[17:28:00.655] Resolving futures part of globals (recursively) ...
[17:28:00.656] resolve() on list ...
[17:28:00.656]  recursive: 99
[17:28:00.656]  length: 1
[17:28:00.656]  elements: 'x'
[17:28:00.657]  length: 0 (resolved future 1)
[17:28:00.657] resolve() on list ... DONE
[17:28:00.657] - globals: [1] 'x'
[17:28:00.658] Resolving futures part of globals (recursively) ... DONE
[17:28:00.658] The total size of the 1 globals is 31 bytes (31 bytes)
[17:28:00.659] The total size of the 1 globals exported for future expression ('{; x[["a"]] <- 1; x; }') is 31 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (31 bytes of class 'list')
[17:28:00.659] - globals: [1] 'x'
[17:28:00.659] 
[17:28:00.660] getGlobalsAndPackages() ... DONE
[17:28:00.660] run() for 'Future' ...
[17:28:00.660] - state: 'created'
[17:28:00.661] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:28:00.661] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:28:00.662] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:28:00.662]   - Field: 'label'
[17:28:00.662]   - Field: 'local'
[17:28:00.663]   - Field: 'owner'
[17:28:00.663]   - Field: 'envir'
[17:28:00.663]   - Field: 'packages'
[17:28:00.663]   - Field: 'gc'
[17:28:00.664]   - Field: 'conditions'
[17:28:00.664]   - Field: 'expr'
[17:28:00.664]   - Field: 'uuid'
[17:28:00.665]   - Field: 'seed'
[17:28:00.665]   - Field: 'version'
[17:28:00.665]   - Field: 'result'
[17:28:00.666]   - Field: 'asynchronous'
[17:28:00.666]   - Field: 'calls'
[17:28:00.666]   - Field: 'globals'
[17:28:00.666]   - Field: 'stdout'
[17:28:00.667]   - Field: 'earlySignal'
[17:28:00.667]   - Field: 'lazy'
[17:28:00.667]   - Field: 'state'
[17:28:00.668] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:28:00.668] - Launch lazy future ...
[17:28:00.668] Packages needed by the future expression (n = 0): <none>
[17:28:00.669] Packages needed by future strategies (n = 0): <none>
[17:28:00.670] {
[17:28:00.670]     {
[17:28:00.670]         {
[17:28:00.670]             ...future.startTime <- base::Sys.time()
[17:28:00.670]             {
[17:28:00.670]                 {
[17:28:00.670]                   {
[17:28:00.670]                     base::local({
[17:28:00.670]                       has_future <- base::requireNamespace("future", 
[17:28:00.670]                         quietly = TRUE)
[17:28:00.670]                       if (has_future) {
[17:28:00.670]                         ns <- base::getNamespace("future")
[17:28:00.670]                         version <- ns[[".package"]][["version"]]
[17:28:00.670]                         if (is.null(version)) 
[17:28:00.670]                           version <- utils::packageVersion("future")
[17:28:00.670]                       }
[17:28:00.670]                       else {
[17:28:00.670]                         version <- NULL
[17:28:00.670]                       }
[17:28:00.670]                       if (!has_future || version < "1.8.0") {
[17:28:00.670]                         info <- base::c(r_version = base::gsub("R version ", 
[17:28:00.670]                           "", base::R.version$version.string), 
[17:28:00.670]                           platform = base::sprintf("%s (%s-bit)", 
[17:28:00.670]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:00.670]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:00.670]                             "release", "version")], collapse = " "), 
[17:28:00.670]                           hostname = base::Sys.info()[["nodename"]])
[17:28:00.670]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:28:00.670]                           info)
[17:28:00.670]                         info <- base::paste(info, collapse = "; ")
[17:28:00.670]                         if (!has_future) {
[17:28:00.670]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:00.670]                             info)
[17:28:00.670]                         }
[17:28:00.670]                         else {
[17:28:00.670]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:00.670]                             info, version)
[17:28:00.670]                         }
[17:28:00.670]                         base::stop(msg)
[17:28:00.670]                       }
[17:28:00.670]                     })
[17:28:00.670]                   }
[17:28:00.670]                   ...future.strategy.old <- future::plan("list")
[17:28:00.670]                   options(future.plan = NULL)
[17:28:00.670]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:00.670]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:00.670]                 }
[17:28:00.670]                 ...future.workdir <- getwd()
[17:28:00.670]             }
[17:28:00.670]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:00.670]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:00.670]         }
[17:28:00.670]         base::options(future.startup.script = FALSE, future.globals.onMissing = "error", 
[17:28:00.670]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:00.670]             future.globals.onMissing = "error", future.globals.onReference = NULL, 
[17:28:00.670]             future.globals.resolve = TRUE, future.resolve.recursive = NULL, 
[17:28:00.670]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:28:00.670]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:00.670]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:00.670]             base::names(...future.oldOptions))
[17:28:00.670]     }
[17:28:00.670]     if (FALSE) {
[17:28:00.670]     }
[17:28:00.670]     else {
[17:28:00.670]         if (TRUE) {
[17:28:00.670]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:00.670]                 open = "w")
[17:28:00.670]         }
[17:28:00.670]         else {
[17:28:00.670]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:00.670]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:00.670]         }
[17:28:00.670]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:00.670]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:00.670]             base::sink(type = "output", split = FALSE)
[17:28:00.670]             base::close(...future.stdout)
[17:28:00.670]         }, add = TRUE)
[17:28:00.670]     }
[17:28:00.670]     ...future.frame <- base::sys.nframe()
[17:28:00.670]     ...future.conditions <- base::list()
[17:28:00.670]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:00.670]     if (FALSE) {
[17:28:00.670]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:00.670]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:00.670]     }
[17:28:00.670]     ...future.result <- base::tryCatch({
[17:28:00.670]         base::withCallingHandlers({
[17:28:00.670]             ...future.value <- base::withVisible(base::local({
[17:28:00.670]                 x[["a"]] <- 1
[17:28:00.670]                 x
[17:28:00.670]             }))
[17:28:00.670]             future::FutureResult(value = ...future.value$value, 
[17:28:00.670]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:00.670]                   ...future.rng), globalenv = if (FALSE) 
[17:28:00.670]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:00.670]                     ...future.globalenv.names))
[17:28:00.670]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:00.670]         }, condition = base::local({
[17:28:00.670]             c <- base::c
[17:28:00.670]             inherits <- base::inherits
[17:28:00.670]             invokeRestart <- base::invokeRestart
[17:28:00.670]             length <- base::length
[17:28:00.670]             list <- base::list
[17:28:00.670]             seq.int <- base::seq.int
[17:28:00.670]             signalCondition <- base::signalCondition
[17:28:00.670]             sys.calls <- base::sys.calls
[17:28:00.670]             `[[` <- base::`[[`
[17:28:00.670]             `+` <- base::`+`
[17:28:00.670]             `<<-` <- base::`<<-`
[17:28:00.670]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:00.670]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:00.670]                   3L)]
[17:28:00.670]             }
[17:28:00.670]             function(cond) {
[17:28:00.670]                 is_error <- inherits(cond, "error")
[17:28:00.670]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:00.670]                   NULL)
[17:28:00.670]                 if (is_error) {
[17:28:00.670]                   sessionInformation <- function() {
[17:28:00.670]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:00.670]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:00.670]                       search = base::search(), system = base::Sys.info())
[17:28:00.670]                   }
[17:28:00.670]                   ...future.conditions[[length(...future.conditions) + 
[17:28:00.670]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:00.670]                     cond$call), session = sessionInformation(), 
[17:28:00.670]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:00.670]                   signalCondition(cond)
[17:28:00.670]                 }
[17:28:00.670]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:00.670]                 "immediateCondition"))) {
[17:28:00.670]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:00.670]                   ...future.conditions[[length(...future.conditions) + 
[17:28:00.670]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:00.670]                   if (TRUE && !signal) {
[17:28:00.670]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:00.670]                     {
[17:28:00.670]                       inherits <- base::inherits
[17:28:00.670]                       invokeRestart <- base::invokeRestart
[17:28:00.670]                       is.null <- base::is.null
[17:28:00.670]                       muffled <- FALSE
[17:28:00.670]                       if (inherits(cond, "message")) {
[17:28:00.670]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:00.670]                         if (muffled) 
[17:28:00.670]                           invokeRestart("muffleMessage")
[17:28:00.670]                       }
[17:28:00.670]                       else if (inherits(cond, "warning")) {
[17:28:00.670]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:00.670]                         if (muffled) 
[17:28:00.670]                           invokeRestart("muffleWarning")
[17:28:00.670]                       }
[17:28:00.670]                       else if (inherits(cond, "condition")) {
[17:28:00.670]                         if (!is.null(pattern)) {
[17:28:00.670]                           computeRestarts <- base::computeRestarts
[17:28:00.670]                           grepl <- base::grepl
[17:28:00.670]                           restarts <- computeRestarts(cond)
[17:28:00.670]                           for (restart in restarts) {
[17:28:00.670]                             name <- restart$name
[17:28:00.670]                             if (is.null(name)) 
[17:28:00.670]                               next
[17:28:00.670]                             if (!grepl(pattern, name)) 
[17:28:00.670]                               next
[17:28:00.670]                             invokeRestart(restart)
[17:28:00.670]                             muffled <- TRUE
[17:28:00.670]                             break
[17:28:00.670]                           }
[17:28:00.670]                         }
[17:28:00.670]                       }
[17:28:00.670]                       invisible(muffled)
[17:28:00.670]                     }
[17:28:00.670]                     muffleCondition(cond, pattern = "^muffle")
[17:28:00.670]                   }
[17:28:00.670]                 }
[17:28:00.670]                 else {
[17:28:00.670]                   if (TRUE) {
[17:28:00.670]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:00.670]                     {
[17:28:00.670]                       inherits <- base::inherits
[17:28:00.670]                       invokeRestart <- base::invokeRestart
[17:28:00.670]                       is.null <- base::is.null
[17:28:00.670]                       muffled <- FALSE
[17:28:00.670]                       if (inherits(cond, "message")) {
[17:28:00.670]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:00.670]                         if (muffled) 
[17:28:00.670]                           invokeRestart("muffleMessage")
[17:28:00.670]                       }
[17:28:00.670]                       else if (inherits(cond, "warning")) {
[17:28:00.670]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:00.670]                         if (muffled) 
[17:28:00.670]                           invokeRestart("muffleWarning")
[17:28:00.670]                       }
[17:28:00.670]                       else if (inherits(cond, "condition")) {
[17:28:00.670]                         if (!is.null(pattern)) {
[17:28:00.670]                           computeRestarts <- base::computeRestarts
[17:28:00.670]                           grepl <- base::grepl
[17:28:00.670]                           restarts <- computeRestarts(cond)
[17:28:00.670]                           for (restart in restarts) {
[17:28:00.670]                             name <- restart$name
[17:28:00.670]                             if (is.null(name)) 
[17:28:00.670]                               next
[17:28:00.670]                             if (!grepl(pattern, name)) 
[17:28:00.670]                               next
[17:28:00.670]                             invokeRestart(restart)
[17:28:00.670]                             muffled <- TRUE
[17:28:00.670]                             break
[17:28:00.670]                           }
[17:28:00.670]                         }
[17:28:00.670]                       }
[17:28:00.670]                       invisible(muffled)
[17:28:00.670]                     }
[17:28:00.670]                     muffleCondition(cond, pattern = "^muffle")
[17:28:00.670]                   }
[17:28:00.670]                 }
[17:28:00.670]             }
[17:28:00.670]         }))
[17:28:00.670]     }, error = function(ex) {
[17:28:00.670]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:00.670]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:00.670]                 ...future.rng), started = ...future.startTime, 
[17:28:00.670]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:00.670]             version = "1.8"), class = "FutureResult")
[17:28:00.670]     }, finally = {
[17:28:00.670]         if (!identical(...future.workdir, getwd())) 
[17:28:00.670]             setwd(...future.workdir)
[17:28:00.670]         {
[17:28:00.670]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:00.670]                 ...future.oldOptions$nwarnings <- NULL
[17:28:00.670]             }
[17:28:00.670]             base::options(...future.oldOptions)
[17:28:00.670]             if (.Platform$OS.type == "windows") {
[17:28:00.670]                 old_names <- names(...future.oldEnvVars)
[17:28:00.670]                 envs <- base::Sys.getenv()
[17:28:00.670]                 names <- names(envs)
[17:28:00.670]                 common <- intersect(names, old_names)
[17:28:00.670]                 added <- setdiff(names, old_names)
[17:28:00.670]                 removed <- setdiff(old_names, names)
[17:28:00.670]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:00.670]                   envs[common]]
[17:28:00.670]                 NAMES <- toupper(changed)
[17:28:00.670]                 args <- list()
[17:28:00.670]                 for (kk in seq_along(NAMES)) {
[17:28:00.670]                   name <- changed[[kk]]
[17:28:00.670]                   NAME <- NAMES[[kk]]
[17:28:00.670]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:00.670]                     next
[17:28:00.670]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:00.670]                 }
[17:28:00.670]                 NAMES <- toupper(added)
[17:28:00.670]                 for (kk in seq_along(NAMES)) {
[17:28:00.670]                   name <- added[[kk]]
[17:28:00.670]                   NAME <- NAMES[[kk]]
[17:28:00.670]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:00.670]                     next
[17:28:00.670]                   args[[name]] <- ""
[17:28:00.670]                 }
[17:28:00.670]                 NAMES <- toupper(removed)
[17:28:00.670]                 for (kk in seq_along(NAMES)) {
[17:28:00.670]                   name <- removed[[kk]]
[17:28:00.670]                   NAME <- NAMES[[kk]]
[17:28:00.670]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:00.670]                     next
[17:28:00.670]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:00.670]                 }
[17:28:00.670]                 if (length(args) > 0) 
[17:28:00.670]                   base::do.call(base::Sys.setenv, args = args)
[17:28:00.670]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:00.670]             }
[17:28:00.670]             else {
[17:28:00.670]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:00.670]             }
[17:28:00.670]             {
[17:28:00.670]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:00.670]                   0L) {
[17:28:00.670]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:00.670]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:00.670]                   base::options(opts)
[17:28:00.670]                 }
[17:28:00.670]                 {
[17:28:00.670]                   {
[17:28:00.670]                     NULL
[17:28:00.670]                     RNGkind("Mersenne-Twister")
[17:28:00.670]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:28:00.670]                       inherits = FALSE)
[17:28:00.670]                   }
[17:28:00.670]                   options(future.plan = NULL)
[17:28:00.670]                   if (is.na(NA_character_)) 
[17:28:00.670]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:00.670]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:00.670]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:00.670]                     .init = FALSE)
[17:28:00.670]                 }
[17:28:00.670]             }
[17:28:00.670]         }
[17:28:00.670]     })
[17:28:00.670]     if (TRUE) {
[17:28:00.670]         base::sink(type = "output", split = FALSE)
[17:28:00.670]         if (TRUE) {
[17:28:00.670]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:00.670]         }
[17:28:00.670]         else {
[17:28:00.670]             ...future.result["stdout"] <- base::list(NULL)
[17:28:00.670]         }
[17:28:00.670]         base::close(...future.stdout)
[17:28:00.670]         ...future.stdout <- NULL
[17:28:00.670]     }
[17:28:00.670]     ...future.result$conditions <- ...future.conditions
[17:28:00.670]     ...future.result$finished <- base::Sys.time()
[17:28:00.670]     ...future.result
[17:28:00.670] }
[17:28:00.676] assign_globals() ...
[17:28:00.676] List of 1
[17:28:00.676]  $ x: list()
[17:28:00.676]  - attr(*, "where")=List of 1
[17:28:00.676]   ..$ x:<environment: R_EmptyEnv> 
[17:28:00.676]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:28:00.676]  - attr(*, "resolved")= logi TRUE
[17:28:00.676]  - attr(*, "total_size")= int 31
[17:28:00.676]  - attr(*, "already-done")= logi TRUE
[17:28:00.684] - copied 'x' to environment
[17:28:00.684] assign_globals() ... done
[17:28:00.685] plan(): Setting new future strategy stack:
[17:28:00.685] List of future strategies:
[17:28:00.685] 1. sequential:
[17:28:00.685]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:00.685]    - tweaked: FALSE
[17:28:00.685]    - call: NULL
[17:28:00.686] plan(): nbrOfWorkers() = 1
[17:28:00.688] plan(): Setting new future strategy stack:
[17:28:00.688] List of future strategies:
[17:28:00.688] 1. sequential:
[17:28:00.688]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:00.688]    - tweaked: FALSE
[17:28:00.688]    - call: plan(strategy)
[17:28:00.689] plan(): nbrOfWorkers() = 1
[17:28:00.690] SequentialFuture started (and completed)
[17:28:00.690] - Launch lazy future ... done
[17:28:00.690] run() for 'SequentialFuture' ... done
$a
[1] 1

Warning in getGlobalsAndPackages(expr, envir = envir, tweak = tweakExpression,  :
  R option 'future.globals.resolve' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'TRUE'
[17:28:00.691] getGlobalsAndPackages() ...
Warning in getGlobalsAndPackages(expr, envir = envir, tweak = tweakExpression,  :
  R option 'future.globals.onMissing' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'error'
[17:28:00.692] Searching for globals...
[17:28:00.696] - globals found: [5] '{', 'x', '<-', '[[', '[[<-'
[17:28:00.696] Searching for globals ... DONE
[17:28:00.697] Resolving globals: TRUE
[17:28:00.697] Resolving any globals that are futures ...
[17:28:00.697] - globals: [5] '{', 'x', '<-', '[[', '[[<-'
[17:28:00.698] Resolving any globals that are futures ... DONE
[17:28:00.698] Resolving futures part of globals (recursively) ...
[17:28:00.699] resolve() on list ...
[17:28:00.699]  recursive: 99
[17:28:00.700]  length: 1
[17:28:00.700]  elements: 'x'
[17:28:00.700]  length: 0 (resolved future 1)
[17:28:00.700] resolve() on list ... DONE
[17:28:00.701] - globals: [1] 'x'
[17:28:00.701] Resolving futures part of globals (recursively) ... DONE
[17:28:00.701] The total size of the 1 globals is 31 bytes (31 bytes)
[17:28:00.702] The total size of the 1 globals exported for future expression ('{; x[["a"]] <- 1; x; }') is 31 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (31 bytes of class 'list')
[17:28:00.702] - globals: [1] 'x'
[17:28:00.703] 
[17:28:00.703] getGlobalsAndPackages() ... DONE
[17:28:00.704] run() for 'Future' ...
[17:28:00.704] - state: 'created'
[17:28:00.704] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:28:00.705] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:28:00.705] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:28:00.705]   - Field: 'label'
[17:28:00.706]   - Field: 'local'
[17:28:00.706]   - Field: 'owner'
[17:28:00.706]   - Field: 'envir'
[17:28:00.706]   - Field: 'packages'
[17:28:00.706]   - Field: 'gc'
[17:28:00.707]   - Field: 'conditions'
[17:28:00.707]   - Field: 'expr'
[17:28:00.707]   - Field: 'uuid'
[17:28:00.707]   - Field: 'seed'
[17:28:00.707]   - Field: 'version'
[17:28:00.708]   - Field: 'result'
[17:28:00.708]   - Field: 'asynchronous'
[17:28:00.708]   - Field: 'calls'
[17:28:00.708]   - Field: 'globals'
[17:28:00.708]   - Field: 'stdout'
[17:28:00.708]   - Field: 'earlySignal'
[17:28:00.709]   - Field: 'lazy'
[17:28:00.709]   - Field: 'state'
[17:28:00.709] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:28:00.709] - Launch lazy future ...
[17:28:00.709] Packages needed by the future expression (n = 0): <none>
[17:28:00.710] Packages needed by future strategies (n = 0): <none>
[17:28:00.710] {
[17:28:00.710]     {
[17:28:00.710]         {
[17:28:00.710]             ...future.startTime <- base::Sys.time()
[17:28:00.710]             {
[17:28:00.710]                 {
[17:28:00.710]                   {
[17:28:00.710]                     base::local({
[17:28:00.710]                       has_future <- base::requireNamespace("future", 
[17:28:00.710]                         quietly = TRUE)
[17:28:00.710]                       if (has_future) {
[17:28:00.710]                         ns <- base::getNamespace("future")
[17:28:00.710]                         version <- ns[[".package"]][["version"]]
[17:28:00.710]                         if (is.null(version)) 
[17:28:00.710]                           version <- utils::packageVersion("future")
[17:28:00.710]                       }
[17:28:00.710]                       else {
[17:28:00.710]                         version <- NULL
[17:28:00.710]                       }
[17:28:00.710]                       if (!has_future || version < "1.8.0") {
[17:28:00.710]                         info <- base::c(r_version = base::gsub("R version ", 
[17:28:00.710]                           "", base::R.version$version.string), 
[17:28:00.710]                           platform = base::sprintf("%s (%s-bit)", 
[17:28:00.710]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:00.710]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:00.710]                             "release", "version")], collapse = " "), 
[17:28:00.710]                           hostname = base::Sys.info()[["nodename"]])
[17:28:00.710]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:28:00.710]                           info)
[17:28:00.710]                         info <- base::paste(info, collapse = "; ")
[17:28:00.710]                         if (!has_future) {
[17:28:00.710]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:00.710]                             info)
[17:28:00.710]                         }
[17:28:00.710]                         else {
[17:28:00.710]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:00.710]                             info, version)
[17:28:00.710]                         }
[17:28:00.710]                         base::stop(msg)
[17:28:00.710]                       }
[17:28:00.710]                     })
[17:28:00.710]                   }
[17:28:00.710]                   ...future.strategy.old <- future::plan("list")
[17:28:00.710]                   options(future.plan = NULL)
[17:28:00.710]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:00.710]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:00.710]                 }
[17:28:00.710]                 ...future.workdir <- getwd()
[17:28:00.710]             }
[17:28:00.710]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:00.710]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:00.710]         }
[17:28:00.710]         base::options(future.startup.script = FALSE, future.globals.onMissing = "error", 
[17:28:00.710]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:00.710]             future.globals.onMissing = "error", future.globals.onReference = NULL, 
[17:28:00.710]             future.globals.resolve = TRUE, future.resolve.recursive = NULL, 
[17:28:00.710]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:28:00.710]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:00.710]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:00.710]             base::names(...future.oldOptions))
[17:28:00.710]     }
[17:28:00.710]     if (FALSE) {
[17:28:00.710]     }
[17:28:00.710]     else {
[17:28:00.710]         if (TRUE) {
[17:28:00.710]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:00.710]                 open = "w")
[17:28:00.710]         }
[17:28:00.710]         else {
[17:28:00.710]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:00.710]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:00.710]         }
[17:28:00.710]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:00.710]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:00.710]             base::sink(type = "output", split = FALSE)
[17:28:00.710]             base::close(...future.stdout)
[17:28:00.710]         }, add = TRUE)
[17:28:00.710]     }
[17:28:00.710]     ...future.frame <- base::sys.nframe()
[17:28:00.710]     ...future.conditions <- base::list()
[17:28:00.710]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:00.710]     if (FALSE) {
[17:28:00.710]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:00.710]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:00.710]     }
[17:28:00.710]     ...future.result <- base::tryCatch({
[17:28:00.710]         base::withCallingHandlers({
[17:28:00.710]             ...future.value <- base::withVisible(base::local({
[17:28:00.710]                 x[["a"]] <- 1
[17:28:00.710]                 x
[17:28:00.710]             }))
[17:28:00.710]             future::FutureResult(value = ...future.value$value, 
[17:28:00.710]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:00.710]                   ...future.rng), globalenv = if (FALSE) 
[17:28:00.710]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:00.710]                     ...future.globalenv.names))
[17:28:00.710]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:00.710]         }, condition = base::local({
[17:28:00.710]             c <- base::c
[17:28:00.710]             inherits <- base::inherits
[17:28:00.710]             invokeRestart <- base::invokeRestart
[17:28:00.710]             length <- base::length
[17:28:00.710]             list <- base::list
[17:28:00.710]             seq.int <- base::seq.int
[17:28:00.710]             signalCondition <- base::signalCondition
[17:28:00.710]             sys.calls <- base::sys.calls
[17:28:00.710]             `[[` <- base::`[[`
[17:28:00.710]             `+` <- base::`+`
[17:28:00.710]             `<<-` <- base::`<<-`
[17:28:00.710]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:00.710]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:00.710]                   3L)]
[17:28:00.710]             }
[17:28:00.710]             function(cond) {
[17:28:00.710]                 is_error <- inherits(cond, "error")
[17:28:00.710]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:00.710]                   NULL)
[17:28:00.710]                 if (is_error) {
[17:28:00.710]                   sessionInformation <- function() {
[17:28:00.710]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:00.710]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:00.710]                       search = base::search(), system = base::Sys.info())
[17:28:00.710]                   }
[17:28:00.710]                   ...future.conditions[[length(...future.conditions) + 
[17:28:00.710]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:00.710]                     cond$call), session = sessionInformation(), 
[17:28:00.710]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:00.710]                   signalCondition(cond)
[17:28:00.710]                 }
[17:28:00.710]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:00.710]                 "immediateCondition"))) {
[17:28:00.710]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:00.710]                   ...future.conditions[[length(...future.conditions) + 
[17:28:00.710]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:00.710]                   if (TRUE && !signal) {
[17:28:00.710]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:00.710]                     {
[17:28:00.710]                       inherits <- base::inherits
[17:28:00.710]                       invokeRestart <- base::invokeRestart
[17:28:00.710]                       is.null <- base::is.null
[17:28:00.710]                       muffled <- FALSE
[17:28:00.710]                       if (inherits(cond, "message")) {
[17:28:00.710]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:00.710]                         if (muffled) 
[17:28:00.710]                           invokeRestart("muffleMessage")
[17:28:00.710]                       }
[17:28:00.710]                       else if (inherits(cond, "warning")) {
[17:28:00.710]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:00.710]                         if (muffled) 
[17:28:00.710]                           invokeRestart("muffleWarning")
[17:28:00.710]                       }
[17:28:00.710]                       else if (inherits(cond, "condition")) {
[17:28:00.710]                         if (!is.null(pattern)) {
[17:28:00.710]                           computeRestarts <- base::computeRestarts
[17:28:00.710]                           grepl <- base::grepl
[17:28:00.710]                           restarts <- computeRestarts(cond)
[17:28:00.710]                           for (restart in restarts) {
[17:28:00.710]                             name <- restart$name
[17:28:00.710]                             if (is.null(name)) 
[17:28:00.710]                               next
[17:28:00.710]                             if (!grepl(pattern, name)) 
[17:28:00.710]                               next
[17:28:00.710]                             invokeRestart(restart)
[17:28:00.710]                             muffled <- TRUE
[17:28:00.710]                             break
[17:28:00.710]                           }
[17:28:00.710]                         }
[17:28:00.710]                       }
[17:28:00.710]                       invisible(muffled)
[17:28:00.710]                     }
[17:28:00.710]                     muffleCondition(cond, pattern = "^muffle")
[17:28:00.710]                   }
[17:28:00.710]                 }
[17:28:00.710]                 else {
[17:28:00.710]                   if (TRUE) {
[17:28:00.710]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:00.710]                     {
[17:28:00.710]                       inherits <- base::inherits
[17:28:00.710]                       invokeRestart <- base::invokeRestart
[17:28:00.710]                       is.null <- base::is.null
[17:28:00.710]                       muffled <- FALSE
[17:28:00.710]                       if (inherits(cond, "message")) {
[17:28:00.710]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:00.710]                         if (muffled) 
[17:28:00.710]                           invokeRestart("muffleMessage")
[17:28:00.710]                       }
[17:28:00.710]                       else if (inherits(cond, "warning")) {
[17:28:00.710]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:00.710]                         if (muffled) 
[17:28:00.710]                           invokeRestart("muffleWarning")
[17:28:00.710]                       }
[17:28:00.710]                       else if (inherits(cond, "condition")) {
[17:28:00.710]                         if (!is.null(pattern)) {
[17:28:00.710]                           computeRestarts <- base::computeRestarts
[17:28:00.710]                           grepl <- base::grepl
[17:28:00.710]                           restarts <- computeRestarts(cond)
[17:28:00.710]                           for (restart in restarts) {
[17:28:00.710]                             name <- restart$name
[17:28:00.710]                             if (is.null(name)) 
[17:28:00.710]                               next
[17:28:00.710]                             if (!grepl(pattern, name)) 
[17:28:00.710]                               next
[17:28:00.710]                             invokeRestart(restart)
[17:28:00.710]                             muffled <- TRUE
[17:28:00.710]                             break
[17:28:00.710]                           }
[17:28:00.710]                         }
[17:28:00.710]                       }
[17:28:00.710]                       invisible(muffled)
[17:28:00.710]                     }
[17:28:00.710]                     muffleCondition(cond, pattern = "^muffle")
[17:28:00.710]                   }
[17:28:00.710]                 }
[17:28:00.710]             }
[17:28:00.710]         }))
[17:28:00.710]     }, error = function(ex) {
[17:28:00.710]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:00.710]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:00.710]                 ...future.rng), started = ...future.startTime, 
[17:28:00.710]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:00.710]             version = "1.8"), class = "FutureResult")
[17:28:00.710]     }, finally = {
[17:28:00.710]         if (!identical(...future.workdir, getwd())) 
[17:28:00.710]             setwd(...future.workdir)
[17:28:00.710]         {
[17:28:00.710]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:00.710]                 ...future.oldOptions$nwarnings <- NULL
[17:28:00.710]             }
[17:28:00.710]             base::options(...future.oldOptions)
[17:28:00.710]             if (.Platform$OS.type == "windows") {
[17:28:00.710]                 old_names <- names(...future.oldEnvVars)
[17:28:00.710]                 envs <- base::Sys.getenv()
[17:28:00.710]                 names <- names(envs)
[17:28:00.710]                 common <- intersect(names, old_names)
[17:28:00.710]                 added <- setdiff(names, old_names)
[17:28:00.710]                 removed <- setdiff(old_names, names)
[17:28:00.710]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:00.710]                   envs[common]]
[17:28:00.710]                 NAMES <- toupper(changed)
[17:28:00.710]                 args <- list()
[17:28:00.710]                 for (kk in seq_along(NAMES)) {
[17:28:00.710]                   name <- changed[[kk]]
[17:28:00.710]                   NAME <- NAMES[[kk]]
[17:28:00.710]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:00.710]                     next
[17:28:00.710]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:00.710]                 }
[17:28:00.710]                 NAMES <- toupper(added)
[17:28:00.710]                 for (kk in seq_along(NAMES)) {
[17:28:00.710]                   name <- added[[kk]]
[17:28:00.710]                   NAME <- NAMES[[kk]]
[17:28:00.710]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:00.710]                     next
[17:28:00.710]                   args[[name]] <- ""
[17:28:00.710]                 }
[17:28:00.710]                 NAMES <- toupper(removed)
[17:28:00.710]                 for (kk in seq_along(NAMES)) {
[17:28:00.710]                   name <- removed[[kk]]
[17:28:00.710]                   NAME <- NAMES[[kk]]
[17:28:00.710]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:00.710]                     next
[17:28:00.710]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:00.710]                 }
[17:28:00.710]                 if (length(args) > 0) 
[17:28:00.710]                   base::do.call(base::Sys.setenv, args = args)
[17:28:00.710]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:00.710]             }
[17:28:00.710]             else {
[17:28:00.710]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:00.710]             }
[17:28:00.710]             {
[17:28:00.710]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:00.710]                   0L) {
[17:28:00.710]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:00.710]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:00.710]                   base::options(opts)
[17:28:00.710]                 }
[17:28:00.710]                 {
[17:28:00.710]                   {
[17:28:00.710]                     NULL
[17:28:00.710]                     RNGkind("Mersenne-Twister")
[17:28:00.710]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:28:00.710]                       inherits = FALSE)
[17:28:00.710]                   }
[17:28:00.710]                   options(future.plan = NULL)
[17:28:00.710]                   if (is.na(NA_character_)) 
[17:28:00.710]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:00.710]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:00.710]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:00.710]                     .init = FALSE)
[17:28:00.710]                 }
[17:28:00.710]             }
[17:28:00.710]         }
[17:28:00.710]     })
[17:28:00.710]     if (TRUE) {
[17:28:00.710]         base::sink(type = "output", split = FALSE)
[17:28:00.710]         if (TRUE) {
[17:28:00.710]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:00.710]         }
[17:28:00.710]         else {
[17:28:00.710]             ...future.result["stdout"] <- base::list(NULL)
[17:28:00.710]         }
[17:28:00.710]         base::close(...future.stdout)
[17:28:00.710]         ...future.stdout <- NULL
[17:28:00.710]     }
[17:28:00.710]     ...future.result$conditions <- ...future.conditions
[17:28:00.710]     ...future.result$finished <- base::Sys.time()
[17:28:00.710]     ...future.result
[17:28:00.710] }
[17:28:00.715] assign_globals() ...
[17:28:00.715] List of 1
[17:28:00.715]  $ x: list()
[17:28:00.715]  - attr(*, "where")=List of 1
[17:28:00.715]   ..$ x:<environment: R_EmptyEnv> 
[17:28:00.715]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:28:00.715]  - attr(*, "resolved")= logi TRUE
[17:28:00.715]  - attr(*, "total_size")= int 31
[17:28:00.715]  - attr(*, "already-done")= logi TRUE
[17:28:00.718] - copied 'x' to environment
[17:28:00.718] assign_globals() ... done
[17:28:00.719] plan(): Setting new future strategy stack:
[17:28:00.719] List of future strategies:
[17:28:00.719] 1. sequential:
[17:28:00.719]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:00.719]    - tweaked: FALSE
[17:28:00.719]    - call: NULL
[17:28:00.720] plan(): nbrOfWorkers() = 1
[17:28:00.722] plan(): Setting new future strategy stack:
[17:28:00.722] List of future strategies:
[17:28:00.722] 1. sequential:
[17:28:00.722]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:00.722]    - tweaked: FALSE
[17:28:00.722]    - call: plan(strategy)
[17:28:00.723] plan(): nbrOfWorkers() = 1
[17:28:00.723] SequentialFuture started (and completed)
[17:28:00.724] - Launch lazy future ... done
[17:28:00.724] run() for 'SequentialFuture' ... done
$a
[1] 1

Warning in getGlobalsAndPackages(expr, envir = envir, tweak = tweakExpression,  :
  R option 'future.globals.resolve' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'TRUE'
[17:28:00.728] getGlobalsAndPackages() ...
Warning in getGlobalsAndPackages(expr, envir = envir, tweak = tweakExpression,  :
  R option 'future.globals.onMissing' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'error'
[17:28:00.728] Searching for globals...
[17:28:00.732] - globals found: [6] '{', 'x', '<-', '[', '[<-', 'list'
[17:28:00.733] Searching for globals ... DONE
[17:28:00.733] Resolving globals: TRUE
[17:28:00.733] Resolving any globals that are futures ...
[17:28:00.733] - globals: [6] '{', 'x', '<-', '[', '[<-', 'list'
[17:28:00.734] Resolving any globals that are futures ... DONE
[17:28:00.734] Resolving futures part of globals (recursively) ...
[17:28:00.735] resolve() on list ...
[17:28:00.735]  recursive: 99
[17:28:00.735]  length: 1
[17:28:00.736]  elements: 'x'
[17:28:00.736]  length: 0 (resolved future 1)
[17:28:00.736] resolve() on list ... DONE
[17:28:00.736] - globals: [1] 'x'
[17:28:00.737] Resolving futures part of globals (recursively) ... DONE
[17:28:00.737] The total size of the 1 globals is 31 bytes (31 bytes)
[17:28:00.738] The total size of the 1 globals exported for future expression ('{; x["a"] <- list(1); x; }') is 31 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (31 bytes of class 'list')
[17:28:00.738] - globals: [1] 'x'
[17:28:00.738] 
[17:28:00.739] getGlobalsAndPackages() ... DONE
[17:28:00.739] run() for 'Future' ...
[17:28:00.740] - state: 'created'
[17:28:00.740] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:28:00.740] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:28:00.741] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:28:00.741]   - Field: 'label'
[17:28:00.741]   - Field: 'local'
[17:28:00.742]   - Field: 'owner'
[17:28:00.742]   - Field: 'envir'
[17:28:00.742]   - Field: 'packages'
[17:28:00.742]   - Field: 'gc'
[17:28:00.743]   - Field: 'conditions'
[17:28:00.743]   - Field: 'expr'
[17:28:00.743]   - Field: 'uuid'
[17:28:00.743]   - Field: 'seed'
[17:28:00.744]   - Field: 'version'
[17:28:00.744]   - Field: 'result'
[17:28:00.744]   - Field: 'asynchronous'
[17:28:00.745]   - Field: 'calls'
[17:28:00.745]   - Field: 'globals'
[17:28:00.745]   - Field: 'stdout'
[17:28:00.745]   - Field: 'earlySignal'
[17:28:00.746]   - Field: 'lazy'
[17:28:00.746]   - Field: 'state'
[17:28:00.746] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:28:00.746] - Launch lazy future ...
[17:28:00.747] Packages needed by the future expression (n = 0): <none>
[17:28:00.747] Packages needed by future strategies (n = 0): <none>
[17:28:00.748] {
[17:28:00.748]     {
[17:28:00.748]         {
[17:28:00.748]             ...future.startTime <- base::Sys.time()
[17:28:00.748]             {
[17:28:00.748]                 {
[17:28:00.748]                   {
[17:28:00.748]                     base::local({
[17:28:00.748]                       has_future <- base::requireNamespace("future", 
[17:28:00.748]                         quietly = TRUE)
[17:28:00.748]                       if (has_future) {
[17:28:00.748]                         ns <- base::getNamespace("future")
[17:28:00.748]                         version <- ns[[".package"]][["version"]]
[17:28:00.748]                         if (is.null(version)) 
[17:28:00.748]                           version <- utils::packageVersion("future")
[17:28:00.748]                       }
[17:28:00.748]                       else {
[17:28:00.748]                         version <- NULL
[17:28:00.748]                       }
[17:28:00.748]                       if (!has_future || version < "1.8.0") {
[17:28:00.748]                         info <- base::c(r_version = base::gsub("R version ", 
[17:28:00.748]                           "", base::R.version$version.string), 
[17:28:00.748]                           platform = base::sprintf("%s (%s-bit)", 
[17:28:00.748]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:00.748]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:00.748]                             "release", "version")], collapse = " "), 
[17:28:00.748]                           hostname = base::Sys.info()[["nodename"]])
[17:28:00.748]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:28:00.748]                           info)
[17:28:00.748]                         info <- base::paste(info, collapse = "; ")
[17:28:00.748]                         if (!has_future) {
[17:28:00.748]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:00.748]                             info)
[17:28:00.748]                         }
[17:28:00.748]                         else {
[17:28:00.748]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:00.748]                             info, version)
[17:28:00.748]                         }
[17:28:00.748]                         base::stop(msg)
[17:28:00.748]                       }
[17:28:00.748]                     })
[17:28:00.748]                   }
[17:28:00.748]                   ...future.strategy.old <- future::plan("list")
[17:28:00.748]                   options(future.plan = NULL)
[17:28:00.748]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:00.748]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:00.748]                 }
[17:28:00.748]                 ...future.workdir <- getwd()
[17:28:00.748]             }
[17:28:00.748]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:00.748]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:00.748]         }
[17:28:00.748]         base::options(future.startup.script = FALSE, future.globals.onMissing = "error", 
[17:28:00.748]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:00.748]             future.globals.onMissing = "error", future.globals.onReference = NULL, 
[17:28:00.748]             future.globals.resolve = TRUE, future.resolve.recursive = NULL, 
[17:28:00.748]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:28:00.748]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:00.748]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:00.748]             base::names(...future.oldOptions))
[17:28:00.748]     }
[17:28:00.748]     if (FALSE) {
[17:28:00.748]     }
[17:28:00.748]     else {
[17:28:00.748]         if (TRUE) {
[17:28:00.748]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:00.748]                 open = "w")
[17:28:00.748]         }
[17:28:00.748]         else {
[17:28:00.748]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:00.748]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:00.748]         }
[17:28:00.748]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:00.748]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:00.748]             base::sink(type = "output", split = FALSE)
[17:28:00.748]             base::close(...future.stdout)
[17:28:00.748]         }, add = TRUE)
[17:28:00.748]     }
[17:28:00.748]     ...future.frame <- base::sys.nframe()
[17:28:00.748]     ...future.conditions <- base::list()
[17:28:00.748]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:00.748]     if (FALSE) {
[17:28:00.748]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:00.748]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:00.748]     }
[17:28:00.748]     ...future.result <- base::tryCatch({
[17:28:00.748]         base::withCallingHandlers({
[17:28:00.748]             ...future.value <- base::withVisible(base::local({
[17:28:00.748]                 x["a"] <- list(1)
[17:28:00.748]                 x
[17:28:00.748]             }))
[17:28:00.748]             future::FutureResult(value = ...future.value$value, 
[17:28:00.748]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:00.748]                   ...future.rng), globalenv = if (FALSE) 
[17:28:00.748]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:00.748]                     ...future.globalenv.names))
[17:28:00.748]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:00.748]         }, condition = base::local({
[17:28:00.748]             c <- base::c
[17:28:00.748]             inherits <- base::inherits
[17:28:00.748]             invokeRestart <- base::invokeRestart
[17:28:00.748]             length <- base::length
[17:28:00.748]             list <- base::list
[17:28:00.748]             seq.int <- base::seq.int
[17:28:00.748]             signalCondition <- base::signalCondition
[17:28:00.748]             sys.calls <- base::sys.calls
[17:28:00.748]             `[[` <- base::`[[`
[17:28:00.748]             `+` <- base::`+`
[17:28:00.748]             `<<-` <- base::`<<-`
[17:28:00.748]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:00.748]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:00.748]                   3L)]
[17:28:00.748]             }
[17:28:00.748]             function(cond) {
[17:28:00.748]                 is_error <- inherits(cond, "error")
[17:28:00.748]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:00.748]                   NULL)
[17:28:00.748]                 if (is_error) {
[17:28:00.748]                   sessionInformation <- function() {
[17:28:00.748]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:00.748]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:00.748]                       search = base::search(), system = base::Sys.info())
[17:28:00.748]                   }
[17:28:00.748]                   ...future.conditions[[length(...future.conditions) + 
[17:28:00.748]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:00.748]                     cond$call), session = sessionInformation(), 
[17:28:00.748]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:00.748]                   signalCondition(cond)
[17:28:00.748]                 }
[17:28:00.748]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:00.748]                 "immediateCondition"))) {
[17:28:00.748]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:00.748]                   ...future.conditions[[length(...future.conditions) + 
[17:28:00.748]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:00.748]                   if (TRUE && !signal) {
[17:28:00.748]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:00.748]                     {
[17:28:00.748]                       inherits <- base::inherits
[17:28:00.748]                       invokeRestart <- base::invokeRestart
[17:28:00.748]                       is.null <- base::is.null
[17:28:00.748]                       muffled <- FALSE
[17:28:00.748]                       if (inherits(cond, "message")) {
[17:28:00.748]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:00.748]                         if (muffled) 
[17:28:00.748]                           invokeRestart("muffleMessage")
[17:28:00.748]                       }
[17:28:00.748]                       else if (inherits(cond, "warning")) {
[17:28:00.748]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:00.748]                         if (muffled) 
[17:28:00.748]                           invokeRestart("muffleWarning")
[17:28:00.748]                       }
[17:28:00.748]                       else if (inherits(cond, "condition")) {
[17:28:00.748]                         if (!is.null(pattern)) {
[17:28:00.748]                           computeRestarts <- base::computeRestarts
[17:28:00.748]                           grepl <- base::grepl
[17:28:00.748]                           restarts <- computeRestarts(cond)
[17:28:00.748]                           for (restart in restarts) {
[17:28:00.748]                             name <- restart$name
[17:28:00.748]                             if (is.null(name)) 
[17:28:00.748]                               next
[17:28:00.748]                             if (!grepl(pattern, name)) 
[17:28:00.748]                               next
[17:28:00.748]                             invokeRestart(restart)
[17:28:00.748]                             muffled <- TRUE
[17:28:00.748]                             break
[17:28:00.748]                           }
[17:28:00.748]                         }
[17:28:00.748]                       }
[17:28:00.748]                       invisible(muffled)
[17:28:00.748]                     }
[17:28:00.748]                     muffleCondition(cond, pattern = "^muffle")
[17:28:00.748]                   }
[17:28:00.748]                 }
[17:28:00.748]                 else {
[17:28:00.748]                   if (TRUE) {
[17:28:00.748]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:00.748]                     {
[17:28:00.748]                       inherits <- base::inherits
[17:28:00.748]                       invokeRestart <- base::invokeRestart
[17:28:00.748]                       is.null <- base::is.null
[17:28:00.748]                       muffled <- FALSE
[17:28:00.748]                       if (inherits(cond, "message")) {
[17:28:00.748]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:00.748]                         if (muffled) 
[17:28:00.748]                           invokeRestart("muffleMessage")
[17:28:00.748]                       }
[17:28:00.748]                       else if (inherits(cond, "warning")) {
[17:28:00.748]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:00.748]                         if (muffled) 
[17:28:00.748]                           invokeRestart("muffleWarning")
[17:28:00.748]                       }
[17:28:00.748]                       else if (inherits(cond, "condition")) {
[17:28:00.748]                         if (!is.null(pattern)) {
[17:28:00.748]                           computeRestarts <- base::computeRestarts
[17:28:00.748]                           grepl <- base::grepl
[17:28:00.748]                           restarts <- computeRestarts(cond)
[17:28:00.748]                           for (restart in restarts) {
[17:28:00.748]                             name <- restart$name
[17:28:00.748]                             if (is.null(name)) 
[17:28:00.748]                               next
[17:28:00.748]                             if (!grepl(pattern, name)) 
[17:28:00.748]                               next
[17:28:00.748]                             invokeRestart(restart)
[17:28:00.748]                             muffled <- TRUE
[17:28:00.748]                             break
[17:28:00.748]                           }
[17:28:00.748]                         }
[17:28:00.748]                       }
[17:28:00.748]                       invisible(muffled)
[17:28:00.748]                     }
[17:28:00.748]                     muffleCondition(cond, pattern = "^muffle")
[17:28:00.748]                   }
[17:28:00.748]                 }
[17:28:00.748]             }
[17:28:00.748]         }))
[17:28:00.748]     }, error = function(ex) {
[17:28:00.748]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:00.748]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:00.748]                 ...future.rng), started = ...future.startTime, 
[17:28:00.748]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:00.748]             version = "1.8"), class = "FutureResult")
[17:28:00.748]     }, finally = {
[17:28:00.748]         if (!identical(...future.workdir, getwd())) 
[17:28:00.748]             setwd(...future.workdir)
[17:28:00.748]         {
[17:28:00.748]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:00.748]                 ...future.oldOptions$nwarnings <- NULL
[17:28:00.748]             }
[17:28:00.748]             base::options(...future.oldOptions)
[17:28:00.748]             if (.Platform$OS.type == "windows") {
[17:28:00.748]                 old_names <- names(...future.oldEnvVars)
[17:28:00.748]                 envs <- base::Sys.getenv()
[17:28:00.748]                 names <- names(envs)
[17:28:00.748]                 common <- intersect(names, old_names)
[17:28:00.748]                 added <- setdiff(names, old_names)
[17:28:00.748]                 removed <- setdiff(old_names, names)
[17:28:00.748]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:00.748]                   envs[common]]
[17:28:00.748]                 NAMES <- toupper(changed)
[17:28:00.748]                 args <- list()
[17:28:00.748]                 for (kk in seq_along(NAMES)) {
[17:28:00.748]                   name <- changed[[kk]]
[17:28:00.748]                   NAME <- NAMES[[kk]]
[17:28:00.748]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:00.748]                     next
[17:28:00.748]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:00.748]                 }
[17:28:00.748]                 NAMES <- toupper(added)
[17:28:00.748]                 for (kk in seq_along(NAMES)) {
[17:28:00.748]                   name <- added[[kk]]
[17:28:00.748]                   NAME <- NAMES[[kk]]
[17:28:00.748]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:00.748]                     next
[17:28:00.748]                   args[[name]] <- ""
[17:28:00.748]                 }
[17:28:00.748]                 NAMES <- toupper(removed)
[17:28:00.748]                 for (kk in seq_along(NAMES)) {
[17:28:00.748]                   name <- removed[[kk]]
[17:28:00.748]                   NAME <- NAMES[[kk]]
[17:28:00.748]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:00.748]                     next
[17:28:00.748]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:00.748]                 }
[17:28:00.748]                 if (length(args) > 0) 
[17:28:00.748]                   base::do.call(base::Sys.setenv, args = args)
[17:28:00.748]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:00.748]             }
[17:28:00.748]             else {
[17:28:00.748]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:00.748]             }
[17:28:00.748]             {
[17:28:00.748]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:00.748]                   0L) {
[17:28:00.748]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:00.748]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:00.748]                   base::options(opts)
[17:28:00.748]                 }
[17:28:00.748]                 {
[17:28:00.748]                   {
[17:28:00.748]                     NULL
[17:28:00.748]                     RNGkind("Mersenne-Twister")
[17:28:00.748]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:28:00.748]                       inherits = FALSE)
[17:28:00.748]                   }
[17:28:00.748]                   options(future.plan = NULL)
[17:28:00.748]                   if (is.na(NA_character_)) 
[17:28:00.748]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:00.748]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:00.748]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:00.748]                     .init = FALSE)
[17:28:00.748]                 }
[17:28:00.748]             }
[17:28:00.748]         }
[17:28:00.748]     })
[17:28:00.748]     if (TRUE) {
[17:28:00.748]         base::sink(type = "output", split = FALSE)
[17:28:00.748]         if (TRUE) {
[17:28:00.748]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:00.748]         }
[17:28:00.748]         else {
[17:28:00.748]             ...future.result["stdout"] <- base::list(NULL)
[17:28:00.748]         }
[17:28:00.748]         base::close(...future.stdout)
[17:28:00.748]         ...future.stdout <- NULL
[17:28:00.748]     }
[17:28:00.748]     ...future.result$conditions <- ...future.conditions
[17:28:00.748]     ...future.result$finished <- base::Sys.time()
[17:28:00.748]     ...future.result
[17:28:00.748] }
[17:28:00.754] assign_globals() ...
[17:28:00.754] List of 1
[17:28:00.754]  $ x: list()
[17:28:00.754]  - attr(*, "where")=List of 1
[17:28:00.754]   ..$ x:<environment: R_EmptyEnv> 
[17:28:00.754]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:28:00.754]  - attr(*, "resolved")= logi TRUE
[17:28:00.754]  - attr(*, "total_size")= int 31
[17:28:00.754]  - attr(*, "already-done")= logi TRUE
[17:28:00.759] - copied 'x' to environment
[17:28:00.759] assign_globals() ... done
[17:28:00.760] plan(): Setting new future strategy stack:
[17:28:00.760] List of future strategies:
[17:28:00.760] 1. sequential:
[17:28:00.760]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:00.760]    - tweaked: FALSE
[17:28:00.760]    - call: NULL
[17:28:00.761] plan(): nbrOfWorkers() = 1
[17:28:00.763] plan(): Setting new future strategy stack:
[17:28:00.763] List of future strategies:
[17:28:00.763] 1. sequential:
[17:28:00.763]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:00.763]    - tweaked: FALSE
[17:28:00.763]    - call: plan(strategy)
[17:28:00.764] plan(): nbrOfWorkers() = 1
[17:28:00.765] SequentialFuture started (and completed)
[17:28:00.765] - Launch lazy future ... done
[17:28:00.765] run() for 'SequentialFuture' ... done
$a
[1] 1

Warning in getGlobalsAndPackages(expr, envir = envir, tweak = tweakExpression,  :
  R option 'future.globals.resolve' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'TRUE'
[17:28:00.766] getGlobalsAndPackages() ...
Warning in getGlobalsAndPackages(expr, envir = envir, tweak = tweakExpression,  :
  R option 'future.globals.onMissing' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'error'
[17:28:00.767] Searching for globals...
[17:28:00.771] - globals found: [6] '{', 'x', '<-', '[', '[<-', 'list'
[17:28:00.774] Searching for globals ... DONE
[17:28:00.774] Resolving globals: TRUE
[17:28:00.775] Resolving any globals that are futures ...
[17:28:00.775] - globals: [6] '{', 'x', '<-', '[', '[<-', 'list'
[17:28:00.775] Resolving any globals that are futures ... DONE
[17:28:00.776] Resolving futures part of globals (recursively) ...
[17:28:00.776] resolve() on list ...
[17:28:00.777]  recursive: 99
[17:28:00.777]  length: 1
[17:28:00.777]  elements: 'x'
[17:28:00.777]  length: 0 (resolved future 1)
[17:28:00.778] resolve() on list ... DONE
[17:28:00.778] - globals: [1] 'x'
[17:28:00.778] Resolving futures part of globals (recursively) ... DONE
[17:28:00.779] The total size of the 1 globals is 31 bytes (31 bytes)
[17:28:00.779] The total size of the 1 globals exported for future expression ('{; x["a"] <- list(1); x; }') is 31 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (31 bytes of class 'list')
[17:28:00.780] - globals: [1] 'x'
[17:28:00.780] 
[17:28:00.780] getGlobalsAndPackages() ... DONE
[17:28:00.781] run() for 'Future' ...
[17:28:00.781] - state: 'created'
[17:28:00.781] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:28:00.782] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:28:00.782] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:28:00.782]   - Field: 'label'
[17:28:00.783]   - Field: 'local'
[17:28:00.783]   - Field: 'owner'
[17:28:00.783]   - Field: 'envir'
[17:28:00.784]   - Field: 'packages'
[17:28:00.784]   - Field: 'gc'
[17:28:00.784]   - Field: 'conditions'
[17:28:00.784]   - Field: 'expr'
[17:28:00.785]   - Field: 'uuid'
[17:28:00.785]   - Field: 'seed'
[17:28:00.785]   - Field: 'version'
[17:28:00.785]   - Field: 'result'
[17:28:00.786]   - Field: 'asynchronous'
[17:28:00.786]   - Field: 'calls'
[17:28:00.786]   - Field: 'globals'
[17:28:00.787]   - Field: 'stdout'
[17:28:00.787]   - Field: 'earlySignal'
[17:28:00.787]   - Field: 'lazy'
[17:28:00.787]   - Field: 'state'
[17:28:00.788] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:28:00.788] - Launch lazy future ...
[17:28:00.788] Packages needed by the future expression (n = 0): <none>
[17:28:00.789] Packages needed by future strategies (n = 0): <none>
[17:28:00.790] {
[17:28:00.790]     {
[17:28:00.790]         {
[17:28:00.790]             ...future.startTime <- base::Sys.time()
[17:28:00.790]             {
[17:28:00.790]                 {
[17:28:00.790]                   {
[17:28:00.790]                     base::local({
[17:28:00.790]                       has_future <- base::requireNamespace("future", 
[17:28:00.790]                         quietly = TRUE)
[17:28:00.790]                       if (has_future) {
[17:28:00.790]                         ns <- base::getNamespace("future")
[17:28:00.790]                         version <- ns[[".package"]][["version"]]
[17:28:00.790]                         if (is.null(version)) 
[17:28:00.790]                           version <- utils::packageVersion("future")
[17:28:00.790]                       }
[17:28:00.790]                       else {
[17:28:00.790]                         version <- NULL
[17:28:00.790]                       }
[17:28:00.790]                       if (!has_future || version < "1.8.0") {
[17:28:00.790]                         info <- base::c(r_version = base::gsub("R version ", 
[17:28:00.790]                           "", base::R.version$version.string), 
[17:28:00.790]                           platform = base::sprintf("%s (%s-bit)", 
[17:28:00.790]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:00.790]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:00.790]                             "release", "version")], collapse = " "), 
[17:28:00.790]                           hostname = base::Sys.info()[["nodename"]])
[17:28:00.790]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:28:00.790]                           info)
[17:28:00.790]                         info <- base::paste(info, collapse = "; ")
[17:28:00.790]                         if (!has_future) {
[17:28:00.790]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:00.790]                             info)
[17:28:00.790]                         }
[17:28:00.790]                         else {
[17:28:00.790]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:00.790]                             info, version)
[17:28:00.790]                         }
[17:28:00.790]                         base::stop(msg)
[17:28:00.790]                       }
[17:28:00.790]                     })
[17:28:00.790]                   }
[17:28:00.790]                   ...future.strategy.old <- future::plan("list")
[17:28:00.790]                   options(future.plan = NULL)
[17:28:00.790]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:00.790]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:00.790]                 }
[17:28:00.790]                 ...future.workdir <- getwd()
[17:28:00.790]             }
[17:28:00.790]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:00.790]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:00.790]         }
[17:28:00.790]         base::options(future.startup.script = FALSE, future.globals.onMissing = "error", 
[17:28:00.790]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:00.790]             future.globals.onMissing = "error", future.globals.onReference = NULL, 
[17:28:00.790]             future.globals.resolve = TRUE, future.resolve.recursive = NULL, 
[17:28:00.790]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:28:00.790]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:00.790]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:00.790]             base::names(...future.oldOptions))
[17:28:00.790]     }
[17:28:00.790]     if (FALSE) {
[17:28:00.790]     }
[17:28:00.790]     else {
[17:28:00.790]         if (TRUE) {
[17:28:00.790]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:00.790]                 open = "w")
[17:28:00.790]         }
[17:28:00.790]         else {
[17:28:00.790]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:00.790]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:00.790]         }
[17:28:00.790]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:00.790]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:00.790]             base::sink(type = "output", split = FALSE)
[17:28:00.790]             base::close(...future.stdout)
[17:28:00.790]         }, add = TRUE)
[17:28:00.790]     }
[17:28:00.790]     ...future.frame <- base::sys.nframe()
[17:28:00.790]     ...future.conditions <- base::list()
[17:28:00.790]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:00.790]     if (FALSE) {
[17:28:00.790]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:00.790]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:00.790]     }
[17:28:00.790]     ...future.result <- base::tryCatch({
[17:28:00.790]         base::withCallingHandlers({
[17:28:00.790]             ...future.value <- base::withVisible(base::local({
[17:28:00.790]                 x["a"] <- list(1)
[17:28:00.790]                 x
[17:28:00.790]             }))
[17:28:00.790]             future::FutureResult(value = ...future.value$value, 
[17:28:00.790]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:00.790]                   ...future.rng), globalenv = if (FALSE) 
[17:28:00.790]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:00.790]                     ...future.globalenv.names))
[17:28:00.790]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:00.790]         }, condition = base::local({
[17:28:00.790]             c <- base::c
[17:28:00.790]             inherits <- base::inherits
[17:28:00.790]             invokeRestart <- base::invokeRestart
[17:28:00.790]             length <- base::length
[17:28:00.790]             list <- base::list
[17:28:00.790]             seq.int <- base::seq.int
[17:28:00.790]             signalCondition <- base::signalCondition
[17:28:00.790]             sys.calls <- base::sys.calls
[17:28:00.790]             `[[` <- base::`[[`
[17:28:00.790]             `+` <- base::`+`
[17:28:00.790]             `<<-` <- base::`<<-`
[17:28:00.790]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:00.790]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:00.790]                   3L)]
[17:28:00.790]             }
[17:28:00.790]             function(cond) {
[17:28:00.790]                 is_error <- inherits(cond, "error")
[17:28:00.790]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:00.790]                   NULL)
[17:28:00.790]                 if (is_error) {
[17:28:00.790]                   sessionInformation <- function() {
[17:28:00.790]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:00.790]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:00.790]                       search = base::search(), system = base::Sys.info())
[17:28:00.790]                   }
[17:28:00.790]                   ...future.conditions[[length(...future.conditions) + 
[17:28:00.790]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:00.790]                     cond$call), session = sessionInformation(), 
[17:28:00.790]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:00.790]                   signalCondition(cond)
[17:28:00.790]                 }
[17:28:00.790]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:00.790]                 "immediateCondition"))) {
[17:28:00.790]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:00.790]                   ...future.conditions[[length(...future.conditions) + 
[17:28:00.790]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:00.790]                   if (TRUE && !signal) {
[17:28:00.790]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:00.790]                     {
[17:28:00.790]                       inherits <- base::inherits
[17:28:00.790]                       invokeRestart <- base::invokeRestart
[17:28:00.790]                       is.null <- base::is.null
[17:28:00.790]                       muffled <- FALSE
[17:28:00.790]                       if (inherits(cond, "message")) {
[17:28:00.790]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:00.790]                         if (muffled) 
[17:28:00.790]                           invokeRestart("muffleMessage")
[17:28:00.790]                       }
[17:28:00.790]                       else if (inherits(cond, "warning")) {
[17:28:00.790]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:00.790]                         if (muffled) 
[17:28:00.790]                           invokeRestart("muffleWarning")
[17:28:00.790]                       }
[17:28:00.790]                       else if (inherits(cond, "condition")) {
[17:28:00.790]                         if (!is.null(pattern)) {
[17:28:00.790]                           computeRestarts <- base::computeRestarts
[17:28:00.790]                           grepl <- base::grepl
[17:28:00.790]                           restarts <- computeRestarts(cond)
[17:28:00.790]                           for (restart in restarts) {
[17:28:00.790]                             name <- restart$name
[17:28:00.790]                             if (is.null(name)) 
[17:28:00.790]                               next
[17:28:00.790]                             if (!grepl(pattern, name)) 
[17:28:00.790]                               next
[17:28:00.790]                             invokeRestart(restart)
[17:28:00.790]                             muffled <- TRUE
[17:28:00.790]                             break
[17:28:00.790]                           }
[17:28:00.790]                         }
[17:28:00.790]                       }
[17:28:00.790]                       invisible(muffled)
[17:28:00.790]                     }
[17:28:00.790]                     muffleCondition(cond, pattern = "^muffle")
[17:28:00.790]                   }
[17:28:00.790]                 }
[17:28:00.790]                 else {
[17:28:00.790]                   if (TRUE) {
[17:28:00.790]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:00.790]                     {
[17:28:00.790]                       inherits <- base::inherits
[17:28:00.790]                       invokeRestart <- base::invokeRestart
[17:28:00.790]                       is.null <- base::is.null
[17:28:00.790]                       muffled <- FALSE
[17:28:00.790]                       if (inherits(cond, "message")) {
[17:28:00.790]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:00.790]                         if (muffled) 
[17:28:00.790]                           invokeRestart("muffleMessage")
[17:28:00.790]                       }
[17:28:00.790]                       else if (inherits(cond, "warning")) {
[17:28:00.790]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:00.790]                         if (muffled) 
[17:28:00.790]                           invokeRestart("muffleWarning")
[17:28:00.790]                       }
[17:28:00.790]                       else if (inherits(cond, "condition")) {
[17:28:00.790]                         if (!is.null(pattern)) {
[17:28:00.790]                           computeRestarts <- base::computeRestarts
[17:28:00.790]                           grepl <- base::grepl
[17:28:00.790]                           restarts <- computeRestarts(cond)
[17:28:00.790]                           for (restart in restarts) {
[17:28:00.790]                             name <- restart$name
[17:28:00.790]                             if (is.null(name)) 
[17:28:00.790]                               next
[17:28:00.790]                             if (!grepl(pattern, name)) 
[17:28:00.790]                               next
[17:28:00.790]                             invokeRestart(restart)
[17:28:00.790]                             muffled <- TRUE
[17:28:00.790]                             break
[17:28:00.790]                           }
[17:28:00.790]                         }
[17:28:00.790]                       }
[17:28:00.790]                       invisible(muffled)
[17:28:00.790]                     }
[17:28:00.790]                     muffleCondition(cond, pattern = "^muffle")
[17:28:00.790]                   }
[17:28:00.790]                 }
[17:28:00.790]             }
[17:28:00.790]         }))
[17:28:00.790]     }, error = function(ex) {
[17:28:00.790]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:00.790]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:00.790]                 ...future.rng), started = ...future.startTime, 
[17:28:00.790]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:00.790]             version = "1.8"), class = "FutureResult")
[17:28:00.790]     }, finally = {
[17:28:00.790]         if (!identical(...future.workdir, getwd())) 
[17:28:00.790]             setwd(...future.workdir)
[17:28:00.790]         {
[17:28:00.790]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:00.790]                 ...future.oldOptions$nwarnings <- NULL
[17:28:00.790]             }
[17:28:00.790]             base::options(...future.oldOptions)
[17:28:00.790]             if (.Platform$OS.type == "windows") {
[17:28:00.790]                 old_names <- names(...future.oldEnvVars)
[17:28:00.790]                 envs <- base::Sys.getenv()
[17:28:00.790]                 names <- names(envs)
[17:28:00.790]                 common <- intersect(names, old_names)
[17:28:00.790]                 added <- setdiff(names, old_names)
[17:28:00.790]                 removed <- setdiff(old_names, names)
[17:28:00.790]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:00.790]                   envs[common]]
[17:28:00.790]                 NAMES <- toupper(changed)
[17:28:00.790]                 args <- list()
[17:28:00.790]                 for (kk in seq_along(NAMES)) {
[17:28:00.790]                   name <- changed[[kk]]
[17:28:00.790]                   NAME <- NAMES[[kk]]
[17:28:00.790]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:00.790]                     next
[17:28:00.790]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:00.790]                 }
[17:28:00.790]                 NAMES <- toupper(added)
[17:28:00.790]                 for (kk in seq_along(NAMES)) {
[17:28:00.790]                   name <- added[[kk]]
[17:28:00.790]                   NAME <- NAMES[[kk]]
[17:28:00.790]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:00.790]                     next
[17:28:00.790]                   args[[name]] <- ""
[17:28:00.790]                 }
[17:28:00.790]                 NAMES <- toupper(removed)
[17:28:00.790]                 for (kk in seq_along(NAMES)) {
[17:28:00.790]                   name <- removed[[kk]]
[17:28:00.790]                   NAME <- NAMES[[kk]]
[17:28:00.790]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:00.790]                     next
[17:28:00.790]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:00.790]                 }
[17:28:00.790]                 if (length(args) > 0) 
[17:28:00.790]                   base::do.call(base::Sys.setenv, args = args)
[17:28:00.790]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:00.790]             }
[17:28:00.790]             else {
[17:28:00.790]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:00.790]             }
[17:28:00.790]             {
[17:28:00.790]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:00.790]                   0L) {
[17:28:00.790]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:00.790]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:00.790]                   base::options(opts)
[17:28:00.790]                 }
[17:28:00.790]                 {
[17:28:00.790]                   {
[17:28:00.790]                     NULL
[17:28:00.790]                     RNGkind("Mersenne-Twister")
[17:28:00.790]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:28:00.790]                       inherits = FALSE)
[17:28:00.790]                   }
[17:28:00.790]                   options(future.plan = NULL)
[17:28:00.790]                   if (is.na(NA_character_)) 
[17:28:00.790]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:00.790]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:00.790]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:00.790]                     .init = FALSE)
[17:28:00.790]                 }
[17:28:00.790]             }
[17:28:00.790]         }
[17:28:00.790]     })
[17:28:00.790]     if (TRUE) {
[17:28:00.790]         base::sink(type = "output", split = FALSE)
[17:28:00.790]         if (TRUE) {
[17:28:00.790]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:00.790]         }
[17:28:00.790]         else {
[17:28:00.790]             ...future.result["stdout"] <- base::list(NULL)
[17:28:00.790]         }
[17:28:00.790]         base::close(...future.stdout)
[17:28:00.790]         ...future.stdout <- NULL
[17:28:00.790]     }
[17:28:00.790]     ...future.result$conditions <- ...future.conditions
[17:28:00.790]     ...future.result$finished <- base::Sys.time()
[17:28:00.790]     ...future.result
[17:28:00.790] }
[17:28:00.796] assign_globals() ...
[17:28:00.796] List of 1
[17:28:00.796]  $ x: list()
[17:28:00.796]  - attr(*, "where")=List of 1
[17:28:00.796]   ..$ x:<environment: R_EmptyEnv> 
[17:28:00.796]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:28:00.796]  - attr(*, "resolved")= logi TRUE
[17:28:00.796]  - attr(*, "total_size")= int 31
[17:28:00.796]  - attr(*, "already-done")= logi TRUE
[17:28:00.800] - copied 'x' to environment
[17:28:00.801] assign_globals() ... done
[17:28:00.801] plan(): Setting new future strategy stack:
[17:28:00.802] List of future strategies:
[17:28:00.802] 1. sequential:
[17:28:00.802]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:00.802]    - tweaked: FALSE
[17:28:00.802]    - call: NULL
[17:28:00.802] plan(): nbrOfWorkers() = 1
[17:28:00.804] plan(): Setting new future strategy stack:
[17:28:00.805] List of future strategies:
[17:28:00.805] 1. sequential:
[17:28:00.805]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:00.805]    - tweaked: FALSE
[17:28:00.805]    - call: plan(strategy)
[17:28:00.806] plan(): nbrOfWorkers() = 1
[17:28:00.806] SequentialFuture started (and completed)
[17:28:00.806] - Launch lazy future ... done
[17:28:00.807] run() for 'SequentialFuture' ... done
$a
[1] 1

Warning in getGlobalsAndPackages(expr, envir = envir, tweak = tweakExpression,  :
  R option 'future.globals.resolve' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'TRUE'
[17:28:00.808] getGlobalsAndPackages() ...
Warning in getGlobalsAndPackages(expr, envir = envir, tweak = tweakExpression,  :
  R option 'future.globals.onMissing' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'error'
[17:28:00.808] Searching for globals...
[17:28:00.812] - globals found: [6] '{', 'x', '<-', '[', '[<-', 'list'
[17:28:00.813] Searching for globals ... DONE
[17:28:00.813] Resolving globals: TRUE
[17:28:00.813] Resolving any globals that are futures ...
[17:28:00.813] - globals: [6] '{', 'x', '<-', '[', '[<-', 'list'
[17:28:00.814] Resolving any globals that are futures ... DONE
[17:28:00.814] Resolving futures part of globals (recursively) ...
[17:28:00.815] resolve() on list ...
[17:28:00.815]  recursive: 99
[17:28:00.815]  length: 1
[17:28:00.816]  elements: 'x'
[17:28:00.816]  length: 0 (resolved future 1)
[17:28:00.816] resolve() on list ... DONE
[17:28:00.816] - globals: [1] 'x'
[17:28:00.817] Resolving futures part of globals (recursively) ... DONE
[17:28:00.817] The total size of the 1 globals is 31 bytes (31 bytes)
[17:28:00.818] The total size of the 1 globals exported for future expression ('{; x["a"] <- list(1); x; }') is 31 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (31 bytes of class 'list')
[17:28:00.818] - globals: [1] 'x'
[17:28:00.818] 
[17:28:00.818] getGlobalsAndPackages() ... DONE
[17:28:00.819] run() for 'Future' ...
[17:28:00.819] - state: 'created'
[17:28:00.822] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:28:00.823] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:28:00.823] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:28:00.823]   - Field: 'label'
[17:28:00.824]   - Field: 'local'
[17:28:00.824]   - Field: 'owner'
[17:28:00.824]   - Field: 'envir'
[17:28:00.825]   - Field: 'packages'
[17:28:00.825]   - Field: 'gc'
[17:28:00.825]   - Field: 'conditions'
[17:28:00.825]   - Field: 'expr'
[17:28:00.826]   - Field: 'uuid'
[17:28:00.826]   - Field: 'seed'
[17:28:00.826]   - Field: 'version'
[17:28:00.826]   - Field: 'result'
[17:28:00.827]   - Field: 'asynchronous'
[17:28:00.827]   - Field: 'calls'
[17:28:00.827]   - Field: 'globals'
[17:28:00.827]   - Field: 'stdout'
[17:28:00.828]   - Field: 'earlySignal'
[17:28:00.828]   - Field: 'lazy'
[17:28:00.828]   - Field: 'state'
[17:28:00.828] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:28:00.829] - Launch lazy future ...
[17:28:00.829] Packages needed by the future expression (n = 0): <none>
[17:28:00.829] Packages needed by future strategies (n = 0): <none>
[17:28:00.830] {
[17:28:00.830]     {
[17:28:00.830]         {
[17:28:00.830]             ...future.startTime <- base::Sys.time()
[17:28:00.830]             {
[17:28:00.830]                 {
[17:28:00.830]                   {
[17:28:00.830]                     base::local({
[17:28:00.830]                       has_future <- base::requireNamespace("future", 
[17:28:00.830]                         quietly = TRUE)
[17:28:00.830]                       if (has_future) {
[17:28:00.830]                         ns <- base::getNamespace("future")
[17:28:00.830]                         version <- ns[[".package"]][["version"]]
[17:28:00.830]                         if (is.null(version)) 
[17:28:00.830]                           version <- utils::packageVersion("future")
[17:28:00.830]                       }
[17:28:00.830]                       else {
[17:28:00.830]                         version <- NULL
[17:28:00.830]                       }
[17:28:00.830]                       if (!has_future || version < "1.8.0") {
[17:28:00.830]                         info <- base::c(r_version = base::gsub("R version ", 
[17:28:00.830]                           "", base::R.version$version.string), 
[17:28:00.830]                           platform = base::sprintf("%s (%s-bit)", 
[17:28:00.830]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:00.830]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:00.830]                             "release", "version")], collapse = " "), 
[17:28:00.830]                           hostname = base::Sys.info()[["nodename"]])
[17:28:00.830]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:28:00.830]                           info)
[17:28:00.830]                         info <- base::paste(info, collapse = "; ")
[17:28:00.830]                         if (!has_future) {
[17:28:00.830]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:00.830]                             info)
[17:28:00.830]                         }
[17:28:00.830]                         else {
[17:28:00.830]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:00.830]                             info, version)
[17:28:00.830]                         }
[17:28:00.830]                         base::stop(msg)
[17:28:00.830]                       }
[17:28:00.830]                     })
[17:28:00.830]                   }
[17:28:00.830]                   ...future.strategy.old <- future::plan("list")
[17:28:00.830]                   options(future.plan = NULL)
[17:28:00.830]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:00.830]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:00.830]                 }
[17:28:00.830]                 ...future.workdir <- getwd()
[17:28:00.830]             }
[17:28:00.830]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:00.830]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:00.830]         }
[17:28:00.830]         base::options(future.startup.script = FALSE, future.globals.onMissing = "error", 
[17:28:00.830]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:00.830]             future.globals.onMissing = "error", future.globals.onReference = NULL, 
[17:28:00.830]             future.globals.resolve = TRUE, future.resolve.recursive = NULL, 
[17:28:00.830]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:28:00.830]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:00.830]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:00.830]             base::names(...future.oldOptions))
[17:28:00.830]     }
[17:28:00.830]     if (FALSE) {
[17:28:00.830]     }
[17:28:00.830]     else {
[17:28:00.830]         if (TRUE) {
[17:28:00.830]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:00.830]                 open = "w")
[17:28:00.830]         }
[17:28:00.830]         else {
[17:28:00.830]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:00.830]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:00.830]         }
[17:28:00.830]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:00.830]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:00.830]             base::sink(type = "output", split = FALSE)
[17:28:00.830]             base::close(...future.stdout)
[17:28:00.830]         }, add = TRUE)
[17:28:00.830]     }
[17:28:00.830]     ...future.frame <- base::sys.nframe()
[17:28:00.830]     ...future.conditions <- base::list()
[17:28:00.830]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:00.830]     if (FALSE) {
[17:28:00.830]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:00.830]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:00.830]     }
[17:28:00.830]     ...future.result <- base::tryCatch({
[17:28:00.830]         base::withCallingHandlers({
[17:28:00.830]             ...future.value <- base::withVisible(base::local({
[17:28:00.830]                 x["a"] <- list(1)
[17:28:00.830]                 x
[17:28:00.830]             }))
[17:28:00.830]             future::FutureResult(value = ...future.value$value, 
[17:28:00.830]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:00.830]                   ...future.rng), globalenv = if (FALSE) 
[17:28:00.830]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:00.830]                     ...future.globalenv.names))
[17:28:00.830]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:00.830]         }, condition = base::local({
[17:28:00.830]             c <- base::c
[17:28:00.830]             inherits <- base::inherits
[17:28:00.830]             invokeRestart <- base::invokeRestart
[17:28:00.830]             length <- base::length
[17:28:00.830]             list <- base::list
[17:28:00.830]             seq.int <- base::seq.int
[17:28:00.830]             signalCondition <- base::signalCondition
[17:28:00.830]             sys.calls <- base::sys.calls
[17:28:00.830]             `[[` <- base::`[[`
[17:28:00.830]             `+` <- base::`+`
[17:28:00.830]             `<<-` <- base::`<<-`
[17:28:00.830]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:00.830]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:00.830]                   3L)]
[17:28:00.830]             }
[17:28:00.830]             function(cond) {
[17:28:00.830]                 is_error <- inherits(cond, "error")
[17:28:00.830]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:00.830]                   NULL)
[17:28:00.830]                 if (is_error) {
[17:28:00.830]                   sessionInformation <- function() {
[17:28:00.830]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:00.830]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:00.830]                       search = base::search(), system = base::Sys.info())
[17:28:00.830]                   }
[17:28:00.830]                   ...future.conditions[[length(...future.conditions) + 
[17:28:00.830]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:00.830]                     cond$call), session = sessionInformation(), 
[17:28:00.830]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:00.830]                   signalCondition(cond)
[17:28:00.830]                 }
[17:28:00.830]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:00.830]                 "immediateCondition"))) {
[17:28:00.830]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:00.830]                   ...future.conditions[[length(...future.conditions) + 
[17:28:00.830]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:00.830]                   if (TRUE && !signal) {
[17:28:00.830]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:00.830]                     {
[17:28:00.830]                       inherits <- base::inherits
[17:28:00.830]                       invokeRestart <- base::invokeRestart
[17:28:00.830]                       is.null <- base::is.null
[17:28:00.830]                       muffled <- FALSE
[17:28:00.830]                       if (inherits(cond, "message")) {
[17:28:00.830]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:00.830]                         if (muffled) 
[17:28:00.830]                           invokeRestart("muffleMessage")
[17:28:00.830]                       }
[17:28:00.830]                       else if (inherits(cond, "warning")) {
[17:28:00.830]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:00.830]                         if (muffled) 
[17:28:00.830]                           invokeRestart("muffleWarning")
[17:28:00.830]                       }
[17:28:00.830]                       else if (inherits(cond, "condition")) {
[17:28:00.830]                         if (!is.null(pattern)) {
[17:28:00.830]                           computeRestarts <- base::computeRestarts
[17:28:00.830]                           grepl <- base::grepl
[17:28:00.830]                           restarts <- computeRestarts(cond)
[17:28:00.830]                           for (restart in restarts) {
[17:28:00.830]                             name <- restart$name
[17:28:00.830]                             if (is.null(name)) 
[17:28:00.830]                               next
[17:28:00.830]                             if (!grepl(pattern, name)) 
[17:28:00.830]                               next
[17:28:00.830]                             invokeRestart(restart)
[17:28:00.830]                             muffled <- TRUE
[17:28:00.830]                             break
[17:28:00.830]                           }
[17:28:00.830]                         }
[17:28:00.830]                       }
[17:28:00.830]                       invisible(muffled)
[17:28:00.830]                     }
[17:28:00.830]                     muffleCondition(cond, pattern = "^muffle")
[17:28:00.830]                   }
[17:28:00.830]                 }
[17:28:00.830]                 else {
[17:28:00.830]                   if (TRUE) {
[17:28:00.830]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:00.830]                     {
[17:28:00.830]                       inherits <- base::inherits
[17:28:00.830]                       invokeRestart <- base::invokeRestart
[17:28:00.830]                       is.null <- base::is.null
[17:28:00.830]                       muffled <- FALSE
[17:28:00.830]                       if (inherits(cond, "message")) {
[17:28:00.830]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:00.830]                         if (muffled) 
[17:28:00.830]                           invokeRestart("muffleMessage")
[17:28:00.830]                       }
[17:28:00.830]                       else if (inherits(cond, "warning")) {
[17:28:00.830]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:00.830]                         if (muffled) 
[17:28:00.830]                           invokeRestart("muffleWarning")
[17:28:00.830]                       }
[17:28:00.830]                       else if (inherits(cond, "condition")) {
[17:28:00.830]                         if (!is.null(pattern)) {
[17:28:00.830]                           computeRestarts <- base::computeRestarts
[17:28:00.830]                           grepl <- base::grepl
[17:28:00.830]                           restarts <- computeRestarts(cond)
[17:28:00.830]                           for (restart in restarts) {
[17:28:00.830]                             name <- restart$name
[17:28:00.830]                             if (is.null(name)) 
[17:28:00.830]                               next
[17:28:00.830]                             if (!grepl(pattern, name)) 
[17:28:00.830]                               next
[17:28:00.830]                             invokeRestart(restart)
[17:28:00.830]                             muffled <- TRUE
[17:28:00.830]                             break
[17:28:00.830]                           }
[17:28:00.830]                         }
[17:28:00.830]                       }
[17:28:00.830]                       invisible(muffled)
[17:28:00.830]                     }
[17:28:00.830]                     muffleCondition(cond, pattern = "^muffle")
[17:28:00.830]                   }
[17:28:00.830]                 }
[17:28:00.830]             }
[17:28:00.830]         }))
[17:28:00.830]     }, error = function(ex) {
[17:28:00.830]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:00.830]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:00.830]                 ...future.rng), started = ...future.startTime, 
[17:28:00.830]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:00.830]             version = "1.8"), class = "FutureResult")
[17:28:00.830]     }, finally = {
[17:28:00.830]         if (!identical(...future.workdir, getwd())) 
[17:28:00.830]             setwd(...future.workdir)
[17:28:00.830]         {
[17:28:00.830]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:00.830]                 ...future.oldOptions$nwarnings <- NULL
[17:28:00.830]             }
[17:28:00.830]             base::options(...future.oldOptions)
[17:28:00.830]             if (.Platform$OS.type == "windows") {
[17:28:00.830]                 old_names <- names(...future.oldEnvVars)
[17:28:00.830]                 envs <- base::Sys.getenv()
[17:28:00.830]                 names <- names(envs)
[17:28:00.830]                 common <- intersect(names, old_names)
[17:28:00.830]                 added <- setdiff(names, old_names)
[17:28:00.830]                 removed <- setdiff(old_names, names)
[17:28:00.830]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:00.830]                   envs[common]]
[17:28:00.830]                 NAMES <- toupper(changed)
[17:28:00.830]                 args <- list()
[17:28:00.830]                 for (kk in seq_along(NAMES)) {
[17:28:00.830]                   name <- changed[[kk]]
[17:28:00.830]                   NAME <- NAMES[[kk]]
[17:28:00.830]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:00.830]                     next
[17:28:00.830]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:00.830]                 }
[17:28:00.830]                 NAMES <- toupper(added)
[17:28:00.830]                 for (kk in seq_along(NAMES)) {
[17:28:00.830]                   name <- added[[kk]]
[17:28:00.830]                   NAME <- NAMES[[kk]]
[17:28:00.830]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:00.830]                     next
[17:28:00.830]                   args[[name]] <- ""
[17:28:00.830]                 }
[17:28:00.830]                 NAMES <- toupper(removed)
[17:28:00.830]                 for (kk in seq_along(NAMES)) {
[17:28:00.830]                   name <- removed[[kk]]
[17:28:00.830]                   NAME <- NAMES[[kk]]
[17:28:00.830]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:00.830]                     next
[17:28:00.830]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:00.830]                 }
[17:28:00.830]                 if (length(args) > 0) 
[17:28:00.830]                   base::do.call(base::Sys.setenv, args = args)
[17:28:00.830]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:00.830]             }
[17:28:00.830]             else {
[17:28:00.830]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:00.830]             }
[17:28:00.830]             {
[17:28:00.830]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:00.830]                   0L) {
[17:28:00.830]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:00.830]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:00.830]                   base::options(opts)
[17:28:00.830]                 }
[17:28:00.830]                 {
[17:28:00.830]                   {
[17:28:00.830]                     NULL
[17:28:00.830]                     RNGkind("Mersenne-Twister")
[17:28:00.830]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:28:00.830]                       inherits = FALSE)
[17:28:00.830]                   }
[17:28:00.830]                   options(future.plan = NULL)
[17:28:00.830]                   if (is.na(NA_character_)) 
[17:28:00.830]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:00.830]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:00.830]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:00.830]                     .init = FALSE)
[17:28:00.830]                 }
[17:28:00.830]             }
[17:28:00.830]         }
[17:28:00.830]     })
[17:28:00.830]     if (TRUE) {
[17:28:00.830]         base::sink(type = "output", split = FALSE)
[17:28:00.830]         if (TRUE) {
[17:28:00.830]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:00.830]         }
[17:28:00.830]         else {
[17:28:00.830]             ...future.result["stdout"] <- base::list(NULL)
[17:28:00.830]         }
[17:28:00.830]         base::close(...future.stdout)
[17:28:00.830]         ...future.stdout <- NULL
[17:28:00.830]     }
[17:28:00.830]     ...future.result$conditions <- ...future.conditions
[17:28:00.830]     ...future.result$finished <- base::Sys.time()
[17:28:00.830]     ...future.result
[17:28:00.830] }
[17:28:00.836] assign_globals() ...
[17:28:00.836] List of 1
[17:28:00.836]  $ x: list()
[17:28:00.836]  - attr(*, "where")=List of 1
[17:28:00.836]   ..$ x:<environment: R_EmptyEnv> 
[17:28:00.836]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:28:00.836]  - attr(*, "resolved")= logi TRUE
[17:28:00.836]  - attr(*, "total_size")= int 31
[17:28:00.836]  - attr(*, "already-done")= logi TRUE
[17:28:00.840] - copied 'x' to environment
[17:28:00.841] assign_globals() ... done
[17:28:00.841] plan(): Setting new future strategy stack:
[17:28:00.842] List of future strategies:
[17:28:00.842] 1. sequential:
[17:28:00.842]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:00.842]    - tweaked: FALSE
[17:28:00.842]    - call: NULL
[17:28:00.842] plan(): nbrOfWorkers() = 1
[17:28:00.844] plan(): Setting new future strategy stack:
[17:28:00.845] List of future strategies:
[17:28:00.845] 1. sequential:
[17:28:00.845]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:00.845]    - tweaked: FALSE
[17:28:00.845]    - call: plan(strategy)
[17:28:00.845] plan(): nbrOfWorkers() = 1
[17:28:00.846] SequentialFuture started (and completed)
[17:28:00.846] - Launch lazy future ... done
[17:28:00.846] run() for 'SequentialFuture' ... done
$a
[1] 1

Warning in getGlobalsAndPackages(expr, envir = envir, tweak = tweakExpression,  :
  R option 'future.globals.resolve' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'TRUE'
[17:28:00.848] getGlobalsAndPackages() ...
Warning in getGlobalsAndPackages(expr, envir = envir, tweak = tweakExpression,  :
  R option 'future.globals.onMissing' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'error'
[17:28:00.848] Searching for globals...
[17:28:00.852] - globals found: [7] '{', 'x', '<-', '[', 'name', '[<-', 'list'
[17:28:00.853] Searching for globals ... DONE
[17:28:00.853] Resolving globals: TRUE
[17:28:00.853] Resolving any globals that are futures ...
[17:28:00.853] - globals: [7] '{', 'x', '<-', '[', 'name', '[<-', 'list'
[17:28:00.854] Resolving any globals that are futures ... DONE
[17:28:00.854] Resolving futures part of globals (recursively) ...
[17:28:00.855] resolve() on list ...
[17:28:00.855]  recursive: 99
[17:28:00.855]  length: 2
[17:28:00.856]  elements: 'x', 'name'
[17:28:00.856]  length: 1 (resolved future 1)
[17:28:00.856]  length: 0 (resolved future 2)
[17:28:00.857] resolve() on list ... DONE
[17:28:00.857] - globals: [2] 'x', 'name'
[17:28:00.857] Resolving futures part of globals (recursively) ... DONE
[17:28:00.857] The total size of the 2 globals is 71 bytes (71 bytes)
[17:28:00.858] The total size of the 2 globals exported for future expression ('{; x[name] <- list(1); x; }') is 71 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are two globals: 'name' (40 bytes of class 'character') and 'x' (31 bytes of class 'list')
[17:28:00.859] - globals: [2] 'x', 'name'
[17:28:00.859] 
[17:28:00.859] getGlobalsAndPackages() ... DONE
[17:28:00.860] run() for 'Future' ...
[17:28:00.860] - state: 'created'
[17:28:00.860] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[17:28:00.861] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[17:28:00.861] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[17:28:00.861]   - Field: 'label'
[17:28:00.862]   - Field: 'local'
[17:28:00.862]   - Field: 'owner'
[17:28:00.862]   - Field: 'envir'
[17:28:00.862]   - Field: 'packages'
[17:28:00.863]   - Field: 'gc'
[17:28:00.863]   - Field: 'conditions'
[17:28:00.863]   - Field: 'expr'
[17:28:00.863]   - Field: 'uuid'
[17:28:00.864]   - Field: 'seed'
[17:28:00.864]   - Field: 'version'
[17:28:00.864]   - Field: 'result'
[17:28:00.864]   - Field: 'asynchronous'
[17:28:00.865]   - Field: 'calls'
[17:28:00.865]   - Field: 'globals'
[17:28:00.865]   - Field: 'stdout'
[17:28:00.865]   - Field: 'earlySignal'
[17:28:00.866]   - Field: 'lazy'
[17:28:00.866]   - Field: 'state'
[17:28:00.869] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[17:28:00.869] - Launch lazy future ...
[17:28:00.870] Packages needed by the future expression (n = 0): <none>
[17:28:00.870] Packages needed by future strategies (n = 0): <none>
[17:28:00.871] {
[17:28:00.871]     {
[17:28:00.871]         {
[17:28:00.871]             ...future.startTime <- base::Sys.time()
[17:28:00.871]             {
[17:28:00.871]                 {
[17:28:00.871]                   {
[17:28:00.871]                     base::local({
[17:28:00.871]                       has_future <- base::requireNamespace("future", 
[17:28:00.871]                         quietly = TRUE)
[17:28:00.871]                       if (has_future) {
[17:28:00.871]                         ns <- base::getNamespace("future")
[17:28:00.871]                         version <- ns[[".package"]][["version"]]
[17:28:00.871]                         if (is.null(version)) 
[17:28:00.871]                           version <- utils::packageVersion("future")
[17:28:00.871]                       }
[17:28:00.871]                       else {
[17:28:00.871]                         version <- NULL
[17:28:00.871]                       }
[17:28:00.871]                       if (!has_future || version < "1.8.0") {
[17:28:00.871]                         info <- base::c(r_version = base::gsub("R version ", 
[17:28:00.871]                           "", base::R.version$version.string), 
[17:28:00.871]                           platform = base::sprintf("%s (%s-bit)", 
[17:28:00.871]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:00.871]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:00.871]                             "release", "version")], collapse = " "), 
[17:28:00.871]                           hostname = base::Sys.info()[["nodename"]])
[17:28:00.871]                         info <- base::sprintf("%s: %s", base::names(info), 
[17:28:00.871]                           info)
[17:28:00.871]                         info <- base::paste(info, collapse = "; ")
[17:28:00.871]                         if (!has_future) {
[17:28:00.871]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:00.871]                             info)
[17:28:00.871]                         }
[17:28:00.871]                         else {
[17:28:00.871]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:00.871]                             info, version)
[17:28:00.871]                         }
[17:28:00.871]                         base::stop(msg)
[17:28:00.871]                       }
[17:28:00.871]                     })
[17:28:00.871]                   }
[17:28:00.871]                   ...future.strategy.old <- future::plan("list")
[17:28:00.871]                   options(future.plan = NULL)
[17:28:00.871]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:00.871]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:00.871]                 }
[17:28:00.871]                 ...future.workdir <- getwd()
[17:28:00.871]             }
[17:28:00.871]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:00.871]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:00.871]         }
[17:28:00.871]         base::options(future.startup.script = FALSE, future.globals.onMissing = "error", 
[17:28:00.871]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:00.871]             future.globals.onMissing = "error", future.globals.onReference = NULL, 
[17:28:00.871]             future.globals.resolve = TRUE, future.resolve.recursive = NULL, 
[17:28:00.871]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:28:00.871]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:00.871]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:00.871]             base::names(...future.oldOptions))
[17:28:00.871]     }
[17:28:00.871]     if (FALSE) {
[17:28:00.871]     }
[17:28:00.871]     else {
[17:28:00.871]         if (TRUE) {
[17:28:00.871]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:00.871]                 open = "w")
[17:28:00.871]         }
[17:28:00.871]         else {
[17:28:00.871]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:00.871]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:00.871]         }
[17:28:00.871]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:00.871]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:00.871]             base::sink(type = "output", split = FALSE)
[17:28:00.871]             base::close(...future.stdout)
[17:28:00.871]         }, add = TRUE)
[17:28:00.871]     }
[17:28:00.871]     ...future.frame <- base::sys.nframe()
[17:28:00.871]     ...future.conditions <- base::list()
[17:28:00.871]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:00.871]     if (FALSE) {
[17:28:00.871]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:00.871]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:00.871]     }
[17:28:00.871]     ...future.result <- base::tryCatch({
[17:28:00.871]         base::withCallingHandlers({
[17:28:00.871]             ...future.value <- base::withVisible(base::local({
[17:28:00.871]                 x[name] <- list(1)
[17:28:00.871]                 x
[17:28:00.871]             }))
[17:28:00.871]             future::FutureResult(value = ...future.value$value, 
[17:28:00.871]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:00.871]                   ...future.rng), globalenv = if (FALSE) 
[17:28:00.871]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:00.871]                     ...future.globalenv.names))
[17:28:00.871]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:00.871]         }, condition = base::local({
[17:28:00.871]             c <- base::c
[17:28:00.871]             inherits <- base::inherits
[17:28:00.871]             invokeRestart <- base::invokeRestart
[17:28:00.871]             length <- base::length
[17:28:00.871]             list <- base::list
[17:28:00.871]             seq.int <- base::seq.int
[17:28:00.871]             signalCondition <- base::signalCondition
[17:28:00.871]             sys.calls <- base::sys.calls
[17:28:00.871]             `[[` <- base::`[[`
[17:28:00.871]             `+` <- base::`+`
[17:28:00.871]             `<<-` <- base::`<<-`
[17:28:00.871]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:00.871]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:00.871]                   3L)]
[17:28:00.871]             }
[17:28:00.871]             function(cond) {
[17:28:00.871]                 is_error <- inherits(cond, "error")
[17:28:00.871]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:00.871]                   NULL)
[17:28:00.871]                 if (is_error) {
[17:28:00.871]                   sessionInformation <- function() {
[17:28:00.871]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:00.871]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:00.871]                       search = base::search(), system = base::Sys.info())
[17:28:00.871]                   }
[17:28:00.871]                   ...future.conditions[[length(...future.conditions) + 
[17:28:00.871]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:00.871]                     cond$call), session = sessionInformation(), 
[17:28:00.871]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:00.871]                   signalCondition(cond)
[17:28:00.871]                 }
[17:28:00.871]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:00.871]                 "immediateCondition"))) {
[17:28:00.871]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:00.871]                   ...future.conditions[[length(...future.conditions) + 
[17:28:00.871]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:00.871]                   if (TRUE && !signal) {
[17:28:00.871]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:00.871]                     {
[17:28:00.871]                       inherits <- base::inherits
[17:28:00.871]                       invokeRestart <- base::invokeRestart
[17:28:00.871]                       is.null <- base::is.null
[17:28:00.871]                       muffled <- FALSE
[17:28:00.871]                       if (inherits(cond, "message")) {
[17:28:00.871]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:00.871]                         if (muffled) 
[17:28:00.871]                           invokeRestart("muffleMessage")
[17:28:00.871]                       }
[17:28:00.871]                       else if (inherits(cond, "warning")) {
[17:28:00.871]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:00.871]                         if (muffled) 
[17:28:00.871]                           invokeRestart("muffleWarning")
[17:28:00.871]                       }
[17:28:00.871]                       else if (inherits(cond, "condition")) {
[17:28:00.871]                         if (!is.null(pattern)) {
[17:28:00.871]                           computeRestarts <- base::computeRestarts
[17:28:00.871]                           grepl <- base::grepl
[17:28:00.871]                           restarts <- computeRestarts(cond)
[17:28:00.871]                           for (restart in restarts) {
[17:28:00.871]                             name <- restart$name
[17:28:00.871]                             if (is.null(name)) 
[17:28:00.871]                               next
[17:28:00.871]                             if (!grepl(pattern, name)) 
[17:28:00.871]                               next
[17:28:00.871]                             invokeRestart(restart)
[17:28:00.871]                             muffled <- TRUE
[17:28:00.871]                             break
[17:28:00.871]                           }
[17:28:00.871]                         }
[17:28:00.871]                       }
[17:28:00.871]                       invisible(muffled)
[17:28:00.871]                     }
[17:28:00.871]                     muffleCondition(cond, pattern = "^muffle")
[17:28:00.871]                   }
[17:28:00.871]                 }
[17:28:00.871]                 else {
[17:28:00.871]                   if (TRUE) {
[17:28:00.871]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:00.871]                     {
[17:28:00.871]                       inherits <- base::inherits
[17:28:00.871]                       invokeRestart <- base::invokeRestart
[17:28:00.871]                       is.null <- base::is.null
[17:28:00.871]                       muffled <- FALSE
[17:28:00.871]                       if (inherits(cond, "message")) {
[17:28:00.871]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:00.871]                         if (muffled) 
[17:28:00.871]                           invokeRestart("muffleMessage")
[17:28:00.871]                       }
[17:28:00.871]                       else if (inherits(cond, "warning")) {
[17:28:00.871]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:00.871]                         if (muffled) 
[17:28:00.871]                           invokeRestart("muffleWarning")
[17:28:00.871]                       }
[17:28:00.871]                       else if (inherits(cond, "condition")) {
[17:28:00.871]                         if (!is.null(pattern)) {
[17:28:00.871]                           computeRestarts <- base::computeRestarts
[17:28:00.871]                           grepl <- base::grepl
[17:28:00.871]                           restarts <- computeRestarts(cond)
[17:28:00.871]                           for (restart in restarts) {
[17:28:00.871]                             name <- restart$name
[17:28:00.871]                             if (is.null(name)) 
[17:28:00.871]                               next
[17:28:00.871]                             if (!grepl(pattern, name)) 
[17:28:00.871]                               next
[17:28:00.871]                             invokeRestart(restart)
[17:28:00.871]                             muffled <- TRUE
[17:28:00.871]                             break
[17:28:00.871]                           }
[17:28:00.871]                         }
[17:28:00.871]                       }
[17:28:00.871]                       invisible(muffled)
[17:28:00.871]                     }
[17:28:00.871]                     muffleCondition(cond, pattern = "^muffle")
[17:28:00.871]                   }
[17:28:00.871]                 }
[17:28:00.871]             }
[17:28:00.871]         }))
[17:28:00.871]     }, error = function(ex) {
[17:28:00.871]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:00.871]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:00.871]                 ...future.rng), started = ...future.startTime, 
[17:28:00.871]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:00.871]             version = "1.8"), class = "FutureResult")
[17:28:00.871]     }, finally = {
[17:28:00.871]         if (!identical(...future.workdir, getwd())) 
[17:28:00.871]             setwd(...future.workdir)
[17:28:00.871]         {
[17:28:00.871]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:00.871]                 ...future.oldOptions$nwarnings <- NULL
[17:28:00.871]             }
[17:28:00.871]             base::options(...future.oldOptions)
[17:28:00.871]             if (.Platform$OS.type == "windows") {
[17:28:00.871]                 old_names <- names(...future.oldEnvVars)
[17:28:00.871]                 envs <- base::Sys.getenv()
[17:28:00.871]                 names <- names(envs)
[17:28:00.871]                 common <- intersect(names, old_names)
[17:28:00.871]                 added <- setdiff(names, old_names)
[17:28:00.871]                 removed <- setdiff(old_names, names)
[17:28:00.871]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:00.871]                   envs[common]]
[17:28:00.871]                 NAMES <- toupper(changed)
[17:28:00.871]                 args <- list()
[17:28:00.871]                 for (kk in seq_along(NAMES)) {
[17:28:00.871]                   name <- changed[[kk]]
[17:28:00.871]                   NAME <- NAMES[[kk]]
[17:28:00.871]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:00.871]                     next
[17:28:00.871]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:00.871]                 }
[17:28:00.871]                 NAMES <- toupper(added)
[17:28:00.871]                 for (kk in seq_along(NAMES)) {
[17:28:00.871]                   name <- added[[kk]]
[17:28:00.871]                   NAME <- NAMES[[kk]]
[17:28:00.871]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:00.871]                     next
[17:28:00.871]                   args[[name]] <- ""
[17:28:00.871]                 }
[17:28:00.871]                 NAMES <- toupper(removed)
[17:28:00.871]                 for (kk in seq_along(NAMES)) {
[17:28:00.871]                   name <- removed[[kk]]
[17:28:00.871]                   NAME <- NAMES[[kk]]
[17:28:00.871]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:00.871]                     next
[17:28:00.871]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:00.871]                 }
[17:28:00.871]                 if (length(args) > 0) 
[17:28:00.871]                   base::do.call(base::Sys.setenv, args = args)
[17:28:00.871]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:00.871]             }
[17:28:00.871]             else {
[17:28:00.871]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:00.871]             }
[17:28:00.871]             {
[17:28:00.871]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:00.871]                   0L) {
[17:28:00.871]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:00.871]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:00.871]                   base::options(opts)
[17:28:00.871]                 }
[17:28:00.871]                 {
[17:28:00.871]                   {
[17:28:00.871]                     NULL
[17:28:00.871]                     RNGkind("Mersenne-Twister")
[17:28:00.871]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[17:28:00.871]                       inherits = FALSE)
[17:28:00.871]                   }
[17:28:00.871]                   options(future.plan = NULL)
[17:28:00.871]                   if (is.na(NA_character_)) 
[17:28:00.871]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:00.871]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:00.871]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:00.871]                     .init = FALSE)
[17:28:00.871]                 }
[17:28:00.871]             }
[17:28:00.871]         }
[17:28:00.871]     })
[17:28:00.871]     if (TRUE) {
[17:28:00.871]         base::sink(type = "output", split = FALSE)
[17:28:00.871]         if (TRUE) {
[17:28:00.871]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:00.871]         }
[17:28:00.871]         else {
[17:28:00.871]             ...future.result["stdout"] <- base::list(NULL)
[17:28:00.871]         }
[17:28:00.871]         base::close(...future.stdout)
[17:28:00.871]         ...future.stdout <- NULL
[17:28:00.871]     }
[17:28:00.871]     ...future.result$conditions <- ...future.conditions
[17:28:00.871]     ...future.result$finished <- base::Sys.time()
[17:28:00.871]     ...future.result
[17:28:00.871] }
[17:28:00.876] assign_globals() ...
[17:28:00.877] List of 2
[17:28:00.877]  $ x   : list()
[17:28:00.877]  $ name: chr "a"
[17:28:00.877]  - attr(*, "where")=List of 2
[17:28:00.877]   ..$ x   :<environment: R_EmptyEnv> 
[17:28:00.877]   ..$ name:<environment: R_EmptyEnv> 
[17:28:00.877]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[17:28:00.877]  - attr(*, "resolved")= logi TRUE
[17:28:00.877]  - attr(*, "total_size")= int 71
[17:28:00.877]  - attr(*, "already-done")= logi TRUE
[17:28:00.882] - copied 'x' to environment
[17:28:00.882] - copied 'name' to environment
[17:28:00.882] assign_globals() ... done
[17:28:00.883] plan(): Setting new future strategy stack:
[17:28:00.883] List of future strategies:
[17:28:00.883] 1. sequential:
[17:28:00.883]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:00.883]    - tweaked: FALSE
[17:28:00.883]    - call: NULL
[17:28:00.884] plan(): nbrOfWorkers() = 1
[17:28:00.886] plan(): Setting new future strategy stack:
[17:28:00.886] List of future strategies:
[17:28:00.886] 1. sequential:
[17:28:00.886]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:00.886]    - tweaked: FALSE
[17:28:00.886]    - call: plan(strategy)
[17:28:00.887] plan(): nbrOfWorkers() = 1
[17:28:00.888] SequentialFuture started (and completed)
[17:28:00.888] - Launch lazy future ... done
[17:28:00.889] run() for 'SequentialFuture' ... done
$a
[1] 1

Testing with 1 cores ... DONE
Testing with 2 cores ...
availableCores(): 2
- plan('multisession') ...
[17:28:00.901] plan(): Setting new future strategy stack:
[17:28:00.901] List of future strategies:
[17:28:00.901] 1. multisession:
[17:28:00.901]    - args: function (..., workers = availableCores(), lazy = FALSE, rscript_libs = .libPaths(), envir = parent.frame())
[17:28:00.901]    - tweaked: FALSE
[17:28:00.901]    - call: plan(strategy)
[17:28:00.902] plan(): plan_init() of 'multisession', 'cluster', 'multiprocess', 'future', 'function' ...
[17:28:00.902] multisession:
[17:28:00.902] - args: function (..., workers = availableCores(), lazy = FALSE, rscript_libs = .libPaths(), envir = parent.frame())
[17:28:00.902] - tweaked: FALSE
[17:28:00.902] - call: plan(strategy)
Warning in getGlobalsAndPackages(expr, envir = envir, tweak = tweakExpression,  :
  R option 'future.globals.resolve' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'TRUE'
[17:28:00.908] getGlobalsAndPackages() ...
Warning in getGlobalsAndPackages(expr, envir = envir, tweak = tweakExpression,  :
  R option 'future.globals.onMissing' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'error'
[17:28:00.911] Not searching for globals
[17:28:00.912] - globals: [0] <none>
[17:28:00.912] getGlobalsAndPackages() ... DONE
[17:28:00.913] [local output] makeClusterPSOCK() ...
[17:28:00.963] [local output] Workers: [n = 2] 'localhost', 'localhost'
[17:28:00.969] [local output] Base port: 30923
[17:28:00.970] [local output] Getting setup options for 2 cluster nodes ...
[17:28:00.970] [local output]  - Node #1 of 2 ...
[17:28:00.971] [local output] localMachine=TRUE => revtunnel=FALSE

[17:28:00.973] Testing if worker's PID can be inferred: '"D:/RCompile/recent/R/bin/x64/Rscript" -e "try(suppressWarnings(cat(Sys.getpid(),file=\"D:/temp/RtmpusWl1W/worker.rank=1.parallelly.parent=164712.283688223f8e.pid\")), silent = TRUE)" -e "file.exists(\"D:/temp/RtmpusWl1W/worker.rank=1.parallelly.parent=164712.283688223f8e.pid\")"'
[17:28:01.424] - Possible to infer worker's PID: TRUE
[17:28:01.425] [local output] Rscript port: 30923

[17:28:01.426] [local output]  - Node #2 of 2 ...
[17:28:01.426] [local output] localMachine=TRUE => revtunnel=FALSE

[17:28:01.428] [local output] Rscript port: 30923

[17:28:01.429] [local output] Getting setup options for 2 cluster nodes ... done
[17:28:01.429] [local output]  - Parallel setup requested for some PSOCK nodes
[17:28:01.430] [local output] Setting up PSOCK nodes in parallel
[17:28:01.430] List of 36
[17:28:01.430]  $ worker          : chr "localhost"
[17:28:01.430]   ..- attr(*, "localhost")= logi TRUE
[17:28:01.430]  $ master          : chr "localhost"
[17:28:01.430]  $ port            : int 30923
[17:28:01.430]  $ connectTimeout  : num 120
[17:28:01.430]  $ timeout         : num 120
[17:28:01.430]  $ rscript         : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\""
[17:28:01.430]  $ homogeneous     : logi TRUE
[17:28:01.430]  $ rscript_args    : chr "--default-packages=datasets,utils,grDevices,graphics,stats,methods -e \"#label=globals,subassignment.R:164712:C"| __truncated__
[17:28:01.430]  $ rscript_envs    : NULL
[17:28:01.430]  $ rscript_libs    : chr [1:2] "D:/temp/RtmpsXpk4j/RLIBS_1097c668d2fda" "D:/RCompile/recent/R/library"
[17:28:01.430]  $ rscript_startup : NULL
[17:28:01.430]  $ rscript_sh      : chr [1:2] "cmd" "cmd"
[17:28:01.430]  $ default_packages: chr [1:6] "datasets" "utils" "grDevices" "graphics" ...
[17:28:01.430]  $ methods         : logi TRUE
[17:28:01.430]  $ socketOptions   : chr "no-delay"
[17:28:01.430]  $ useXDR          : logi FALSE
[17:28:01.430]  $ outfile         : chr "/dev/null"
[17:28:01.430]  $ renice          : int NA
[17:28:01.430]  $ rshcmd          : NULL
[17:28:01.430]  $ user            : chr(0) 
[17:28:01.430]  $ revtunnel       : logi FALSE
[17:28:01.430]  $ rshlogfile      : NULL
[17:28:01.430]  $ rshopts         : chr(0) 
[17:28:01.430]  $ rank            : int 1
[17:28:01.430]  $ manual          : logi FALSE
[17:28:01.430]  $ dryrun          : logi FALSE
[17:28:01.430]  $ quiet           : logi FALSE
[17:28:01.430]  $ setup_strategy  : chr "parallel"
[17:28:01.430]  $ local_cmd       : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "| __truncated__
[17:28:01.430]  $ pidfile         : chr "D:/temp/RtmpusWl1W/worker.rank=1.parallelly.parent=164712.283688223f8e.pid"
[17:28:01.430]  $ rshcmd_label    : NULL
[17:28:01.430]  $ rsh_call        : NULL
[17:28:01.430]  $ cmd             : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "| __truncated__
[17:28:01.430]  $ localMachine    : logi TRUE
[17:28:01.430]  $ make_fcn        :function (worker = getOption2("parallelly.localhost.hostname", "localhost"), 
[17:28:01.430]     master = NULL, port, connectTimeout = getOption2("parallelly.makeNodePSOCK.connectTimeout", 
[17:28:01.430]         2 * 60), timeout = getOption2("parallelly.makeNodePSOCK.timeout", 
[17:28:01.430]         30 * 24 * 60 * 60), rscript = NULL, homogeneous = NULL, rscript_args = NULL, 
[17:28:01.430]     rscript_envs = NULL, rscript_libs = NULL, rscript_startup = NULL, rscript_sh = c("auto", 
[17:28:01.430]         "cmd", "sh", "none"), default_packages = c("datasets", "utils", 
[17:28:01.430]         "grDevices", "graphics", "stats", if (methods) "methods"), methods = TRUE, 
[17:28:01.430]     socketOptions = getOption2("parallelly.makeNodePSOCK.socketOptions", 
[17:28:01.430]         "no-delay"), useXDR = getOption2("parallelly.makeNodePSOCK.useXDR", 
[17:28:01.430]         FALSE), outfile = "/dev/null", renice = NA_integer_, rshcmd = getOption2("parallelly.makeNodePSOCK.rshcmd", 
[17:28:01.430]         NULL), user = NULL, revtunnel = NA, rshlogfile = NULL, rshopts = getOption2("parallelly.makeNodePSOCK.rshopts", 
[17:28:01.430]         NULL), rank = 1L, manual = FALSE, dryrun = FALSE, quiet = FALSE, 
[17:28:01.430]     setup_strategy = getOption2("parallelly.makeNodePSOCK.setup_strategy", 
[17:28:01.430]         "parallel"), action = c("launch", "options"), verbose = FALSE)  
[17:28:01.430]  $ arguments       :List of 28
[17:28:01.430]   ..$ worker          : chr "localhost"
[17:28:01.430]   ..$ master          : NULL
[17:28:01.430]   ..$ port            : int 30923
[17:28:01.430]   ..$ connectTimeout  : num 120
[17:28:01.430]   ..$ timeout         : num 120
[17:28:01.430]   ..$ rscript         : NULL
[17:28:01.430]   ..$ homogeneous     : NULL
[17:28:01.430]   ..$ rscript_args    : NULL
[17:28:01.430]   ..$ rscript_envs    : NULL
[17:28:01.430]   ..$ rscript_libs    : chr [1:2] "D:/temp/RtmpsXpk4j/RLIBS_1097c668d2fda" "D:/RCompile/recent/R/library"
[17:28:01.430]   ..$ rscript_startup : NULL
[17:28:01.430]   ..$ rscript_sh      : chr "auto"
[17:28:01.430]   ..$ default_packages: chr [1:6] "datasets" "utils" "grDevices" "graphics" ...
[17:28:01.430]   ..$ methods         : logi TRUE
[17:28:01.430]   ..$ socketOptions   : chr "no-delay"
[17:28:01.430]   ..$ useXDR          : logi FALSE
[17:28:01.430]   ..$ outfile         : chr "/dev/null"
[17:28:01.430]   ..$ renice          : int NA
[17:28:01.430]   ..$ rshcmd          : NULL
[17:28:01.430]   ..$ user            : NULL
[17:28:01.430]   ..$ revtunnel       : logi NA
[17:28:01.430]   ..$ rshlogfile      : NULL
[17:28:01.430]   ..$ rshopts         : NULL
[17:28:01.430]   ..$ rank            : int 1
[17:28:01.430]   ..$ manual          : logi FALSE
[17:28:01.430]   ..$ dryrun          : logi FALSE
[17:28:01.430]   ..$ quiet           : logi FALSE
[17:28:01.430]   ..$ setup_strategy  : chr "parallel"
[17:28:01.430]  - attr(*, "class")= chr [1:2] "makeNodePSOCKOptions" "makeNodeOptions"
[17:28:01.463] [local output] System call to launch all workers:
[17:28:01.463] [local output] "D:/RCompile/recent/R/bin/x64/Rscript" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "#label=globals,subassignment.R:164712:CRANWIN3:CRAN" -e "try(suppressWarnings(cat(Sys.getpid(),file=\"D:/temp/RtmpusWl1W/worker.rank=1.parallelly.parent=164712.283688223f8e.pid\")), silent = TRUE)" -e "options(socketOptions = \"no-delay\")" -e ".libPaths(c(\"D:/temp/RtmpsXpk4j/RLIBS_1097c668d2fda\",\"D:/RCompile/recent/R/library\"))" -e "workRSOCK <- tryCatch(parallel:::.workRSOCK, error=function(e) parallel:::.slaveRSOCK); workRSOCK()" MASTER=localhost PORT=30923 OUT=/dev/null TIMEOUT=120 XDR=FALSE SETUPTIMEOUT=120 SETUPSTRATEGY=parallel
[17:28:01.463] [local output] Starting PSOCK main server
[17:28:01.473] [local output] Workers launched
[17:28:01.474] [local output] Waiting for workers to connect back
[17:28:01.474]  - [local output] 0 workers out of 2 ready
[17:28:01.693]  - [local output] 0 workers out of 2 ready
[17:28:01.693]  - [local output] 1 workers out of 2 ready
[17:28:01.731]  - [local output] 1 workers out of 2 ready
[17:28:01.731]  - [local output] 2 workers out of 2 ready
[17:28:01.731] [local output] Launching of 2 workers completed
[17:28:01.732] [local output] Number of nodes in cluster: 2
[17:28:01.732] [local output] Collecting session information from 2 workers
[17:28:01.734] [local output]  - Worker #1 of 2
[17:28:01.735] [local output]  - Worker #2 of 2
[17:28:01.735] [local output] makeClusterPSOCK() ... done
[17:28:01.754] Packages needed by the future expression (n = 0): <none>
[17:28:01.754] Packages needed by future strategies (n = 0): <none>
[17:28:01.755] {
[17:28:01.755]     {
[17:28:01.755]         {
[17:28:01.755]             ...future.startTime <- base::Sys.time()
[17:28:01.755]             {
[17:28:01.755]                 {
[17:28:01.755]                   {
[17:28:01.755]                     {
[17:28:01.755]                       base::local({
[17:28:01.755]                         has_future <- base::requireNamespace("future", 
[17:28:01.755]                           quietly = TRUE)
[17:28:01.755]                         if (has_future) {
[17:28:01.755]                           ns <- base::getNamespace("future")
[17:28:01.755]                           version <- ns[[".package"]][["version"]]
[17:28:01.755]                           if (is.null(version)) 
[17:28:01.755]                             version <- utils::packageVersion("future")
[17:28:01.755]                         }
[17:28:01.755]                         else {
[17:28:01.755]                           version <- NULL
[17:28:01.755]                         }
[17:28:01.755]                         if (!has_future || version < "1.8.0") {
[17:28:01.755]                           info <- base::c(r_version = base::gsub("R version ", 
[17:28:01.755]                             "", base::R.version$version.string), 
[17:28:01.755]                             platform = base::sprintf("%s (%s-bit)", 
[17:28:01.755]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:01.755]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:01.755]                               "release", "version")], collapse = " "), 
[17:28:01.755]                             hostname = base::Sys.info()[["nodename"]])
[17:28:01.755]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:28:01.755]                             info)
[17:28:01.755]                           info <- base::paste(info, collapse = "; ")
[17:28:01.755]                           if (!has_future) {
[17:28:01.755]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:01.755]                               info)
[17:28:01.755]                           }
[17:28:01.755]                           else {
[17:28:01.755]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:01.755]                               info, version)
[17:28:01.755]                           }
[17:28:01.755]                           base::stop(msg)
[17:28:01.755]                         }
[17:28:01.755]                       })
[17:28:01.755]                     }
[17:28:01.755]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:28:01.755]                     base::options(mc.cores = 1L)
[17:28:01.755]                   }
[17:28:01.755]                   ...future.strategy.old <- future::plan("list")
[17:28:01.755]                   options(future.plan = NULL)
[17:28:01.755]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:01.755]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:01.755]                 }
[17:28:01.755]                 ...future.workdir <- getwd()
[17:28:01.755]             }
[17:28:01.755]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:01.755]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:01.755]         }
[17:28:01.755]         base::options(future.startup.script = FALSE, future.globals.onMissing = "error", 
[17:28:01.755]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:01.755]             future.globals.onMissing = "error", future.globals.onReference = NULL, 
[17:28:01.755]             future.globals.resolve = TRUE, future.resolve.recursive = NULL, 
[17:28:01.755]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:28:01.755]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:01.755]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:01.755]             base::names(...future.oldOptions))
[17:28:01.755]     }
[17:28:01.755]     if (FALSE) {
[17:28:01.755]     }
[17:28:01.755]     else {
[17:28:01.755]         if (TRUE) {
[17:28:01.755]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:01.755]                 open = "w")
[17:28:01.755]         }
[17:28:01.755]         else {
[17:28:01.755]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:01.755]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:01.755]         }
[17:28:01.755]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:01.755]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:01.755]             base::sink(type = "output", split = FALSE)
[17:28:01.755]             base::close(...future.stdout)
[17:28:01.755]         }, add = TRUE)
[17:28:01.755]     }
[17:28:01.755]     ...future.frame <- base::sys.nframe()
[17:28:01.755]     ...future.conditions <- base::list()
[17:28:01.755]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:01.755]     if (FALSE) {
[17:28:01.755]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:01.755]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:01.755]     }
[17:28:01.755]     ...future.result <- base::tryCatch({
[17:28:01.755]         base::withCallingHandlers({
[17:28:01.755]             ...future.value <- base::withVisible(base::local({
[17:28:01.755]                 ...future.makeSendCondition <- base::local({
[17:28:01.755]                   sendCondition <- NULL
[17:28:01.755]                   function(frame = 1L) {
[17:28:01.755]                     if (is.function(sendCondition)) 
[17:28:01.755]                       return(sendCondition)
[17:28:01.755]                     ns <- getNamespace("parallel")
[17:28:01.755]                     if (exists("sendData", mode = "function", 
[17:28:01.755]                       envir = ns)) {
[17:28:01.755]                       parallel_sendData <- get("sendData", mode = "function", 
[17:28:01.755]                         envir = ns)
[17:28:01.755]                       envir <- sys.frame(frame)
[17:28:01.755]                       master <- NULL
[17:28:01.755]                       while (!identical(envir, .GlobalEnv) && 
[17:28:01.755]                         !identical(envir, emptyenv())) {
[17:28:01.755]                         if (exists("master", mode = "list", envir = envir, 
[17:28:01.755]                           inherits = FALSE)) {
[17:28:01.755]                           master <- get("master", mode = "list", 
[17:28:01.755]                             envir = envir, inherits = FALSE)
[17:28:01.755]                           if (inherits(master, c("SOCKnode", 
[17:28:01.755]                             "SOCK0node"))) {
[17:28:01.755]                             sendCondition <<- function(cond) {
[17:28:01.755]                               data <- list(type = "VALUE", value = cond, 
[17:28:01.755]                                 success = TRUE)
[17:28:01.755]                               parallel_sendData(master, data)
[17:28:01.755]                             }
[17:28:01.755]                             return(sendCondition)
[17:28:01.755]                           }
[17:28:01.755]                         }
[17:28:01.755]                         frame <- frame + 1L
[17:28:01.755]                         envir <- sys.frame(frame)
[17:28:01.755]                       }
[17:28:01.755]                     }
[17:28:01.755]                     sendCondition <<- function(cond) NULL
[17:28:01.755]                   }
[17:28:01.755]                 })
[17:28:01.755]                 withCallingHandlers({
[17:28:01.755]                   NA
[17:28:01.755]                 }, immediateCondition = function(cond) {
[17:28:01.755]                   sendCondition <- ...future.makeSendCondition()
[17:28:01.755]                   sendCondition(cond)
[17:28:01.755]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:01.755]                   {
[17:28:01.755]                     inherits <- base::inherits
[17:28:01.755]                     invokeRestart <- base::invokeRestart
[17:28:01.755]                     is.null <- base::is.null
[17:28:01.755]                     muffled <- FALSE
[17:28:01.755]                     if (inherits(cond, "message")) {
[17:28:01.755]                       muffled <- grepl(pattern, "muffleMessage")
[17:28:01.755]                       if (muffled) 
[17:28:01.755]                         invokeRestart("muffleMessage")
[17:28:01.755]                     }
[17:28:01.755]                     else if (inherits(cond, "warning")) {
[17:28:01.755]                       muffled <- grepl(pattern, "muffleWarning")
[17:28:01.755]                       if (muffled) 
[17:28:01.755]                         invokeRestart("muffleWarning")
[17:28:01.755]                     }
[17:28:01.755]                     else if (inherits(cond, "condition")) {
[17:28:01.755]                       if (!is.null(pattern)) {
[17:28:01.755]                         computeRestarts <- base::computeRestarts
[17:28:01.755]                         grepl <- base::grepl
[17:28:01.755]                         restarts <- computeRestarts(cond)
[17:28:01.755]                         for (restart in restarts) {
[17:28:01.755]                           name <- restart$name
[17:28:01.755]                           if (is.null(name)) 
[17:28:01.755]                             next
[17:28:01.755]                           if (!grepl(pattern, name)) 
[17:28:01.755]                             next
[17:28:01.755]                           invokeRestart(restart)
[17:28:01.755]                           muffled <- TRUE
[17:28:01.755]                           break
[17:28:01.755]                         }
[17:28:01.755]                       }
[17:28:01.755]                     }
[17:28:01.755]                     invisible(muffled)
[17:28:01.755]                   }
[17:28:01.755]                   muffleCondition(cond)
[17:28:01.755]                 })
[17:28:01.755]             }))
[17:28:01.755]             future::FutureResult(value = ...future.value$value, 
[17:28:01.755]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:01.755]                   ...future.rng), globalenv = if (FALSE) 
[17:28:01.755]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:01.755]                     ...future.globalenv.names))
[17:28:01.755]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:01.755]         }, condition = base::local({
[17:28:01.755]             c <- base::c
[17:28:01.755]             inherits <- base::inherits
[17:28:01.755]             invokeRestart <- base::invokeRestart
[17:28:01.755]             length <- base::length
[17:28:01.755]             list <- base::list
[17:28:01.755]             seq.int <- base::seq.int
[17:28:01.755]             signalCondition <- base::signalCondition
[17:28:01.755]             sys.calls <- base::sys.calls
[17:28:01.755]             `[[` <- base::`[[`
[17:28:01.755]             `+` <- base::`+`
[17:28:01.755]             `<<-` <- base::`<<-`
[17:28:01.755]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:01.755]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:01.755]                   3L)]
[17:28:01.755]             }
[17:28:01.755]             function(cond) {
[17:28:01.755]                 is_error <- inherits(cond, "error")
[17:28:01.755]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:01.755]                   NULL)
[17:28:01.755]                 if (is_error) {
[17:28:01.755]                   sessionInformation <- function() {
[17:28:01.755]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:01.755]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:01.755]                       search = base::search(), system = base::Sys.info())
[17:28:01.755]                   }
[17:28:01.755]                   ...future.conditions[[length(...future.conditions) + 
[17:28:01.755]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:01.755]                     cond$call), session = sessionInformation(), 
[17:28:01.755]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:01.755]                   signalCondition(cond)
[17:28:01.755]                 }
[17:28:01.755]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:01.755]                 "immediateCondition"))) {
[17:28:01.755]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:01.755]                   ...future.conditions[[length(...future.conditions) + 
[17:28:01.755]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:01.755]                   if (TRUE && !signal) {
[17:28:01.755]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:01.755]                     {
[17:28:01.755]                       inherits <- base::inherits
[17:28:01.755]                       invokeRestart <- base::invokeRestart
[17:28:01.755]                       is.null <- base::is.null
[17:28:01.755]                       muffled <- FALSE
[17:28:01.755]                       if (inherits(cond, "message")) {
[17:28:01.755]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:01.755]                         if (muffled) 
[17:28:01.755]                           invokeRestart("muffleMessage")
[17:28:01.755]                       }
[17:28:01.755]                       else if (inherits(cond, "warning")) {
[17:28:01.755]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:01.755]                         if (muffled) 
[17:28:01.755]                           invokeRestart("muffleWarning")
[17:28:01.755]                       }
[17:28:01.755]                       else if (inherits(cond, "condition")) {
[17:28:01.755]                         if (!is.null(pattern)) {
[17:28:01.755]                           computeRestarts <- base::computeRestarts
[17:28:01.755]                           grepl <- base::grepl
[17:28:01.755]                           restarts <- computeRestarts(cond)
[17:28:01.755]                           for (restart in restarts) {
[17:28:01.755]                             name <- restart$name
[17:28:01.755]                             if (is.null(name)) 
[17:28:01.755]                               next
[17:28:01.755]                             if (!grepl(pattern, name)) 
[17:28:01.755]                               next
[17:28:01.755]                             invokeRestart(restart)
[17:28:01.755]                             muffled <- TRUE
[17:28:01.755]                             break
[17:28:01.755]                           }
[17:28:01.755]                         }
[17:28:01.755]                       }
[17:28:01.755]                       invisible(muffled)
[17:28:01.755]                     }
[17:28:01.755]                     muffleCondition(cond, pattern = "^muffle")
[17:28:01.755]                   }
[17:28:01.755]                 }
[17:28:01.755]                 else {
[17:28:01.755]                   if (TRUE) {
[17:28:01.755]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:01.755]                     {
[17:28:01.755]                       inherits <- base::inherits
[17:28:01.755]                       invokeRestart <- base::invokeRestart
[17:28:01.755]                       is.null <- base::is.null
[17:28:01.755]                       muffled <- FALSE
[17:28:01.755]                       if (inherits(cond, "message")) {
[17:28:01.755]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:01.755]                         if (muffled) 
[17:28:01.755]                           invokeRestart("muffleMessage")
[17:28:01.755]                       }
[17:28:01.755]                       else if (inherits(cond, "warning")) {
[17:28:01.755]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:01.755]                         if (muffled) 
[17:28:01.755]                           invokeRestart("muffleWarning")
[17:28:01.755]                       }
[17:28:01.755]                       else if (inherits(cond, "condition")) {
[17:28:01.755]                         if (!is.null(pattern)) {
[17:28:01.755]                           computeRestarts <- base::computeRestarts
[17:28:01.755]                           grepl <- base::grepl
[17:28:01.755]                           restarts <- computeRestarts(cond)
[17:28:01.755]                           for (restart in restarts) {
[17:28:01.755]                             name <- restart$name
[17:28:01.755]                             if (is.null(name)) 
[17:28:01.755]                               next
[17:28:01.755]                             if (!grepl(pattern, name)) 
[17:28:01.755]                               next
[17:28:01.755]                             invokeRestart(restart)
[17:28:01.755]                             muffled <- TRUE
[17:28:01.755]                             break
[17:28:01.755]                           }
[17:28:01.755]                         }
[17:28:01.755]                       }
[17:28:01.755]                       invisible(muffled)
[17:28:01.755]                     }
[17:28:01.755]                     muffleCondition(cond, pattern = "^muffle")
[17:28:01.755]                   }
[17:28:01.755]                 }
[17:28:01.755]             }
[17:28:01.755]         }))
[17:28:01.755]     }, error = function(ex) {
[17:28:01.755]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:01.755]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:01.755]                 ...future.rng), started = ...future.startTime, 
[17:28:01.755]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:01.755]             version = "1.8"), class = "FutureResult")
[17:28:01.755]     }, finally = {
[17:28:01.755]         if (!identical(...future.workdir, getwd())) 
[17:28:01.755]             setwd(...future.workdir)
[17:28:01.755]         {
[17:28:01.755]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:01.755]                 ...future.oldOptions$nwarnings <- NULL
[17:28:01.755]             }
[17:28:01.755]             base::options(...future.oldOptions)
[17:28:01.755]             if (.Platform$OS.type == "windows") {
[17:28:01.755]                 old_names <- names(...future.oldEnvVars)
[17:28:01.755]                 envs <- base::Sys.getenv()
[17:28:01.755]                 names <- names(envs)
[17:28:01.755]                 common <- intersect(names, old_names)
[17:28:01.755]                 added <- setdiff(names, old_names)
[17:28:01.755]                 removed <- setdiff(old_names, names)
[17:28:01.755]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:01.755]                   envs[common]]
[17:28:01.755]                 NAMES <- toupper(changed)
[17:28:01.755]                 args <- list()
[17:28:01.755]                 for (kk in seq_along(NAMES)) {
[17:28:01.755]                   name <- changed[[kk]]
[17:28:01.755]                   NAME <- NAMES[[kk]]
[17:28:01.755]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:01.755]                     next
[17:28:01.755]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:01.755]                 }
[17:28:01.755]                 NAMES <- toupper(added)
[17:28:01.755]                 for (kk in seq_along(NAMES)) {
[17:28:01.755]                   name <- added[[kk]]
[17:28:01.755]                   NAME <- NAMES[[kk]]
[17:28:01.755]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:01.755]                     next
[17:28:01.755]                   args[[name]] <- ""
[17:28:01.755]                 }
[17:28:01.755]                 NAMES <- toupper(removed)
[17:28:01.755]                 for (kk in seq_along(NAMES)) {
[17:28:01.755]                   name <- removed[[kk]]
[17:28:01.755]                   NAME <- NAMES[[kk]]
[17:28:01.755]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:01.755]                     next
[17:28:01.755]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:01.755]                 }
[17:28:01.755]                 if (length(args) > 0) 
[17:28:01.755]                   base::do.call(base::Sys.setenv, args = args)
[17:28:01.755]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:01.755]             }
[17:28:01.755]             else {
[17:28:01.755]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:01.755]             }
[17:28:01.755]             {
[17:28:01.755]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:01.755]                   0L) {
[17:28:01.755]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:01.755]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:01.755]                   base::options(opts)
[17:28:01.755]                 }
[17:28:01.755]                 {
[17:28:01.755]                   {
[17:28:01.755]                     base::options(mc.cores = ...future.mc.cores.old)
[17:28:01.755]                     NULL
[17:28:01.755]                   }
[17:28:01.755]                   options(future.plan = NULL)
[17:28:01.755]                   if (is.na(NA_character_)) 
[17:28:01.755]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:01.755]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:01.755]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:01.755]                     .init = FALSE)
[17:28:01.755]                 }
[17:28:01.755]             }
[17:28:01.755]         }
[17:28:01.755]     })
[17:28:01.755]     if (TRUE) {
[17:28:01.755]         base::sink(type = "output", split = FALSE)
[17:28:01.755]         if (TRUE) {
[17:28:01.755]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:01.755]         }
[17:28:01.755]         else {
[17:28:01.755]             ...future.result["stdout"] <- base::list(NULL)
[17:28:01.755]         }
[17:28:01.755]         base::close(...future.stdout)
[17:28:01.755]         ...future.stdout <- NULL
[17:28:01.755]     }
[17:28:01.755]     ...future.result$conditions <- ...future.conditions
[17:28:01.755]     ...future.result$finished <- base::Sys.time()
[17:28:01.755]     ...future.result
[17:28:01.755] }
[17:28:01.894] MultisessionFuture started
[17:28:01.895] result() for ClusterFuture ...
[17:28:01.896] receiveMessageFromWorker() for ClusterFuture ...
[17:28:01.897] - Validating connection of MultisessionFuture
[17:28:01.981] - received message: FutureResult
[17:28:01.981] - Received FutureResult
[17:28:01.987] - Erased future from FutureRegistry
[17:28:01.987] result() for ClusterFuture ...
[17:28:01.987] - result already collected: FutureResult
[17:28:01.988] result() for ClusterFuture ... done
[17:28:01.988] receiveMessageFromWorker() for ClusterFuture ... done
[17:28:01.988] result() for ClusterFuture ... done
[17:28:01.988] result() for ClusterFuture ...
[17:28:01.989] - result already collected: FutureResult
[17:28:01.989] result() for ClusterFuture ... done
[17:28:01.989] plan(): plan_init() of 'multisession', 'cluster', 'multiprocess', 'future', 'function' ... DONE
[17:28:01.993] plan(): nbrOfWorkers() = 2
Warning in getGlobalsAndPackages(expr, envir = envir, tweak = tweakExpression,  :
  R option 'future.globals.resolve' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'TRUE'
[17:28:01.994] getGlobalsAndPackages() ...
Warning in getGlobalsAndPackages(expr, envir = envir, tweak = tweakExpression,  :
  R option 'future.globals.onMissing' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'error'
[17:28:01.994] Searching for globals...
[17:28:01.998] - globals found: [5] '{', 'x', '<-', '$', '$<-'
[17:28:01.999] Searching for globals ... DONE
[17:28:01.999] Resolving globals: TRUE
[17:28:01.999] Resolving any globals that are futures ...
[17:28:01.999] - globals: [5] '{', 'x', '<-', '$', '$<-'
[17:28:01.999] Resolving any globals that are futures ... DONE
[17:28:02.000] Resolving futures part of globals (recursively) ...
[17:28:02.000] resolve() on list ...
[17:28:02.001]  recursive: 99
[17:28:02.001]  length: 1
[17:28:02.001]  elements: 'x'
[17:28:02.001]  length: 0 (resolved future 1)
[17:28:02.002] resolve() on list ... DONE
[17:28:02.002] - globals: [1] 'x'
[17:28:02.002] Resolving futures part of globals (recursively) ... DONE
[17:28:02.002] The total size of the 1 globals is 31 bytes (31 bytes)
[17:28:02.003] The total size of the 1 globals exported for future expression ('{; x$a <- 1; x; }') is 31 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (31 bytes of class 'list')
[17:28:02.004] - globals: [1] 'x'
[17:28:02.004] 
[17:28:02.004] getGlobalsAndPackages() ... DONE
[17:28:02.005] run() for 'Future' ...
[17:28:02.005] - state: 'created'
[17:28:02.005] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:28:02.024] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:28:02.024] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:28:02.025]   - Field: 'node'
[17:28:02.025]   - Field: 'label'
[17:28:02.025]   - Field: 'local'
[17:28:02.025]   - Field: 'owner'
[17:28:02.026]   - Field: 'envir'
[17:28:02.026]   - Field: 'workers'
[17:28:02.026]   - Field: 'packages'
[17:28:02.027]   - Field: 'gc'
[17:28:02.027]   - Field: 'conditions'
[17:28:02.027]   - Field: 'persistent'
[17:28:02.028]   - Field: 'expr'
[17:28:02.028]   - Field: 'uuid'
[17:28:02.028]   - Field: 'seed'
[17:28:02.029]   - Field: 'version'
[17:28:02.029]   - Field: 'result'
[17:28:02.029]   - Field: 'asynchronous'
[17:28:02.030]   - Field: 'calls'
[17:28:02.030]   - Field: 'globals'
[17:28:02.030]   - Field: 'stdout'
[17:28:02.031]   - Field: 'earlySignal'
[17:28:02.031]   - Field: 'lazy'
[17:28:02.031]   - Field: 'state'
[17:28:02.032] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:28:02.032] - Launch lazy future ...
[17:28:02.033] Packages needed by the future expression (n = 0): <none>
[17:28:02.033] Packages needed by future strategies (n = 0): <none>
[17:28:02.034] {
[17:28:02.034]     {
[17:28:02.034]         {
[17:28:02.034]             ...future.startTime <- base::Sys.time()
[17:28:02.034]             {
[17:28:02.034]                 {
[17:28:02.034]                   {
[17:28:02.034]                     {
[17:28:02.034]                       base::local({
[17:28:02.034]                         has_future <- base::requireNamespace("future", 
[17:28:02.034]                           quietly = TRUE)
[17:28:02.034]                         if (has_future) {
[17:28:02.034]                           ns <- base::getNamespace("future")
[17:28:02.034]                           version <- ns[[".package"]][["version"]]
[17:28:02.034]                           if (is.null(version)) 
[17:28:02.034]                             version <- utils::packageVersion("future")
[17:28:02.034]                         }
[17:28:02.034]                         else {
[17:28:02.034]                           version <- NULL
[17:28:02.034]                         }
[17:28:02.034]                         if (!has_future || version < "1.8.0") {
[17:28:02.034]                           info <- base::c(r_version = base::gsub("R version ", 
[17:28:02.034]                             "", base::R.version$version.string), 
[17:28:02.034]                             platform = base::sprintf("%s (%s-bit)", 
[17:28:02.034]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:02.034]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:02.034]                               "release", "version")], collapse = " "), 
[17:28:02.034]                             hostname = base::Sys.info()[["nodename"]])
[17:28:02.034]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:28:02.034]                             info)
[17:28:02.034]                           info <- base::paste(info, collapse = "; ")
[17:28:02.034]                           if (!has_future) {
[17:28:02.034]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:02.034]                               info)
[17:28:02.034]                           }
[17:28:02.034]                           else {
[17:28:02.034]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:02.034]                               info, version)
[17:28:02.034]                           }
[17:28:02.034]                           base::stop(msg)
[17:28:02.034]                         }
[17:28:02.034]                       })
[17:28:02.034]                     }
[17:28:02.034]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:28:02.034]                     base::options(mc.cores = 1L)
[17:28:02.034]                   }
[17:28:02.034]                   ...future.strategy.old <- future::plan("list")
[17:28:02.034]                   options(future.plan = NULL)
[17:28:02.034]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:02.034]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:02.034]                 }
[17:28:02.034]                 ...future.workdir <- getwd()
[17:28:02.034]             }
[17:28:02.034]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:02.034]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:02.034]         }
[17:28:02.034]         base::options(future.startup.script = FALSE, future.globals.onMissing = "error", 
[17:28:02.034]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:02.034]             future.globals.onMissing = "error", future.globals.onReference = NULL, 
[17:28:02.034]             future.globals.resolve = TRUE, future.resolve.recursive = NULL, 
[17:28:02.034]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:28:02.034]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:02.034]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:02.034]             base::names(...future.oldOptions))
[17:28:02.034]     }
[17:28:02.034]     if (FALSE) {
[17:28:02.034]     }
[17:28:02.034]     else {
[17:28:02.034]         if (TRUE) {
[17:28:02.034]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:02.034]                 open = "w")
[17:28:02.034]         }
[17:28:02.034]         else {
[17:28:02.034]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:02.034]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:02.034]         }
[17:28:02.034]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:02.034]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:02.034]             base::sink(type = "output", split = FALSE)
[17:28:02.034]             base::close(...future.stdout)
[17:28:02.034]         }, add = TRUE)
[17:28:02.034]     }
[17:28:02.034]     ...future.frame <- base::sys.nframe()
[17:28:02.034]     ...future.conditions <- base::list()
[17:28:02.034]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:02.034]     if (FALSE) {
[17:28:02.034]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:02.034]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:02.034]     }
[17:28:02.034]     ...future.result <- base::tryCatch({
[17:28:02.034]         base::withCallingHandlers({
[17:28:02.034]             ...future.value <- base::withVisible(base::local({
[17:28:02.034]                 ...future.makeSendCondition <- base::local({
[17:28:02.034]                   sendCondition <- NULL
[17:28:02.034]                   function(frame = 1L) {
[17:28:02.034]                     if (is.function(sendCondition)) 
[17:28:02.034]                       return(sendCondition)
[17:28:02.034]                     ns <- getNamespace("parallel")
[17:28:02.034]                     if (exists("sendData", mode = "function", 
[17:28:02.034]                       envir = ns)) {
[17:28:02.034]                       parallel_sendData <- get("sendData", mode = "function", 
[17:28:02.034]                         envir = ns)
[17:28:02.034]                       envir <- sys.frame(frame)
[17:28:02.034]                       master <- NULL
[17:28:02.034]                       while (!identical(envir, .GlobalEnv) && 
[17:28:02.034]                         !identical(envir, emptyenv())) {
[17:28:02.034]                         if (exists("master", mode = "list", envir = envir, 
[17:28:02.034]                           inherits = FALSE)) {
[17:28:02.034]                           master <- get("master", mode = "list", 
[17:28:02.034]                             envir = envir, inherits = FALSE)
[17:28:02.034]                           if (inherits(master, c("SOCKnode", 
[17:28:02.034]                             "SOCK0node"))) {
[17:28:02.034]                             sendCondition <<- function(cond) {
[17:28:02.034]                               data <- list(type = "VALUE", value = cond, 
[17:28:02.034]                                 success = TRUE)
[17:28:02.034]                               parallel_sendData(master, data)
[17:28:02.034]                             }
[17:28:02.034]                             return(sendCondition)
[17:28:02.034]                           }
[17:28:02.034]                         }
[17:28:02.034]                         frame <- frame + 1L
[17:28:02.034]                         envir <- sys.frame(frame)
[17:28:02.034]                       }
[17:28:02.034]                     }
[17:28:02.034]                     sendCondition <<- function(cond) NULL
[17:28:02.034]                   }
[17:28:02.034]                 })
[17:28:02.034]                 withCallingHandlers({
[17:28:02.034]                   {
[17:28:02.034]                     x$a <- 1
[17:28:02.034]                     x
[17:28:02.034]                   }
[17:28:02.034]                 }, immediateCondition = function(cond) {
[17:28:02.034]                   sendCondition <- ...future.makeSendCondition()
[17:28:02.034]                   sendCondition(cond)
[17:28:02.034]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:02.034]                   {
[17:28:02.034]                     inherits <- base::inherits
[17:28:02.034]                     invokeRestart <- base::invokeRestart
[17:28:02.034]                     is.null <- base::is.null
[17:28:02.034]                     muffled <- FALSE
[17:28:02.034]                     if (inherits(cond, "message")) {
[17:28:02.034]                       muffled <- grepl(pattern, "muffleMessage")
[17:28:02.034]                       if (muffled) 
[17:28:02.034]                         invokeRestart("muffleMessage")
[17:28:02.034]                     }
[17:28:02.034]                     else if (inherits(cond, "warning")) {
[17:28:02.034]                       muffled <- grepl(pattern, "muffleWarning")
[17:28:02.034]                       if (muffled) 
[17:28:02.034]                         invokeRestart("muffleWarning")
[17:28:02.034]                     }
[17:28:02.034]                     else if (inherits(cond, "condition")) {
[17:28:02.034]                       if (!is.null(pattern)) {
[17:28:02.034]                         computeRestarts <- base::computeRestarts
[17:28:02.034]                         grepl <- base::grepl
[17:28:02.034]                         restarts <- computeRestarts(cond)
[17:28:02.034]                         for (restart in restarts) {
[17:28:02.034]                           name <- restart$name
[17:28:02.034]                           if (is.null(name)) 
[17:28:02.034]                             next
[17:28:02.034]                           if (!grepl(pattern, name)) 
[17:28:02.034]                             next
[17:28:02.034]                           invokeRestart(restart)
[17:28:02.034]                           muffled <- TRUE
[17:28:02.034]                           break
[17:28:02.034]                         }
[17:28:02.034]                       }
[17:28:02.034]                     }
[17:28:02.034]                     invisible(muffled)
[17:28:02.034]                   }
[17:28:02.034]                   muffleCondition(cond)
[17:28:02.034]                 })
[17:28:02.034]             }))
[17:28:02.034]             future::FutureResult(value = ...future.value$value, 
[17:28:02.034]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:02.034]                   ...future.rng), globalenv = if (FALSE) 
[17:28:02.034]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:02.034]                     ...future.globalenv.names))
[17:28:02.034]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:02.034]         }, condition = base::local({
[17:28:02.034]             c <- base::c
[17:28:02.034]             inherits <- base::inherits
[17:28:02.034]             invokeRestart <- base::invokeRestart
[17:28:02.034]             length <- base::length
[17:28:02.034]             list <- base::list
[17:28:02.034]             seq.int <- base::seq.int
[17:28:02.034]             signalCondition <- base::signalCondition
[17:28:02.034]             sys.calls <- base::sys.calls
[17:28:02.034]             `[[` <- base::`[[`
[17:28:02.034]             `+` <- base::`+`
[17:28:02.034]             `<<-` <- base::`<<-`
[17:28:02.034]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:02.034]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:02.034]                   3L)]
[17:28:02.034]             }
[17:28:02.034]             function(cond) {
[17:28:02.034]                 is_error <- inherits(cond, "error")
[17:28:02.034]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:02.034]                   NULL)
[17:28:02.034]                 if (is_error) {
[17:28:02.034]                   sessionInformation <- function() {
[17:28:02.034]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:02.034]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:02.034]                       search = base::search(), system = base::Sys.info())
[17:28:02.034]                   }
[17:28:02.034]                   ...future.conditions[[length(...future.conditions) + 
[17:28:02.034]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:02.034]                     cond$call), session = sessionInformation(), 
[17:28:02.034]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:02.034]                   signalCondition(cond)
[17:28:02.034]                 }
[17:28:02.034]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:02.034]                 "immediateCondition"))) {
[17:28:02.034]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:02.034]                   ...future.conditions[[length(...future.conditions) + 
[17:28:02.034]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:02.034]                   if (TRUE && !signal) {
[17:28:02.034]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:02.034]                     {
[17:28:02.034]                       inherits <- base::inherits
[17:28:02.034]                       invokeRestart <- base::invokeRestart
[17:28:02.034]                       is.null <- base::is.null
[17:28:02.034]                       muffled <- FALSE
[17:28:02.034]                       if (inherits(cond, "message")) {
[17:28:02.034]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:02.034]                         if (muffled) 
[17:28:02.034]                           invokeRestart("muffleMessage")
[17:28:02.034]                       }
[17:28:02.034]                       else if (inherits(cond, "warning")) {
[17:28:02.034]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:02.034]                         if (muffled) 
[17:28:02.034]                           invokeRestart("muffleWarning")
[17:28:02.034]                       }
[17:28:02.034]                       else if (inherits(cond, "condition")) {
[17:28:02.034]                         if (!is.null(pattern)) {
[17:28:02.034]                           computeRestarts <- base::computeRestarts
[17:28:02.034]                           grepl <- base::grepl
[17:28:02.034]                           restarts <- computeRestarts(cond)
[17:28:02.034]                           for (restart in restarts) {
[17:28:02.034]                             name <- restart$name
[17:28:02.034]                             if (is.null(name)) 
[17:28:02.034]                               next
[17:28:02.034]                             if (!grepl(pattern, name)) 
[17:28:02.034]                               next
[17:28:02.034]                             invokeRestart(restart)
[17:28:02.034]                             muffled <- TRUE
[17:28:02.034]                             break
[17:28:02.034]                           }
[17:28:02.034]                         }
[17:28:02.034]                       }
[17:28:02.034]                       invisible(muffled)
[17:28:02.034]                     }
[17:28:02.034]                     muffleCondition(cond, pattern = "^muffle")
[17:28:02.034]                   }
[17:28:02.034]                 }
[17:28:02.034]                 else {
[17:28:02.034]                   if (TRUE) {
[17:28:02.034]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:02.034]                     {
[17:28:02.034]                       inherits <- base::inherits
[17:28:02.034]                       invokeRestart <- base::invokeRestart
[17:28:02.034]                       is.null <- base::is.null
[17:28:02.034]                       muffled <- FALSE
[17:28:02.034]                       if (inherits(cond, "message")) {
[17:28:02.034]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:02.034]                         if (muffled) 
[17:28:02.034]                           invokeRestart("muffleMessage")
[17:28:02.034]                       }
[17:28:02.034]                       else if (inherits(cond, "warning")) {
[17:28:02.034]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:02.034]                         if (muffled) 
[17:28:02.034]                           invokeRestart("muffleWarning")
[17:28:02.034]                       }
[17:28:02.034]                       else if (inherits(cond, "condition")) {
[17:28:02.034]                         if (!is.null(pattern)) {
[17:28:02.034]                           computeRestarts <- base::computeRestarts
[17:28:02.034]                           grepl <- base::grepl
[17:28:02.034]                           restarts <- computeRestarts(cond)
[17:28:02.034]                           for (restart in restarts) {
[17:28:02.034]                             name <- restart$name
[17:28:02.034]                             if (is.null(name)) 
[17:28:02.034]                               next
[17:28:02.034]                             if (!grepl(pattern, name)) 
[17:28:02.034]                               next
[17:28:02.034]                             invokeRestart(restart)
[17:28:02.034]                             muffled <- TRUE
[17:28:02.034]                             break
[17:28:02.034]                           }
[17:28:02.034]                         }
[17:28:02.034]                       }
[17:28:02.034]                       invisible(muffled)
[17:28:02.034]                     }
[17:28:02.034]                     muffleCondition(cond, pattern = "^muffle")
[17:28:02.034]                   }
[17:28:02.034]                 }
[17:28:02.034]             }
[17:28:02.034]         }))
[17:28:02.034]     }, error = function(ex) {
[17:28:02.034]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:02.034]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:02.034]                 ...future.rng), started = ...future.startTime, 
[17:28:02.034]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:02.034]             version = "1.8"), class = "FutureResult")
[17:28:02.034]     }, finally = {
[17:28:02.034]         if (!identical(...future.workdir, getwd())) 
[17:28:02.034]             setwd(...future.workdir)
[17:28:02.034]         {
[17:28:02.034]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:02.034]                 ...future.oldOptions$nwarnings <- NULL
[17:28:02.034]             }
[17:28:02.034]             base::options(...future.oldOptions)
[17:28:02.034]             if (.Platform$OS.type == "windows") {
[17:28:02.034]                 old_names <- names(...future.oldEnvVars)
[17:28:02.034]                 envs <- base::Sys.getenv()
[17:28:02.034]                 names <- names(envs)
[17:28:02.034]                 common <- intersect(names, old_names)
[17:28:02.034]                 added <- setdiff(names, old_names)
[17:28:02.034]                 removed <- setdiff(old_names, names)
[17:28:02.034]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:02.034]                   envs[common]]
[17:28:02.034]                 NAMES <- toupper(changed)
[17:28:02.034]                 args <- list()
[17:28:02.034]                 for (kk in seq_along(NAMES)) {
[17:28:02.034]                   name <- changed[[kk]]
[17:28:02.034]                   NAME <- NAMES[[kk]]
[17:28:02.034]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:02.034]                     next
[17:28:02.034]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:02.034]                 }
[17:28:02.034]                 NAMES <- toupper(added)
[17:28:02.034]                 for (kk in seq_along(NAMES)) {
[17:28:02.034]                   name <- added[[kk]]
[17:28:02.034]                   NAME <- NAMES[[kk]]
[17:28:02.034]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:02.034]                     next
[17:28:02.034]                   args[[name]] <- ""
[17:28:02.034]                 }
[17:28:02.034]                 NAMES <- toupper(removed)
[17:28:02.034]                 for (kk in seq_along(NAMES)) {
[17:28:02.034]                   name <- removed[[kk]]
[17:28:02.034]                   NAME <- NAMES[[kk]]
[17:28:02.034]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:02.034]                     next
[17:28:02.034]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:02.034]                 }
[17:28:02.034]                 if (length(args) > 0) 
[17:28:02.034]                   base::do.call(base::Sys.setenv, args = args)
[17:28:02.034]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:02.034]             }
[17:28:02.034]             else {
[17:28:02.034]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:02.034]             }
[17:28:02.034]             {
[17:28:02.034]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:02.034]                   0L) {
[17:28:02.034]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:02.034]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:02.034]                   base::options(opts)
[17:28:02.034]                 }
[17:28:02.034]                 {
[17:28:02.034]                   {
[17:28:02.034]                     base::options(mc.cores = ...future.mc.cores.old)
[17:28:02.034]                     NULL
[17:28:02.034]                   }
[17:28:02.034]                   options(future.plan = NULL)
[17:28:02.034]                   if (is.na(NA_character_)) 
[17:28:02.034]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:02.034]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:02.034]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:02.034]                     .init = FALSE)
[17:28:02.034]                 }
[17:28:02.034]             }
[17:28:02.034]         }
[17:28:02.034]     })
[17:28:02.034]     if (TRUE) {
[17:28:02.034]         base::sink(type = "output", split = FALSE)
[17:28:02.034]         if (TRUE) {
[17:28:02.034]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:02.034]         }
[17:28:02.034]         else {
[17:28:02.034]             ...future.result["stdout"] <- base::list(NULL)
[17:28:02.034]         }
[17:28:02.034]         base::close(...future.stdout)
[17:28:02.034]         ...future.stdout <- NULL
[17:28:02.034]     }
[17:28:02.034]     ...future.result$conditions <- ...future.conditions
[17:28:02.034]     ...future.result$finished <- base::Sys.time()
[17:28:02.034]     ...future.result
[17:28:02.034] }
[17:28:02.043] Exporting 1 global objects (334 bytes) to cluster node #1 ...
[17:28:02.043] Exporting 'x' (31 bytes) to cluster node #1 ...
[17:28:02.044] Exporting 'x' (31 bytes) to cluster node #1 ... DONE
[17:28:02.045] Exporting 1 global objects (334 bytes) to cluster node #1 ... DONE
[17:28:02.046] MultisessionFuture started
[17:28:02.046] - Launch lazy future ... done
[17:28:02.046] run() for 'MultisessionFuture' ... done
[17:28:02.047] result() for ClusterFuture ...
[17:28:02.047] receiveMessageFromWorker() for ClusterFuture ...
[17:28:02.047] - Validating connection of MultisessionFuture
[17:28:02.076] - received message: FutureResult
[17:28:02.077] - Received FutureResult
[17:28:02.077] - Erased future from FutureRegistry
[17:28:02.077] result() for ClusterFuture ...
[17:28:02.078] - result already collected: FutureResult
[17:28:02.078] result() for ClusterFuture ... done
[17:28:02.078] receiveMessageFromWorker() for ClusterFuture ... done
[17:28:02.079] result() for ClusterFuture ... done
[17:28:02.079] result() for ClusterFuture ...
[17:28:02.079] - result already collected: FutureResult
[17:28:02.080] result() for ClusterFuture ... done
$a
[1] 1

Warning in getGlobalsAndPackages(expr, envir = envir, tweak = tweakExpression,  :
  R option 'future.globals.resolve' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'TRUE'
[17:28:02.081] getGlobalsAndPackages() ...
Warning in getGlobalsAndPackages(expr, envir = envir, tweak = tweakExpression,  :
  R option 'future.globals.onMissing' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'error'
[17:28:02.081] Searching for globals...
[17:28:02.086] - globals found: [5] '{', 'x', '<-', '$', '$<-'
[17:28:02.087] Searching for globals ... DONE
[17:28:02.087] Resolving globals: TRUE
[17:28:02.087] Resolving any globals that are futures ...
[17:28:02.088] - globals: [5] '{', 'x', '<-', '$', '$<-'
[17:28:02.088] Resolving any globals that are futures ... DONE
[17:28:02.089] Resolving futures part of globals (recursively) ...
[17:28:02.090] resolve() on list ...
[17:28:02.090]  recursive: 99
[17:28:02.090]  length: 1
[17:28:02.091]  elements: 'x'
[17:28:02.091]  length: 0 (resolved future 1)
[17:28:02.091] resolve() on list ... DONE
[17:28:02.092] - globals: [1] 'x'
[17:28:02.092] Resolving futures part of globals (recursively) ... DONE
[17:28:02.093] The total size of the 1 globals is 31 bytes (31 bytes)
[17:28:02.093] The total size of the 1 globals exported for future expression ('{; x$a <- 1; x; }') is 31 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (31 bytes of class 'list')
[17:28:02.094] - globals: [1] 'x'
[17:28:02.094] 
[17:28:02.094] getGlobalsAndPackages() ... DONE
[17:28:02.095] run() for 'Future' ...
[17:28:02.096] - state: 'created'
[17:28:02.096] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:28:02.117] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:28:02.117] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:28:02.118]   - Field: 'node'
[17:28:02.118]   - Field: 'label'
[17:28:02.118]   - Field: 'local'
[17:28:02.119]   - Field: 'owner'
[17:28:02.119]   - Field: 'envir'
[17:28:02.119]   - Field: 'workers'
[17:28:02.120]   - Field: 'packages'
[17:28:02.120]   - Field: 'gc'
[17:28:02.120]   - Field: 'conditions'
[17:28:02.121]   - Field: 'persistent'
[17:28:02.121]   - Field: 'expr'
[17:28:02.122]   - Field: 'uuid'
[17:28:02.122]   - Field: 'seed'
[17:28:02.122]   - Field: 'version'
[17:28:02.123]   - Field: 'result'
[17:28:02.123]   - Field: 'asynchronous'
[17:28:02.123]   - Field: 'calls'
[17:28:02.124]   - Field: 'globals'
[17:28:02.124]   - Field: 'stdout'
[17:28:02.124]   - Field: 'earlySignal'
[17:28:02.125]   - Field: 'lazy'
[17:28:02.125]   - Field: 'state'
[17:28:02.126] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:28:02.126] - Launch lazy future ...
[17:28:02.127] Packages needed by the future expression (n = 0): <none>
[17:28:02.127] Packages needed by future strategies (n = 0): <none>
[17:28:02.128] {
[17:28:02.128]     {
[17:28:02.128]         {
[17:28:02.128]             ...future.startTime <- base::Sys.time()
[17:28:02.128]             {
[17:28:02.128]                 {
[17:28:02.128]                   {
[17:28:02.128]                     {
[17:28:02.128]                       base::local({
[17:28:02.128]                         has_future <- base::requireNamespace("future", 
[17:28:02.128]                           quietly = TRUE)
[17:28:02.128]                         if (has_future) {
[17:28:02.128]                           ns <- base::getNamespace("future")
[17:28:02.128]                           version <- ns[[".package"]][["version"]]
[17:28:02.128]                           if (is.null(version)) 
[17:28:02.128]                             version <- utils::packageVersion("future")
[17:28:02.128]                         }
[17:28:02.128]                         else {
[17:28:02.128]                           version <- NULL
[17:28:02.128]                         }
[17:28:02.128]                         if (!has_future || version < "1.8.0") {
[17:28:02.128]                           info <- base::c(r_version = base::gsub("R version ", 
[17:28:02.128]                             "", base::R.version$version.string), 
[17:28:02.128]                             platform = base::sprintf("%s (%s-bit)", 
[17:28:02.128]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:02.128]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:02.128]                               "release", "version")], collapse = " "), 
[17:28:02.128]                             hostname = base::Sys.info()[["nodename"]])
[17:28:02.128]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:28:02.128]                             info)
[17:28:02.128]                           info <- base::paste(info, collapse = "; ")
[17:28:02.128]                           if (!has_future) {
[17:28:02.128]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:02.128]                               info)
[17:28:02.128]                           }
[17:28:02.128]                           else {
[17:28:02.128]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:02.128]                               info, version)
[17:28:02.128]                           }
[17:28:02.128]                           base::stop(msg)
[17:28:02.128]                         }
[17:28:02.128]                       })
[17:28:02.128]                     }
[17:28:02.128]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:28:02.128]                     base::options(mc.cores = 1L)
[17:28:02.128]                   }
[17:28:02.128]                   ...future.strategy.old <- future::plan("list")
[17:28:02.128]                   options(future.plan = NULL)
[17:28:02.128]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:02.128]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:02.128]                 }
[17:28:02.128]                 ...future.workdir <- getwd()
[17:28:02.128]             }
[17:28:02.128]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:02.128]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:02.128]         }
[17:28:02.128]         base::options(future.startup.script = FALSE, future.globals.onMissing = "error", 
[17:28:02.128]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:02.128]             future.globals.onMissing = "error", future.globals.onReference = NULL, 
[17:28:02.128]             future.globals.resolve = TRUE, future.resolve.recursive = NULL, 
[17:28:02.128]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:28:02.128]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:02.128]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:02.128]             base::names(...future.oldOptions))
[17:28:02.128]     }
[17:28:02.128]     if (FALSE) {
[17:28:02.128]     }
[17:28:02.128]     else {
[17:28:02.128]         if (TRUE) {
[17:28:02.128]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:02.128]                 open = "w")
[17:28:02.128]         }
[17:28:02.128]         else {
[17:28:02.128]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:02.128]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:02.128]         }
[17:28:02.128]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:02.128]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:02.128]             base::sink(type = "output", split = FALSE)
[17:28:02.128]             base::close(...future.stdout)
[17:28:02.128]         }, add = TRUE)
[17:28:02.128]     }
[17:28:02.128]     ...future.frame <- base::sys.nframe()
[17:28:02.128]     ...future.conditions <- base::list()
[17:28:02.128]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:02.128]     if (FALSE) {
[17:28:02.128]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:02.128]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:02.128]     }
[17:28:02.128]     ...future.result <- base::tryCatch({
[17:28:02.128]         base::withCallingHandlers({
[17:28:02.128]             ...future.value <- base::withVisible(base::local({
[17:28:02.128]                 ...future.makeSendCondition <- base::local({
[17:28:02.128]                   sendCondition <- NULL
[17:28:02.128]                   function(frame = 1L) {
[17:28:02.128]                     if (is.function(sendCondition)) 
[17:28:02.128]                       return(sendCondition)
[17:28:02.128]                     ns <- getNamespace("parallel")
[17:28:02.128]                     if (exists("sendData", mode = "function", 
[17:28:02.128]                       envir = ns)) {
[17:28:02.128]                       parallel_sendData <- get("sendData", mode = "function", 
[17:28:02.128]                         envir = ns)
[17:28:02.128]                       envir <- sys.frame(frame)
[17:28:02.128]                       master <- NULL
[17:28:02.128]                       while (!identical(envir, .GlobalEnv) && 
[17:28:02.128]                         !identical(envir, emptyenv())) {
[17:28:02.128]                         if (exists("master", mode = "list", envir = envir, 
[17:28:02.128]                           inherits = FALSE)) {
[17:28:02.128]                           master <- get("master", mode = "list", 
[17:28:02.128]                             envir = envir, inherits = FALSE)
[17:28:02.128]                           if (inherits(master, c("SOCKnode", 
[17:28:02.128]                             "SOCK0node"))) {
[17:28:02.128]                             sendCondition <<- function(cond) {
[17:28:02.128]                               data <- list(type = "VALUE", value = cond, 
[17:28:02.128]                                 success = TRUE)
[17:28:02.128]                               parallel_sendData(master, data)
[17:28:02.128]                             }
[17:28:02.128]                             return(sendCondition)
[17:28:02.128]                           }
[17:28:02.128]                         }
[17:28:02.128]                         frame <- frame + 1L
[17:28:02.128]                         envir <- sys.frame(frame)
[17:28:02.128]                       }
[17:28:02.128]                     }
[17:28:02.128]                     sendCondition <<- function(cond) NULL
[17:28:02.128]                   }
[17:28:02.128]                 })
[17:28:02.128]                 withCallingHandlers({
[17:28:02.128]                   {
[17:28:02.128]                     x$a <- 1
[17:28:02.128]                     x
[17:28:02.128]                   }
[17:28:02.128]                 }, immediateCondition = function(cond) {
[17:28:02.128]                   sendCondition <- ...future.makeSendCondition()
[17:28:02.128]                   sendCondition(cond)
[17:28:02.128]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:02.128]                   {
[17:28:02.128]                     inherits <- base::inherits
[17:28:02.128]                     invokeRestart <- base::invokeRestart
[17:28:02.128]                     is.null <- base::is.null
[17:28:02.128]                     muffled <- FALSE
[17:28:02.128]                     if (inherits(cond, "message")) {
[17:28:02.128]                       muffled <- grepl(pattern, "muffleMessage")
[17:28:02.128]                       if (muffled) 
[17:28:02.128]                         invokeRestart("muffleMessage")
[17:28:02.128]                     }
[17:28:02.128]                     else if (inherits(cond, "warning")) {
[17:28:02.128]                       muffled <- grepl(pattern, "muffleWarning")
[17:28:02.128]                       if (muffled) 
[17:28:02.128]                         invokeRestart("muffleWarning")
[17:28:02.128]                     }
[17:28:02.128]                     else if (inherits(cond, "condition")) {
[17:28:02.128]                       if (!is.null(pattern)) {
[17:28:02.128]                         computeRestarts <- base::computeRestarts
[17:28:02.128]                         grepl <- base::grepl
[17:28:02.128]                         restarts <- computeRestarts(cond)
[17:28:02.128]                         for (restart in restarts) {
[17:28:02.128]                           name <- restart$name
[17:28:02.128]                           if (is.null(name)) 
[17:28:02.128]                             next
[17:28:02.128]                           if (!grepl(pattern, name)) 
[17:28:02.128]                             next
[17:28:02.128]                           invokeRestart(restart)
[17:28:02.128]                           muffled <- TRUE
[17:28:02.128]                           break
[17:28:02.128]                         }
[17:28:02.128]                       }
[17:28:02.128]                     }
[17:28:02.128]                     invisible(muffled)
[17:28:02.128]                   }
[17:28:02.128]                   muffleCondition(cond)
[17:28:02.128]                 })
[17:28:02.128]             }))
[17:28:02.128]             future::FutureResult(value = ...future.value$value, 
[17:28:02.128]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:02.128]                   ...future.rng), globalenv = if (FALSE) 
[17:28:02.128]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:02.128]                     ...future.globalenv.names))
[17:28:02.128]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:02.128]         }, condition = base::local({
[17:28:02.128]             c <- base::c
[17:28:02.128]             inherits <- base::inherits
[17:28:02.128]             invokeRestart <- base::invokeRestart
[17:28:02.128]             length <- base::length
[17:28:02.128]             list <- base::list
[17:28:02.128]             seq.int <- base::seq.int
[17:28:02.128]             signalCondition <- base::signalCondition
[17:28:02.128]             sys.calls <- base::sys.calls
[17:28:02.128]             `[[` <- base::`[[`
[17:28:02.128]             `+` <- base::`+`
[17:28:02.128]             `<<-` <- base::`<<-`
[17:28:02.128]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:02.128]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:02.128]                   3L)]
[17:28:02.128]             }
[17:28:02.128]             function(cond) {
[17:28:02.128]                 is_error <- inherits(cond, "error")
[17:28:02.128]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:02.128]                   NULL)
[17:28:02.128]                 if (is_error) {
[17:28:02.128]                   sessionInformation <- function() {
[17:28:02.128]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:02.128]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:02.128]                       search = base::search(), system = base::Sys.info())
[17:28:02.128]                   }
[17:28:02.128]                   ...future.conditions[[length(...future.conditions) + 
[17:28:02.128]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:02.128]                     cond$call), session = sessionInformation(), 
[17:28:02.128]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:02.128]                   signalCondition(cond)
[17:28:02.128]                 }
[17:28:02.128]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:02.128]                 "immediateCondition"))) {
[17:28:02.128]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:02.128]                   ...future.conditions[[length(...future.conditions) + 
[17:28:02.128]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:02.128]                   if (TRUE && !signal) {
[17:28:02.128]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:02.128]                     {
[17:28:02.128]                       inherits <- base::inherits
[17:28:02.128]                       invokeRestart <- base::invokeRestart
[17:28:02.128]                       is.null <- base::is.null
[17:28:02.128]                       muffled <- FALSE
[17:28:02.128]                       if (inherits(cond, "message")) {
[17:28:02.128]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:02.128]                         if (muffled) 
[17:28:02.128]                           invokeRestart("muffleMessage")
[17:28:02.128]                       }
[17:28:02.128]                       else if (inherits(cond, "warning")) {
[17:28:02.128]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:02.128]                         if (muffled) 
[17:28:02.128]                           invokeRestart("muffleWarning")
[17:28:02.128]                       }
[17:28:02.128]                       else if (inherits(cond, "condition")) {
[17:28:02.128]                         if (!is.null(pattern)) {
[17:28:02.128]                           computeRestarts <- base::computeRestarts
[17:28:02.128]                           grepl <- base::grepl
[17:28:02.128]                           restarts <- computeRestarts(cond)
[17:28:02.128]                           for (restart in restarts) {
[17:28:02.128]                             name <- restart$name
[17:28:02.128]                             if (is.null(name)) 
[17:28:02.128]                               next
[17:28:02.128]                             if (!grepl(pattern, name)) 
[17:28:02.128]                               next
[17:28:02.128]                             invokeRestart(restart)
[17:28:02.128]                             muffled <- TRUE
[17:28:02.128]                             break
[17:28:02.128]                           }
[17:28:02.128]                         }
[17:28:02.128]                       }
[17:28:02.128]                       invisible(muffled)
[17:28:02.128]                     }
[17:28:02.128]                     muffleCondition(cond, pattern = "^muffle")
[17:28:02.128]                   }
[17:28:02.128]                 }
[17:28:02.128]                 else {
[17:28:02.128]                   if (TRUE) {
[17:28:02.128]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:02.128]                     {
[17:28:02.128]                       inherits <- base::inherits
[17:28:02.128]                       invokeRestart <- base::invokeRestart
[17:28:02.128]                       is.null <- base::is.null
[17:28:02.128]                       muffled <- FALSE
[17:28:02.128]                       if (inherits(cond, "message")) {
[17:28:02.128]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:02.128]                         if (muffled) 
[17:28:02.128]                           invokeRestart("muffleMessage")
[17:28:02.128]                       }
[17:28:02.128]                       else if (inherits(cond, "warning")) {
[17:28:02.128]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:02.128]                         if (muffled) 
[17:28:02.128]                           invokeRestart("muffleWarning")
[17:28:02.128]                       }
[17:28:02.128]                       else if (inherits(cond, "condition")) {
[17:28:02.128]                         if (!is.null(pattern)) {
[17:28:02.128]                           computeRestarts <- base::computeRestarts
[17:28:02.128]                           grepl <- base::grepl
[17:28:02.128]                           restarts <- computeRestarts(cond)
[17:28:02.128]                           for (restart in restarts) {
[17:28:02.128]                             name <- restart$name
[17:28:02.128]                             if (is.null(name)) 
[17:28:02.128]                               next
[17:28:02.128]                             if (!grepl(pattern, name)) 
[17:28:02.128]                               next
[17:28:02.128]                             invokeRestart(restart)
[17:28:02.128]                             muffled <- TRUE
[17:28:02.128]                             break
[17:28:02.128]                           }
[17:28:02.128]                         }
[17:28:02.128]                       }
[17:28:02.128]                       invisible(muffled)
[17:28:02.128]                     }
[17:28:02.128]                     muffleCondition(cond, pattern = "^muffle")
[17:28:02.128]                   }
[17:28:02.128]                 }
[17:28:02.128]             }
[17:28:02.128]         }))
[17:28:02.128]     }, error = function(ex) {
[17:28:02.128]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:02.128]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:02.128]                 ...future.rng), started = ...future.startTime, 
[17:28:02.128]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:02.128]             version = "1.8"), class = "FutureResult")
[17:28:02.128]     }, finally = {
[17:28:02.128]         if (!identical(...future.workdir, getwd())) 
[17:28:02.128]             setwd(...future.workdir)
[17:28:02.128]         {
[17:28:02.128]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:02.128]                 ...future.oldOptions$nwarnings <- NULL
[17:28:02.128]             }
[17:28:02.128]             base::options(...future.oldOptions)
[17:28:02.128]             if (.Platform$OS.type == "windows") {
[17:28:02.128]                 old_names <- names(...future.oldEnvVars)
[17:28:02.128]                 envs <- base::Sys.getenv()
[17:28:02.128]                 names <- names(envs)
[17:28:02.128]                 common <- intersect(names, old_names)
[17:28:02.128]                 added <- setdiff(names, old_names)
[17:28:02.128]                 removed <- setdiff(old_names, names)
[17:28:02.128]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:02.128]                   envs[common]]
[17:28:02.128]                 NAMES <- toupper(changed)
[17:28:02.128]                 args <- list()
[17:28:02.128]                 for (kk in seq_along(NAMES)) {
[17:28:02.128]                   name <- changed[[kk]]
[17:28:02.128]                   NAME <- NAMES[[kk]]
[17:28:02.128]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:02.128]                     next
[17:28:02.128]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:02.128]                 }
[17:28:02.128]                 NAMES <- toupper(added)
[17:28:02.128]                 for (kk in seq_along(NAMES)) {
[17:28:02.128]                   name <- added[[kk]]
[17:28:02.128]                   NAME <- NAMES[[kk]]
[17:28:02.128]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:02.128]                     next
[17:28:02.128]                   args[[name]] <- ""
[17:28:02.128]                 }
[17:28:02.128]                 NAMES <- toupper(removed)
[17:28:02.128]                 for (kk in seq_along(NAMES)) {
[17:28:02.128]                   name <- removed[[kk]]
[17:28:02.128]                   NAME <- NAMES[[kk]]
[17:28:02.128]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:02.128]                     next
[17:28:02.128]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:02.128]                 }
[17:28:02.128]                 if (length(args) > 0) 
[17:28:02.128]                   base::do.call(base::Sys.setenv, args = args)
[17:28:02.128]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:02.128]             }
[17:28:02.128]             else {
[17:28:02.128]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:02.128]             }
[17:28:02.128]             {
[17:28:02.128]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:02.128]                   0L) {
[17:28:02.128]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:02.128]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:02.128]                   base::options(opts)
[17:28:02.128]                 }
[17:28:02.128]                 {
[17:28:02.128]                   {
[17:28:02.128]                     base::options(mc.cores = ...future.mc.cores.old)
[17:28:02.128]                     NULL
[17:28:02.128]                   }
[17:28:02.128]                   options(future.plan = NULL)
[17:28:02.128]                   if (is.na(NA_character_)) 
[17:28:02.128]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:02.128]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:02.128]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:02.128]                     .init = FALSE)
[17:28:02.128]                 }
[17:28:02.128]             }
[17:28:02.128]         }
[17:28:02.128]     })
[17:28:02.128]     if (TRUE) {
[17:28:02.128]         base::sink(type = "output", split = FALSE)
[17:28:02.128]         if (TRUE) {
[17:28:02.128]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:02.128]         }
[17:28:02.128]         else {
[17:28:02.128]             ...future.result["stdout"] <- base::list(NULL)
[17:28:02.128]         }
[17:28:02.128]         base::close(...future.stdout)
[17:28:02.128]         ...future.stdout <- NULL
[17:28:02.128]     }
[17:28:02.128]     ...future.result$conditions <- ...future.conditions
[17:28:02.128]     ...future.result$finished <- base::Sys.time()
[17:28:02.128]     ...future.result
[17:28:02.128] }
[17:28:02.137] Exporting 1 global objects (334 bytes) to cluster node #1 ...
[17:28:02.138] Exporting 'x' (31 bytes) to cluster node #1 ...
[17:28:02.139] Exporting 'x' (31 bytes) to cluster node #1 ... DONE
[17:28:02.139] Exporting 1 global objects (334 bytes) to cluster node #1 ... DONE
[17:28:02.140] MultisessionFuture started
[17:28:02.141] - Launch lazy future ... done
[17:28:02.141] run() for 'MultisessionFuture' ... done
[17:28:02.141] result() for ClusterFuture ...
[17:28:02.142] receiveMessageFromWorker() for ClusterFuture ...
[17:28:02.142] - Validating connection of MultisessionFuture
[17:28:02.176] - received message: FutureResult
[17:28:02.176] - Received FutureResult
[17:28:02.177] - Erased future from FutureRegistry
[17:28:02.177] result() for ClusterFuture ...
[17:28:02.177] - result already collected: FutureResult
[17:28:02.178] result() for ClusterFuture ... done
[17:28:02.178] receiveMessageFromWorker() for ClusterFuture ... done
[17:28:02.178] result() for ClusterFuture ... done
[17:28:02.179] result() for ClusterFuture ...
[17:28:02.179] - result already collected: FutureResult
[17:28:02.179] result() for ClusterFuture ... done
$a
[1] 1

Warning in getGlobalsAndPackages(expr, envir = envir, tweak = tweakExpression,  :
  R option 'future.globals.resolve' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'TRUE'
[17:28:02.181] getGlobalsAndPackages() ...
Warning in getGlobalsAndPackages(expr, envir = envir, tweak = tweakExpression,  :
  R option 'future.globals.onMissing' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'error'
[17:28:02.181] Searching for globals...
[17:28:02.186] - globals found: [5] '{', 'x', '<-', '$', '$<-'
[17:28:02.187] Searching for globals ... DONE
[17:28:02.187] Resolving globals: TRUE
[17:28:02.187] Resolving any globals that are futures ...
[17:28:02.188] - globals: [5] '{', 'x', '<-', '$', '$<-'
[17:28:02.188] Resolving any globals that are futures ... DONE
[17:28:02.189] Resolving futures part of globals (recursively) ...
[17:28:02.189] resolve() on list ...
[17:28:02.190]  recursive: 99
[17:28:02.190]  length: 1
[17:28:02.190]  elements: 'x'
[17:28:02.190]  length: 0 (resolved future 1)
[17:28:02.191] resolve() on list ... DONE
[17:28:02.191] - globals: [1] 'x'
[17:28:02.191] Resolving futures part of globals (recursively) ... DONE
[17:28:02.191] The total size of the 1 globals is 31 bytes (31 bytes)
[17:28:02.192] The total size of the 1 globals exported for future expression ('{; x$a <- 1; x; }') is 31 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (31 bytes of class 'list')
[17:28:02.192] - globals: [1] 'x'
[17:28:02.192] 
[17:28:02.192] getGlobalsAndPackages() ... DONE
[17:28:02.193] run() for 'Future' ...
[17:28:02.193] - state: 'created'
[17:28:02.193] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:28:02.211] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:28:02.212] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:28:02.212]   - Field: 'node'
[17:28:02.212]   - Field: 'label'
[17:28:02.212]   - Field: 'local'
[17:28:02.213]   - Field: 'owner'
[17:28:02.213]   - Field: 'envir'
[17:28:02.213]   - Field: 'workers'
[17:28:02.213]   - Field: 'packages'
[17:28:02.213]   - Field: 'gc'
[17:28:02.213]   - Field: 'conditions'
[17:28:02.214]   - Field: 'persistent'
[17:28:02.214]   - Field: 'expr'
[17:28:02.214]   - Field: 'uuid'
[17:28:02.214]   - Field: 'seed'
[17:28:02.214]   - Field: 'version'
[17:28:02.214]   - Field: 'result'
[17:28:02.215]   - Field: 'asynchronous'
[17:28:02.215]   - Field: 'calls'
[17:28:02.215]   - Field: 'globals'
[17:28:02.215]   - Field: 'stdout'
[17:28:02.215]   - Field: 'earlySignal'
[17:28:02.215]   - Field: 'lazy'
[17:28:02.216]   - Field: 'state'
[17:28:02.216] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:28:02.216] - Launch lazy future ...
[17:28:02.216] Packages needed by the future expression (n = 0): <none>
[17:28:02.217] Packages needed by future strategies (n = 0): <none>
[17:28:02.217] {
[17:28:02.217]     {
[17:28:02.217]         {
[17:28:02.217]             ...future.startTime <- base::Sys.time()
[17:28:02.217]             {
[17:28:02.217]                 {
[17:28:02.217]                   {
[17:28:02.217]                     {
[17:28:02.217]                       base::local({
[17:28:02.217]                         has_future <- base::requireNamespace("future", 
[17:28:02.217]                           quietly = TRUE)
[17:28:02.217]                         if (has_future) {
[17:28:02.217]                           ns <- base::getNamespace("future")
[17:28:02.217]                           version <- ns[[".package"]][["version"]]
[17:28:02.217]                           if (is.null(version)) 
[17:28:02.217]                             version <- utils::packageVersion("future")
[17:28:02.217]                         }
[17:28:02.217]                         else {
[17:28:02.217]                           version <- NULL
[17:28:02.217]                         }
[17:28:02.217]                         if (!has_future || version < "1.8.0") {
[17:28:02.217]                           info <- base::c(r_version = base::gsub("R version ", 
[17:28:02.217]                             "", base::R.version$version.string), 
[17:28:02.217]                             platform = base::sprintf("%s (%s-bit)", 
[17:28:02.217]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:02.217]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:02.217]                               "release", "version")], collapse = " "), 
[17:28:02.217]                             hostname = base::Sys.info()[["nodename"]])
[17:28:02.217]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:28:02.217]                             info)
[17:28:02.217]                           info <- base::paste(info, collapse = "; ")
[17:28:02.217]                           if (!has_future) {
[17:28:02.217]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:02.217]                               info)
[17:28:02.217]                           }
[17:28:02.217]                           else {
[17:28:02.217]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:02.217]                               info, version)
[17:28:02.217]                           }
[17:28:02.217]                           base::stop(msg)
[17:28:02.217]                         }
[17:28:02.217]                       })
[17:28:02.217]                     }
[17:28:02.217]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:28:02.217]                     base::options(mc.cores = 1L)
[17:28:02.217]                   }
[17:28:02.217]                   ...future.strategy.old <- future::plan("list")
[17:28:02.217]                   options(future.plan = NULL)
[17:28:02.217]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:02.217]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:02.217]                 }
[17:28:02.217]                 ...future.workdir <- getwd()
[17:28:02.217]             }
[17:28:02.217]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:02.217]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:02.217]         }
[17:28:02.217]         base::options(future.startup.script = FALSE, future.globals.onMissing = "error", 
[17:28:02.217]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:02.217]             future.globals.onMissing = "error", future.globals.onReference = NULL, 
[17:28:02.217]             future.globals.resolve = TRUE, future.resolve.recursive = NULL, 
[17:28:02.217]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:28:02.217]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:02.217]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:02.217]             base::names(...future.oldOptions))
[17:28:02.217]     }
[17:28:02.217]     if (FALSE) {
[17:28:02.217]     }
[17:28:02.217]     else {
[17:28:02.217]         if (TRUE) {
[17:28:02.217]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:02.217]                 open = "w")
[17:28:02.217]         }
[17:28:02.217]         else {
[17:28:02.217]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:02.217]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:02.217]         }
[17:28:02.217]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:02.217]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:02.217]             base::sink(type = "output", split = FALSE)
[17:28:02.217]             base::close(...future.stdout)
[17:28:02.217]         }, add = TRUE)
[17:28:02.217]     }
[17:28:02.217]     ...future.frame <- base::sys.nframe()
[17:28:02.217]     ...future.conditions <- base::list()
[17:28:02.217]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:02.217]     if (FALSE) {
[17:28:02.217]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:02.217]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:02.217]     }
[17:28:02.217]     ...future.result <- base::tryCatch({
[17:28:02.217]         base::withCallingHandlers({
[17:28:02.217]             ...future.value <- base::withVisible(base::local({
[17:28:02.217]                 ...future.makeSendCondition <- base::local({
[17:28:02.217]                   sendCondition <- NULL
[17:28:02.217]                   function(frame = 1L) {
[17:28:02.217]                     if (is.function(sendCondition)) 
[17:28:02.217]                       return(sendCondition)
[17:28:02.217]                     ns <- getNamespace("parallel")
[17:28:02.217]                     if (exists("sendData", mode = "function", 
[17:28:02.217]                       envir = ns)) {
[17:28:02.217]                       parallel_sendData <- get("sendData", mode = "function", 
[17:28:02.217]                         envir = ns)
[17:28:02.217]                       envir <- sys.frame(frame)
[17:28:02.217]                       master <- NULL
[17:28:02.217]                       while (!identical(envir, .GlobalEnv) && 
[17:28:02.217]                         !identical(envir, emptyenv())) {
[17:28:02.217]                         if (exists("master", mode = "list", envir = envir, 
[17:28:02.217]                           inherits = FALSE)) {
[17:28:02.217]                           master <- get("master", mode = "list", 
[17:28:02.217]                             envir = envir, inherits = FALSE)
[17:28:02.217]                           if (inherits(master, c("SOCKnode", 
[17:28:02.217]                             "SOCK0node"))) {
[17:28:02.217]                             sendCondition <<- function(cond) {
[17:28:02.217]                               data <- list(type = "VALUE", value = cond, 
[17:28:02.217]                                 success = TRUE)
[17:28:02.217]                               parallel_sendData(master, data)
[17:28:02.217]                             }
[17:28:02.217]                             return(sendCondition)
[17:28:02.217]                           }
[17:28:02.217]                         }
[17:28:02.217]                         frame <- frame + 1L
[17:28:02.217]                         envir <- sys.frame(frame)
[17:28:02.217]                       }
[17:28:02.217]                     }
[17:28:02.217]                     sendCondition <<- function(cond) NULL
[17:28:02.217]                   }
[17:28:02.217]                 })
[17:28:02.217]                 withCallingHandlers({
[17:28:02.217]                   {
[17:28:02.217]                     x$a <- 1
[17:28:02.217]                     x
[17:28:02.217]                   }
[17:28:02.217]                 }, immediateCondition = function(cond) {
[17:28:02.217]                   sendCondition <- ...future.makeSendCondition()
[17:28:02.217]                   sendCondition(cond)
[17:28:02.217]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:02.217]                   {
[17:28:02.217]                     inherits <- base::inherits
[17:28:02.217]                     invokeRestart <- base::invokeRestart
[17:28:02.217]                     is.null <- base::is.null
[17:28:02.217]                     muffled <- FALSE
[17:28:02.217]                     if (inherits(cond, "message")) {
[17:28:02.217]                       muffled <- grepl(pattern, "muffleMessage")
[17:28:02.217]                       if (muffled) 
[17:28:02.217]                         invokeRestart("muffleMessage")
[17:28:02.217]                     }
[17:28:02.217]                     else if (inherits(cond, "warning")) {
[17:28:02.217]                       muffled <- grepl(pattern, "muffleWarning")
[17:28:02.217]                       if (muffled) 
[17:28:02.217]                         invokeRestart("muffleWarning")
[17:28:02.217]                     }
[17:28:02.217]                     else if (inherits(cond, "condition")) {
[17:28:02.217]                       if (!is.null(pattern)) {
[17:28:02.217]                         computeRestarts <- base::computeRestarts
[17:28:02.217]                         grepl <- base::grepl
[17:28:02.217]                         restarts <- computeRestarts(cond)
[17:28:02.217]                         for (restart in restarts) {
[17:28:02.217]                           name <- restart$name
[17:28:02.217]                           if (is.null(name)) 
[17:28:02.217]                             next
[17:28:02.217]                           if (!grepl(pattern, name)) 
[17:28:02.217]                             next
[17:28:02.217]                           invokeRestart(restart)
[17:28:02.217]                           muffled <- TRUE
[17:28:02.217]                           break
[17:28:02.217]                         }
[17:28:02.217]                       }
[17:28:02.217]                     }
[17:28:02.217]                     invisible(muffled)
[17:28:02.217]                   }
[17:28:02.217]                   muffleCondition(cond)
[17:28:02.217]                 })
[17:28:02.217]             }))
[17:28:02.217]             future::FutureResult(value = ...future.value$value, 
[17:28:02.217]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:02.217]                   ...future.rng), globalenv = if (FALSE) 
[17:28:02.217]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:02.217]                     ...future.globalenv.names))
[17:28:02.217]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:02.217]         }, condition = base::local({
[17:28:02.217]             c <- base::c
[17:28:02.217]             inherits <- base::inherits
[17:28:02.217]             invokeRestart <- base::invokeRestart
[17:28:02.217]             length <- base::length
[17:28:02.217]             list <- base::list
[17:28:02.217]             seq.int <- base::seq.int
[17:28:02.217]             signalCondition <- base::signalCondition
[17:28:02.217]             sys.calls <- base::sys.calls
[17:28:02.217]             `[[` <- base::`[[`
[17:28:02.217]             `+` <- base::`+`
[17:28:02.217]             `<<-` <- base::`<<-`
[17:28:02.217]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:02.217]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:02.217]                   3L)]
[17:28:02.217]             }
[17:28:02.217]             function(cond) {
[17:28:02.217]                 is_error <- inherits(cond, "error")
[17:28:02.217]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:02.217]                   NULL)
[17:28:02.217]                 if (is_error) {
[17:28:02.217]                   sessionInformation <- function() {
[17:28:02.217]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:02.217]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:02.217]                       search = base::search(), system = base::Sys.info())
[17:28:02.217]                   }
[17:28:02.217]                   ...future.conditions[[length(...future.conditions) + 
[17:28:02.217]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:02.217]                     cond$call), session = sessionInformation(), 
[17:28:02.217]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:02.217]                   signalCondition(cond)
[17:28:02.217]                 }
[17:28:02.217]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:02.217]                 "immediateCondition"))) {
[17:28:02.217]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:02.217]                   ...future.conditions[[length(...future.conditions) + 
[17:28:02.217]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:02.217]                   if (TRUE && !signal) {
[17:28:02.217]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:02.217]                     {
[17:28:02.217]                       inherits <- base::inherits
[17:28:02.217]                       invokeRestart <- base::invokeRestart
[17:28:02.217]                       is.null <- base::is.null
[17:28:02.217]                       muffled <- FALSE
[17:28:02.217]                       if (inherits(cond, "message")) {
[17:28:02.217]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:02.217]                         if (muffled) 
[17:28:02.217]                           invokeRestart("muffleMessage")
[17:28:02.217]                       }
[17:28:02.217]                       else if (inherits(cond, "warning")) {
[17:28:02.217]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:02.217]                         if (muffled) 
[17:28:02.217]                           invokeRestart("muffleWarning")
[17:28:02.217]                       }
[17:28:02.217]                       else if (inherits(cond, "condition")) {
[17:28:02.217]                         if (!is.null(pattern)) {
[17:28:02.217]                           computeRestarts <- base::computeRestarts
[17:28:02.217]                           grepl <- base::grepl
[17:28:02.217]                           restarts <- computeRestarts(cond)
[17:28:02.217]                           for (restart in restarts) {
[17:28:02.217]                             name <- restart$name
[17:28:02.217]                             if (is.null(name)) 
[17:28:02.217]                               next
[17:28:02.217]                             if (!grepl(pattern, name)) 
[17:28:02.217]                               next
[17:28:02.217]                             invokeRestart(restart)
[17:28:02.217]                             muffled <- TRUE
[17:28:02.217]                             break
[17:28:02.217]                           }
[17:28:02.217]                         }
[17:28:02.217]                       }
[17:28:02.217]                       invisible(muffled)
[17:28:02.217]                     }
[17:28:02.217]                     muffleCondition(cond, pattern = "^muffle")
[17:28:02.217]                   }
[17:28:02.217]                 }
[17:28:02.217]                 else {
[17:28:02.217]                   if (TRUE) {
[17:28:02.217]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:02.217]                     {
[17:28:02.217]                       inherits <- base::inherits
[17:28:02.217]                       invokeRestart <- base::invokeRestart
[17:28:02.217]                       is.null <- base::is.null
[17:28:02.217]                       muffled <- FALSE
[17:28:02.217]                       if (inherits(cond, "message")) {
[17:28:02.217]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:02.217]                         if (muffled) 
[17:28:02.217]                           invokeRestart("muffleMessage")
[17:28:02.217]                       }
[17:28:02.217]                       else if (inherits(cond, "warning")) {
[17:28:02.217]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:02.217]                         if (muffled) 
[17:28:02.217]                           invokeRestart("muffleWarning")
[17:28:02.217]                       }
[17:28:02.217]                       else if (inherits(cond, "condition")) {
[17:28:02.217]                         if (!is.null(pattern)) {
[17:28:02.217]                           computeRestarts <- base::computeRestarts
[17:28:02.217]                           grepl <- base::grepl
[17:28:02.217]                           restarts <- computeRestarts(cond)
[17:28:02.217]                           for (restart in restarts) {
[17:28:02.217]                             name <- restart$name
[17:28:02.217]                             if (is.null(name)) 
[17:28:02.217]                               next
[17:28:02.217]                             if (!grepl(pattern, name)) 
[17:28:02.217]                               next
[17:28:02.217]                             invokeRestart(restart)
[17:28:02.217]                             muffled <- TRUE
[17:28:02.217]                             break
[17:28:02.217]                           }
[17:28:02.217]                         }
[17:28:02.217]                       }
[17:28:02.217]                       invisible(muffled)
[17:28:02.217]                     }
[17:28:02.217]                     muffleCondition(cond, pattern = "^muffle")
[17:28:02.217]                   }
[17:28:02.217]                 }
[17:28:02.217]             }
[17:28:02.217]         }))
[17:28:02.217]     }, error = function(ex) {
[17:28:02.217]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:02.217]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:02.217]                 ...future.rng), started = ...future.startTime, 
[17:28:02.217]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:02.217]             version = "1.8"), class = "FutureResult")
[17:28:02.217]     }, finally = {
[17:28:02.217]         if (!identical(...future.workdir, getwd())) 
[17:28:02.217]             setwd(...future.workdir)
[17:28:02.217]         {
[17:28:02.217]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:02.217]                 ...future.oldOptions$nwarnings <- NULL
[17:28:02.217]             }
[17:28:02.217]             base::options(...future.oldOptions)
[17:28:02.217]             if (.Platform$OS.type == "windows") {
[17:28:02.217]                 old_names <- names(...future.oldEnvVars)
[17:28:02.217]                 envs <- base::Sys.getenv()
[17:28:02.217]                 names <- names(envs)
[17:28:02.217]                 common <- intersect(names, old_names)
[17:28:02.217]                 added <- setdiff(names, old_names)
[17:28:02.217]                 removed <- setdiff(old_names, names)
[17:28:02.217]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:02.217]                   envs[common]]
[17:28:02.217]                 NAMES <- toupper(changed)
[17:28:02.217]                 args <- list()
[17:28:02.217]                 for (kk in seq_along(NAMES)) {
[17:28:02.217]                   name <- changed[[kk]]
[17:28:02.217]                   NAME <- NAMES[[kk]]
[17:28:02.217]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:02.217]                     next
[17:28:02.217]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:02.217]                 }
[17:28:02.217]                 NAMES <- toupper(added)
[17:28:02.217]                 for (kk in seq_along(NAMES)) {
[17:28:02.217]                   name <- added[[kk]]
[17:28:02.217]                   NAME <- NAMES[[kk]]
[17:28:02.217]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:02.217]                     next
[17:28:02.217]                   args[[name]] <- ""
[17:28:02.217]                 }
[17:28:02.217]                 NAMES <- toupper(removed)
[17:28:02.217]                 for (kk in seq_along(NAMES)) {
[17:28:02.217]                   name <- removed[[kk]]
[17:28:02.217]                   NAME <- NAMES[[kk]]
[17:28:02.217]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:02.217]                     next
[17:28:02.217]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:02.217]                 }
[17:28:02.217]                 if (length(args) > 0) 
[17:28:02.217]                   base::do.call(base::Sys.setenv, args = args)
[17:28:02.217]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:02.217]             }
[17:28:02.217]             else {
[17:28:02.217]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:02.217]             }
[17:28:02.217]             {
[17:28:02.217]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:02.217]                   0L) {
[17:28:02.217]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:02.217]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:02.217]                   base::options(opts)
[17:28:02.217]                 }
[17:28:02.217]                 {
[17:28:02.217]                   {
[17:28:02.217]                     base::options(mc.cores = ...future.mc.cores.old)
[17:28:02.217]                     NULL
[17:28:02.217]                   }
[17:28:02.217]                   options(future.plan = NULL)
[17:28:02.217]                   if (is.na(NA_character_)) 
[17:28:02.217]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:02.217]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:02.217]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:02.217]                     .init = FALSE)
[17:28:02.217]                 }
[17:28:02.217]             }
[17:28:02.217]         }
[17:28:02.217]     })
[17:28:02.217]     if (TRUE) {
[17:28:02.217]         base::sink(type = "output", split = FALSE)
[17:28:02.217]         if (TRUE) {
[17:28:02.217]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:02.217]         }
[17:28:02.217]         else {
[17:28:02.217]             ...future.result["stdout"] <- base::list(NULL)
[17:28:02.217]         }
[17:28:02.217]         base::close(...future.stdout)
[17:28:02.217]         ...future.stdout <- NULL
[17:28:02.217]     }
[17:28:02.217]     ...future.result$conditions <- ...future.conditions
[17:28:02.217]     ...future.result$finished <- base::Sys.time()
[17:28:02.217]     ...future.result
[17:28:02.217] }
[17:28:02.223] Exporting 1 global objects (334 bytes) to cluster node #1 ...
[17:28:02.223] Exporting 'x' (31 bytes) to cluster node #1 ...
[17:28:02.223] Exporting 'x' (31 bytes) to cluster node #1 ... DONE
[17:28:02.224] Exporting 1 global objects (334 bytes) to cluster node #1 ... DONE
[17:28:02.225] MultisessionFuture started
[17:28:02.225] - Launch lazy future ... done
[17:28:02.225] run() for 'MultisessionFuture' ... done
[17:28:02.226] result() for ClusterFuture ...
[17:28:02.226] receiveMessageFromWorker() for ClusterFuture ...
[17:28:02.226] - Validating connection of MultisessionFuture
[17:28:02.244] - received message: FutureResult
[17:28:02.244] - Received FutureResult
[17:28:02.245] - Erased future from FutureRegistry
[17:28:02.245] result() for ClusterFuture ...
[17:28:02.245] - result already collected: FutureResult
[17:28:02.246] result() for ClusterFuture ... done
[17:28:02.246] receiveMessageFromWorker() for ClusterFuture ... done
[17:28:02.246] result() for ClusterFuture ... done
[17:28:02.247] result() for ClusterFuture ...
[17:28:02.247] - result already collected: FutureResult
[17:28:02.247] result() for ClusterFuture ... done
$a
[1] 1

Warning in getGlobalsAndPackages(expr, envir = envir, tweak = tweakExpression,  :
  R option 'future.globals.resolve' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'TRUE'
[17:28:02.249] getGlobalsAndPackages() ...
Warning in getGlobalsAndPackages(expr, envir = envir, tweak = tweakExpression,  :
  R option 'future.globals.onMissing' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'error'
[17:28:02.249] Searching for globals...
[17:28:02.254] - globals found: [5] '{', 'x', '<-', '$', '$<-'
[17:28:02.254] Searching for globals ... DONE
[17:28:02.255] Resolving globals: TRUE
[17:28:02.255] Resolving any globals that are futures ...
[17:28:02.255] - globals: [5] '{', 'x', '<-', '$', '$<-'
[17:28:02.255] Resolving any globals that are futures ... DONE
[17:28:02.256] Resolving futures part of globals (recursively) ...
[17:28:02.257] resolve() on list ...
[17:28:02.257]  recursive: 99
[17:28:02.258]  length: 1
[17:28:02.258]  elements: 'x'
[17:28:02.258]  length: 0 (resolved future 1)
[17:28:02.259] resolve() on list ... DONE
[17:28:02.259] - globals: [1] 'x'
[17:28:02.259] Resolving futures part of globals (recursively) ... DONE
[17:28:02.260] The total size of the 1 globals is 31 bytes (31 bytes)
[17:28:02.260] The total size of the 1 globals exported for future expression ('{; x$a <- 1; x; }') is 31 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (31 bytes of class 'list')
[17:28:02.261] - globals: [1] 'x'
[17:28:02.261] 
[17:28:02.261] getGlobalsAndPackages() ... DONE
[17:28:02.262] run() for 'Future' ...
[17:28:02.262] - state: 'created'
[17:28:02.263] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:28:02.286] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:28:02.287] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:28:02.287]   - Field: 'node'
[17:28:02.288]   - Field: 'label'
[17:28:02.288]   - Field: 'local'
[17:28:02.288]   - Field: 'owner'
[17:28:02.289]   - Field: 'envir'
[17:28:02.289]   - Field: 'workers'
[17:28:02.289]   - Field: 'packages'
[17:28:02.290]   - Field: 'gc'
[17:28:02.290]   - Field: 'conditions'
[17:28:02.290]   - Field: 'persistent'
[17:28:02.291]   - Field: 'expr'
[17:28:02.291]   - Field: 'uuid'
[17:28:02.291]   - Field: 'seed'
[17:28:02.292]   - Field: 'version'
[17:28:02.292]   - Field: 'result'
[17:28:02.292]   - Field: 'asynchronous'
[17:28:02.293]   - Field: 'calls'
[17:28:02.293]   - Field: 'globals'
[17:28:02.293]   - Field: 'stdout'
[17:28:02.294]   - Field: 'earlySignal'
[17:28:02.294]   - Field: 'lazy'
[17:28:02.294]   - Field: 'state'
[17:28:02.295] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:28:02.295] - Launch lazy future ...
[17:28:02.296] Packages needed by the future expression (n = 0): <none>
[17:28:02.296] Packages needed by future strategies (n = 0): <none>
[17:28:02.297] {
[17:28:02.297]     {
[17:28:02.297]         {
[17:28:02.297]             ...future.startTime <- base::Sys.time()
[17:28:02.297]             {
[17:28:02.297]                 {
[17:28:02.297]                   {
[17:28:02.297]                     {
[17:28:02.297]                       base::local({
[17:28:02.297]                         has_future <- base::requireNamespace("future", 
[17:28:02.297]                           quietly = TRUE)
[17:28:02.297]                         if (has_future) {
[17:28:02.297]                           ns <- base::getNamespace("future")
[17:28:02.297]                           version <- ns[[".package"]][["version"]]
[17:28:02.297]                           if (is.null(version)) 
[17:28:02.297]                             version <- utils::packageVersion("future")
[17:28:02.297]                         }
[17:28:02.297]                         else {
[17:28:02.297]                           version <- NULL
[17:28:02.297]                         }
[17:28:02.297]                         if (!has_future || version < "1.8.0") {
[17:28:02.297]                           info <- base::c(r_version = base::gsub("R version ", 
[17:28:02.297]                             "", base::R.version$version.string), 
[17:28:02.297]                             platform = base::sprintf("%s (%s-bit)", 
[17:28:02.297]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:02.297]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:02.297]                               "release", "version")], collapse = " "), 
[17:28:02.297]                             hostname = base::Sys.info()[["nodename"]])
[17:28:02.297]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:28:02.297]                             info)
[17:28:02.297]                           info <- base::paste(info, collapse = "; ")
[17:28:02.297]                           if (!has_future) {
[17:28:02.297]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:02.297]                               info)
[17:28:02.297]                           }
[17:28:02.297]                           else {
[17:28:02.297]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:02.297]                               info, version)
[17:28:02.297]                           }
[17:28:02.297]                           base::stop(msg)
[17:28:02.297]                         }
[17:28:02.297]                       })
[17:28:02.297]                     }
[17:28:02.297]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:28:02.297]                     base::options(mc.cores = 1L)
[17:28:02.297]                   }
[17:28:02.297]                   ...future.strategy.old <- future::plan("list")
[17:28:02.297]                   options(future.plan = NULL)
[17:28:02.297]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:02.297]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:02.297]                 }
[17:28:02.297]                 ...future.workdir <- getwd()
[17:28:02.297]             }
[17:28:02.297]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:02.297]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:02.297]         }
[17:28:02.297]         base::options(future.startup.script = FALSE, future.globals.onMissing = "error", 
[17:28:02.297]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:02.297]             future.globals.onMissing = "error", future.globals.onReference = NULL, 
[17:28:02.297]             future.globals.resolve = TRUE, future.resolve.recursive = NULL, 
[17:28:02.297]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:28:02.297]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:02.297]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:02.297]             base::names(...future.oldOptions))
[17:28:02.297]     }
[17:28:02.297]     if (FALSE) {
[17:28:02.297]     }
[17:28:02.297]     else {
[17:28:02.297]         if (TRUE) {
[17:28:02.297]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:02.297]                 open = "w")
[17:28:02.297]         }
[17:28:02.297]         else {
[17:28:02.297]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:02.297]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:02.297]         }
[17:28:02.297]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:02.297]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:02.297]             base::sink(type = "output", split = FALSE)
[17:28:02.297]             base::close(...future.stdout)
[17:28:02.297]         }, add = TRUE)
[17:28:02.297]     }
[17:28:02.297]     ...future.frame <- base::sys.nframe()
[17:28:02.297]     ...future.conditions <- base::list()
[17:28:02.297]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:02.297]     if (FALSE) {
[17:28:02.297]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:02.297]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:02.297]     }
[17:28:02.297]     ...future.result <- base::tryCatch({
[17:28:02.297]         base::withCallingHandlers({
[17:28:02.297]             ...future.value <- base::withVisible(base::local({
[17:28:02.297]                 ...future.makeSendCondition <- base::local({
[17:28:02.297]                   sendCondition <- NULL
[17:28:02.297]                   function(frame = 1L) {
[17:28:02.297]                     if (is.function(sendCondition)) 
[17:28:02.297]                       return(sendCondition)
[17:28:02.297]                     ns <- getNamespace("parallel")
[17:28:02.297]                     if (exists("sendData", mode = "function", 
[17:28:02.297]                       envir = ns)) {
[17:28:02.297]                       parallel_sendData <- get("sendData", mode = "function", 
[17:28:02.297]                         envir = ns)
[17:28:02.297]                       envir <- sys.frame(frame)
[17:28:02.297]                       master <- NULL
[17:28:02.297]                       while (!identical(envir, .GlobalEnv) && 
[17:28:02.297]                         !identical(envir, emptyenv())) {
[17:28:02.297]                         if (exists("master", mode = "list", envir = envir, 
[17:28:02.297]                           inherits = FALSE)) {
[17:28:02.297]                           master <- get("master", mode = "list", 
[17:28:02.297]                             envir = envir, inherits = FALSE)
[17:28:02.297]                           if (inherits(master, c("SOCKnode", 
[17:28:02.297]                             "SOCK0node"))) {
[17:28:02.297]                             sendCondition <<- function(cond) {
[17:28:02.297]                               data <- list(type = "VALUE", value = cond, 
[17:28:02.297]                                 success = TRUE)
[17:28:02.297]                               parallel_sendData(master, data)
[17:28:02.297]                             }
[17:28:02.297]                             return(sendCondition)
[17:28:02.297]                           }
[17:28:02.297]                         }
[17:28:02.297]                         frame <- frame + 1L
[17:28:02.297]                         envir <- sys.frame(frame)
[17:28:02.297]                       }
[17:28:02.297]                     }
[17:28:02.297]                     sendCondition <<- function(cond) NULL
[17:28:02.297]                   }
[17:28:02.297]                 })
[17:28:02.297]                 withCallingHandlers({
[17:28:02.297]                   {
[17:28:02.297]                     x$a <- 1
[17:28:02.297]                     x
[17:28:02.297]                   }
[17:28:02.297]                 }, immediateCondition = function(cond) {
[17:28:02.297]                   sendCondition <- ...future.makeSendCondition()
[17:28:02.297]                   sendCondition(cond)
[17:28:02.297]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:02.297]                   {
[17:28:02.297]                     inherits <- base::inherits
[17:28:02.297]                     invokeRestart <- base::invokeRestart
[17:28:02.297]                     is.null <- base::is.null
[17:28:02.297]                     muffled <- FALSE
[17:28:02.297]                     if (inherits(cond, "message")) {
[17:28:02.297]                       muffled <- grepl(pattern, "muffleMessage")
[17:28:02.297]                       if (muffled) 
[17:28:02.297]                         invokeRestart("muffleMessage")
[17:28:02.297]                     }
[17:28:02.297]                     else if (inherits(cond, "warning")) {
[17:28:02.297]                       muffled <- grepl(pattern, "muffleWarning")
[17:28:02.297]                       if (muffled) 
[17:28:02.297]                         invokeRestart("muffleWarning")
[17:28:02.297]                     }
[17:28:02.297]                     else if (inherits(cond, "condition")) {
[17:28:02.297]                       if (!is.null(pattern)) {
[17:28:02.297]                         computeRestarts <- base::computeRestarts
[17:28:02.297]                         grepl <- base::grepl
[17:28:02.297]                         restarts <- computeRestarts(cond)
[17:28:02.297]                         for (restart in restarts) {
[17:28:02.297]                           name <- restart$name
[17:28:02.297]                           if (is.null(name)) 
[17:28:02.297]                             next
[17:28:02.297]                           if (!grepl(pattern, name)) 
[17:28:02.297]                             next
[17:28:02.297]                           invokeRestart(restart)
[17:28:02.297]                           muffled <- TRUE
[17:28:02.297]                           break
[17:28:02.297]                         }
[17:28:02.297]                       }
[17:28:02.297]                     }
[17:28:02.297]                     invisible(muffled)
[17:28:02.297]                   }
[17:28:02.297]                   muffleCondition(cond)
[17:28:02.297]                 })
[17:28:02.297]             }))
[17:28:02.297]             future::FutureResult(value = ...future.value$value, 
[17:28:02.297]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:02.297]                   ...future.rng), globalenv = if (FALSE) 
[17:28:02.297]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:02.297]                     ...future.globalenv.names))
[17:28:02.297]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:02.297]         }, condition = base::local({
[17:28:02.297]             c <- base::c
[17:28:02.297]             inherits <- base::inherits
[17:28:02.297]             invokeRestart <- base::invokeRestart
[17:28:02.297]             length <- base::length
[17:28:02.297]             list <- base::list
[17:28:02.297]             seq.int <- base::seq.int
[17:28:02.297]             signalCondition <- base::signalCondition
[17:28:02.297]             sys.calls <- base::sys.calls
[17:28:02.297]             `[[` <- base::`[[`
[17:28:02.297]             `+` <- base::`+`
[17:28:02.297]             `<<-` <- base::`<<-`
[17:28:02.297]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:02.297]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:02.297]                   3L)]
[17:28:02.297]             }
[17:28:02.297]             function(cond) {
[17:28:02.297]                 is_error <- inherits(cond, "error")
[17:28:02.297]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:02.297]                   NULL)
[17:28:02.297]                 if (is_error) {
[17:28:02.297]                   sessionInformation <- function() {
[17:28:02.297]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:02.297]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:02.297]                       search = base::search(), system = base::Sys.info())
[17:28:02.297]                   }
[17:28:02.297]                   ...future.conditions[[length(...future.conditions) + 
[17:28:02.297]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:02.297]                     cond$call), session = sessionInformation(), 
[17:28:02.297]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:02.297]                   signalCondition(cond)
[17:28:02.297]                 }
[17:28:02.297]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:02.297]                 "immediateCondition"))) {
[17:28:02.297]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:02.297]                   ...future.conditions[[length(...future.conditions) + 
[17:28:02.297]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:02.297]                   if (TRUE && !signal) {
[17:28:02.297]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:02.297]                     {
[17:28:02.297]                       inherits <- base::inherits
[17:28:02.297]                       invokeRestart <- base::invokeRestart
[17:28:02.297]                       is.null <- base::is.null
[17:28:02.297]                       muffled <- FALSE
[17:28:02.297]                       if (inherits(cond, "message")) {
[17:28:02.297]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:02.297]                         if (muffled) 
[17:28:02.297]                           invokeRestart("muffleMessage")
[17:28:02.297]                       }
[17:28:02.297]                       else if (inherits(cond, "warning")) {
[17:28:02.297]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:02.297]                         if (muffled) 
[17:28:02.297]                           invokeRestart("muffleWarning")
[17:28:02.297]                       }
[17:28:02.297]                       else if (inherits(cond, "condition")) {
[17:28:02.297]                         if (!is.null(pattern)) {
[17:28:02.297]                           computeRestarts <- base::computeRestarts
[17:28:02.297]                           grepl <- base::grepl
[17:28:02.297]                           restarts <- computeRestarts(cond)
[17:28:02.297]                           for (restart in restarts) {
[17:28:02.297]                             name <- restart$name
[17:28:02.297]                             if (is.null(name)) 
[17:28:02.297]                               next
[17:28:02.297]                             if (!grepl(pattern, name)) 
[17:28:02.297]                               next
[17:28:02.297]                             invokeRestart(restart)
[17:28:02.297]                             muffled <- TRUE
[17:28:02.297]                             break
[17:28:02.297]                           }
[17:28:02.297]                         }
[17:28:02.297]                       }
[17:28:02.297]                       invisible(muffled)
[17:28:02.297]                     }
[17:28:02.297]                     muffleCondition(cond, pattern = "^muffle")
[17:28:02.297]                   }
[17:28:02.297]                 }
[17:28:02.297]                 else {
[17:28:02.297]                   if (TRUE) {
[17:28:02.297]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:02.297]                     {
[17:28:02.297]                       inherits <- base::inherits
[17:28:02.297]                       invokeRestart <- base::invokeRestart
[17:28:02.297]                       is.null <- base::is.null
[17:28:02.297]                       muffled <- FALSE
[17:28:02.297]                       if (inherits(cond, "message")) {
[17:28:02.297]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:02.297]                         if (muffled) 
[17:28:02.297]                           invokeRestart("muffleMessage")
[17:28:02.297]                       }
[17:28:02.297]                       else if (inherits(cond, "warning")) {
[17:28:02.297]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:02.297]                         if (muffled) 
[17:28:02.297]                           invokeRestart("muffleWarning")
[17:28:02.297]                       }
[17:28:02.297]                       else if (inherits(cond, "condition")) {
[17:28:02.297]                         if (!is.null(pattern)) {
[17:28:02.297]                           computeRestarts <- base::computeRestarts
[17:28:02.297]                           grepl <- base::grepl
[17:28:02.297]                           restarts <- computeRestarts(cond)
[17:28:02.297]                           for (restart in restarts) {
[17:28:02.297]                             name <- restart$name
[17:28:02.297]                             if (is.null(name)) 
[17:28:02.297]                               next
[17:28:02.297]                             if (!grepl(pattern, name)) 
[17:28:02.297]                               next
[17:28:02.297]                             invokeRestart(restart)
[17:28:02.297]                             muffled <- TRUE
[17:28:02.297]                             break
[17:28:02.297]                           }
[17:28:02.297]                         }
[17:28:02.297]                       }
[17:28:02.297]                       invisible(muffled)
[17:28:02.297]                     }
[17:28:02.297]                     muffleCondition(cond, pattern = "^muffle")
[17:28:02.297]                   }
[17:28:02.297]                 }
[17:28:02.297]             }
[17:28:02.297]         }))
[17:28:02.297]     }, error = function(ex) {
[17:28:02.297]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:02.297]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:02.297]                 ...future.rng), started = ...future.startTime, 
[17:28:02.297]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:02.297]             version = "1.8"), class = "FutureResult")
[17:28:02.297]     }, finally = {
[17:28:02.297]         if (!identical(...future.workdir, getwd())) 
[17:28:02.297]             setwd(...future.workdir)
[17:28:02.297]         {
[17:28:02.297]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:02.297]                 ...future.oldOptions$nwarnings <- NULL
[17:28:02.297]             }
[17:28:02.297]             base::options(...future.oldOptions)
[17:28:02.297]             if (.Platform$OS.type == "windows") {
[17:28:02.297]                 old_names <- names(...future.oldEnvVars)
[17:28:02.297]                 envs <- base::Sys.getenv()
[17:28:02.297]                 names <- names(envs)
[17:28:02.297]                 common <- intersect(names, old_names)
[17:28:02.297]                 added <- setdiff(names, old_names)
[17:28:02.297]                 removed <- setdiff(old_names, names)
[17:28:02.297]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:02.297]                   envs[common]]
[17:28:02.297]                 NAMES <- toupper(changed)
[17:28:02.297]                 args <- list()
[17:28:02.297]                 for (kk in seq_along(NAMES)) {
[17:28:02.297]                   name <- changed[[kk]]
[17:28:02.297]                   NAME <- NAMES[[kk]]
[17:28:02.297]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:02.297]                     next
[17:28:02.297]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:02.297]                 }
[17:28:02.297]                 NAMES <- toupper(added)
[17:28:02.297]                 for (kk in seq_along(NAMES)) {
[17:28:02.297]                   name <- added[[kk]]
[17:28:02.297]                   NAME <- NAMES[[kk]]
[17:28:02.297]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:02.297]                     next
[17:28:02.297]                   args[[name]] <- ""
[17:28:02.297]                 }
[17:28:02.297]                 NAMES <- toupper(removed)
[17:28:02.297]                 for (kk in seq_along(NAMES)) {
[17:28:02.297]                   name <- removed[[kk]]
[17:28:02.297]                   NAME <- NAMES[[kk]]
[17:28:02.297]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:02.297]                     next
[17:28:02.297]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:02.297]                 }
[17:28:02.297]                 if (length(args) > 0) 
[17:28:02.297]                   base::do.call(base::Sys.setenv, args = args)
[17:28:02.297]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:02.297]             }
[17:28:02.297]             else {
[17:28:02.297]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:02.297]             }
[17:28:02.297]             {
[17:28:02.297]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:02.297]                   0L) {
[17:28:02.297]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:02.297]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:02.297]                   base::options(opts)
[17:28:02.297]                 }
[17:28:02.297]                 {
[17:28:02.297]                   {
[17:28:02.297]                     base::options(mc.cores = ...future.mc.cores.old)
[17:28:02.297]                     NULL
[17:28:02.297]                   }
[17:28:02.297]                   options(future.plan = NULL)
[17:28:02.297]                   if (is.na(NA_character_)) 
[17:28:02.297]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:02.297]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:02.297]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:02.297]                     .init = FALSE)
[17:28:02.297]                 }
[17:28:02.297]             }
[17:28:02.297]         }
[17:28:02.297]     })
[17:28:02.297]     if (TRUE) {
[17:28:02.297]         base::sink(type = "output", split = FALSE)
[17:28:02.297]         if (TRUE) {
[17:28:02.297]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:02.297]         }
[17:28:02.297]         else {
[17:28:02.297]             ...future.result["stdout"] <- base::list(NULL)
[17:28:02.297]         }
[17:28:02.297]         base::close(...future.stdout)
[17:28:02.297]         ...future.stdout <- NULL
[17:28:02.297]     }
[17:28:02.297]     ...future.result$conditions <- ...future.conditions
[17:28:02.297]     ...future.result$finished <- base::Sys.time()
[17:28:02.297]     ...future.result
[17:28:02.297] }
[17:28:02.308] Exporting 1 global objects (334 bytes) to cluster node #1 ...
[17:28:02.308] Exporting 'x' (31 bytes) to cluster node #1 ...
[17:28:02.309] Exporting 'x' (31 bytes) to cluster node #1 ... DONE
[17:28:02.309] Exporting 1 global objects (334 bytes) to cluster node #1 ... DONE
[17:28:02.310] MultisessionFuture started
[17:28:02.311] - Launch lazy future ... done
[17:28:02.311] run() for 'MultisessionFuture' ... done
[17:28:02.311] result() for ClusterFuture ...
[17:28:02.312] receiveMessageFromWorker() for ClusterFuture ...
[17:28:02.312] - Validating connection of MultisessionFuture
[17:28:02.340] - received message: FutureResult
[17:28:02.340] - Received FutureResult
[17:28:02.341] - Erased future from FutureRegistry
[17:28:02.341] result() for ClusterFuture ...
[17:28:02.341] - result already collected: FutureResult
[17:28:02.341] result() for ClusterFuture ... done
[17:28:02.342] receiveMessageFromWorker() for ClusterFuture ... done
[17:28:02.342] result() for ClusterFuture ... done
[17:28:02.342] result() for ClusterFuture ...
[17:28:02.342] - result already collected: FutureResult
[17:28:02.343] result() for ClusterFuture ... done
$a
[1] 1

Warning in getGlobalsAndPackages(expr, envir = envir, tweak = tweakExpression,  :
  R option 'future.globals.resolve' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'TRUE'
[17:28:02.344] getGlobalsAndPackages() ...
Warning in getGlobalsAndPackages(expr, envir = envir, tweak = tweakExpression,  :
  R option 'future.globals.onMissing' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'error'
[17:28:02.344] Searching for globals...
[17:28:02.349] - globals found: [5] '{', '<-', 'list', '$', '$<-'
[17:28:02.350] Searching for globals ... DONE
[17:28:02.350] Resolving globals: TRUE
[17:28:02.350] Resolving any globals that are futures ...
[17:28:02.350] - globals: [5] '{', '<-', 'list', '$', '$<-'
[17:28:02.351] Resolving any globals that are futures ... DONE
[17:28:02.351] 
[17:28:02.352] 
[17:28:02.352] getGlobalsAndPackages() ... DONE
[17:28:02.353] run() for 'Future' ...
[17:28:02.353] - state: 'created'
[17:28:02.353] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:28:02.370] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:28:02.371] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:28:02.371]   - Field: 'node'
[17:28:02.371]   - Field: 'label'
[17:28:02.371]   - Field: 'local'
[17:28:02.371]   - Field: 'owner'
[17:28:02.372]   - Field: 'envir'
[17:28:02.372]   - Field: 'workers'
[17:28:02.372]   - Field: 'packages'
[17:28:02.372]   - Field: 'gc'
[17:28:02.372]   - Field: 'conditions'
[17:28:02.372]   - Field: 'persistent'
[17:28:02.373]   - Field: 'expr'
[17:28:02.373]   - Field: 'uuid'
[17:28:02.373]   - Field: 'seed'
[17:28:02.373]   - Field: 'version'
[17:28:02.373]   - Field: 'result'
[17:28:02.373]   - Field: 'asynchronous'
[17:28:02.374]   - Field: 'calls'
[17:28:02.374]   - Field: 'globals'
[17:28:02.374]   - Field: 'stdout'
[17:28:02.374]   - Field: 'earlySignal'
[17:28:02.374]   - Field: 'lazy'
[17:28:02.374]   - Field: 'state'
[17:28:02.375] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:28:02.375] - Launch lazy future ...
[17:28:02.375] Packages needed by the future expression (n = 0): <none>
[17:28:02.375] Packages needed by future strategies (n = 0): <none>
[17:28:02.376] {
[17:28:02.376]     {
[17:28:02.376]         {
[17:28:02.376]             ...future.startTime <- base::Sys.time()
[17:28:02.376]             {
[17:28:02.376]                 {
[17:28:02.376]                   {
[17:28:02.376]                     {
[17:28:02.376]                       base::local({
[17:28:02.376]                         has_future <- base::requireNamespace("future", 
[17:28:02.376]                           quietly = TRUE)
[17:28:02.376]                         if (has_future) {
[17:28:02.376]                           ns <- base::getNamespace("future")
[17:28:02.376]                           version <- ns[[".package"]][["version"]]
[17:28:02.376]                           if (is.null(version)) 
[17:28:02.376]                             version <- utils::packageVersion("future")
[17:28:02.376]                         }
[17:28:02.376]                         else {
[17:28:02.376]                           version <- NULL
[17:28:02.376]                         }
[17:28:02.376]                         if (!has_future || version < "1.8.0") {
[17:28:02.376]                           info <- base::c(r_version = base::gsub("R version ", 
[17:28:02.376]                             "", base::R.version$version.string), 
[17:28:02.376]                             platform = base::sprintf("%s (%s-bit)", 
[17:28:02.376]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:02.376]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:02.376]                               "release", "version")], collapse = " "), 
[17:28:02.376]                             hostname = base::Sys.info()[["nodename"]])
[17:28:02.376]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:28:02.376]                             info)
[17:28:02.376]                           info <- base::paste(info, collapse = "; ")
[17:28:02.376]                           if (!has_future) {
[17:28:02.376]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:02.376]                               info)
[17:28:02.376]                           }
[17:28:02.376]                           else {
[17:28:02.376]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:02.376]                               info, version)
[17:28:02.376]                           }
[17:28:02.376]                           base::stop(msg)
[17:28:02.376]                         }
[17:28:02.376]                       })
[17:28:02.376]                     }
[17:28:02.376]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:28:02.376]                     base::options(mc.cores = 1L)
[17:28:02.376]                   }
[17:28:02.376]                   ...future.strategy.old <- future::plan("list")
[17:28:02.376]                   options(future.plan = NULL)
[17:28:02.376]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:02.376]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:02.376]                 }
[17:28:02.376]                 ...future.workdir <- getwd()
[17:28:02.376]             }
[17:28:02.376]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:02.376]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:02.376]         }
[17:28:02.376]         base::options(future.startup.script = FALSE, future.globals.onMissing = "error", 
[17:28:02.376]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:02.376]             future.globals.onMissing = "error", future.globals.onReference = NULL, 
[17:28:02.376]             future.globals.resolve = TRUE, future.resolve.recursive = NULL, 
[17:28:02.376]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:28:02.376]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:02.376]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:02.376]             base::names(...future.oldOptions))
[17:28:02.376]     }
[17:28:02.376]     if (FALSE) {
[17:28:02.376]     }
[17:28:02.376]     else {
[17:28:02.376]         if (TRUE) {
[17:28:02.376]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:02.376]                 open = "w")
[17:28:02.376]         }
[17:28:02.376]         else {
[17:28:02.376]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:02.376]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:02.376]         }
[17:28:02.376]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:02.376]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:02.376]             base::sink(type = "output", split = FALSE)
[17:28:02.376]             base::close(...future.stdout)
[17:28:02.376]         }, add = TRUE)
[17:28:02.376]     }
[17:28:02.376]     ...future.frame <- base::sys.nframe()
[17:28:02.376]     ...future.conditions <- base::list()
[17:28:02.376]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:02.376]     if (FALSE) {
[17:28:02.376]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:02.376]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:02.376]     }
[17:28:02.376]     ...future.result <- base::tryCatch({
[17:28:02.376]         base::withCallingHandlers({
[17:28:02.376]             ...future.value <- base::withVisible(base::local({
[17:28:02.376]                 ...future.makeSendCondition <- base::local({
[17:28:02.376]                   sendCondition <- NULL
[17:28:02.376]                   function(frame = 1L) {
[17:28:02.376]                     if (is.function(sendCondition)) 
[17:28:02.376]                       return(sendCondition)
[17:28:02.376]                     ns <- getNamespace("parallel")
[17:28:02.376]                     if (exists("sendData", mode = "function", 
[17:28:02.376]                       envir = ns)) {
[17:28:02.376]                       parallel_sendData <- get("sendData", mode = "function", 
[17:28:02.376]                         envir = ns)
[17:28:02.376]                       envir <- sys.frame(frame)
[17:28:02.376]                       master <- NULL
[17:28:02.376]                       while (!identical(envir, .GlobalEnv) && 
[17:28:02.376]                         !identical(envir, emptyenv())) {
[17:28:02.376]                         if (exists("master", mode = "list", envir = envir, 
[17:28:02.376]                           inherits = FALSE)) {
[17:28:02.376]                           master <- get("master", mode = "list", 
[17:28:02.376]                             envir = envir, inherits = FALSE)
[17:28:02.376]                           if (inherits(master, c("SOCKnode", 
[17:28:02.376]                             "SOCK0node"))) {
[17:28:02.376]                             sendCondition <<- function(cond) {
[17:28:02.376]                               data <- list(type = "VALUE", value = cond, 
[17:28:02.376]                                 success = TRUE)
[17:28:02.376]                               parallel_sendData(master, data)
[17:28:02.376]                             }
[17:28:02.376]                             return(sendCondition)
[17:28:02.376]                           }
[17:28:02.376]                         }
[17:28:02.376]                         frame <- frame + 1L
[17:28:02.376]                         envir <- sys.frame(frame)
[17:28:02.376]                       }
[17:28:02.376]                     }
[17:28:02.376]                     sendCondition <<- function(cond) NULL
[17:28:02.376]                   }
[17:28:02.376]                 })
[17:28:02.376]                 withCallingHandlers({
[17:28:02.376]                   {
[17:28:02.376]                     x <- list(b = 2)
[17:28:02.376]                     x$a <- 1
[17:28:02.376]                     x
[17:28:02.376]                   }
[17:28:02.376]                 }, immediateCondition = function(cond) {
[17:28:02.376]                   sendCondition <- ...future.makeSendCondition()
[17:28:02.376]                   sendCondition(cond)
[17:28:02.376]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:02.376]                   {
[17:28:02.376]                     inherits <- base::inherits
[17:28:02.376]                     invokeRestart <- base::invokeRestart
[17:28:02.376]                     is.null <- base::is.null
[17:28:02.376]                     muffled <- FALSE
[17:28:02.376]                     if (inherits(cond, "message")) {
[17:28:02.376]                       muffled <- grepl(pattern, "muffleMessage")
[17:28:02.376]                       if (muffled) 
[17:28:02.376]                         invokeRestart("muffleMessage")
[17:28:02.376]                     }
[17:28:02.376]                     else if (inherits(cond, "warning")) {
[17:28:02.376]                       muffled <- grepl(pattern, "muffleWarning")
[17:28:02.376]                       if (muffled) 
[17:28:02.376]                         invokeRestart("muffleWarning")
[17:28:02.376]                     }
[17:28:02.376]                     else if (inherits(cond, "condition")) {
[17:28:02.376]                       if (!is.null(pattern)) {
[17:28:02.376]                         computeRestarts <- base::computeRestarts
[17:28:02.376]                         grepl <- base::grepl
[17:28:02.376]                         restarts <- computeRestarts(cond)
[17:28:02.376]                         for (restart in restarts) {
[17:28:02.376]                           name <- restart$name
[17:28:02.376]                           if (is.null(name)) 
[17:28:02.376]                             next
[17:28:02.376]                           if (!grepl(pattern, name)) 
[17:28:02.376]                             next
[17:28:02.376]                           invokeRestart(restart)
[17:28:02.376]                           muffled <- TRUE
[17:28:02.376]                           break
[17:28:02.376]                         }
[17:28:02.376]                       }
[17:28:02.376]                     }
[17:28:02.376]                     invisible(muffled)
[17:28:02.376]                   }
[17:28:02.376]                   muffleCondition(cond)
[17:28:02.376]                 })
[17:28:02.376]             }))
[17:28:02.376]             future::FutureResult(value = ...future.value$value, 
[17:28:02.376]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:02.376]                   ...future.rng), globalenv = if (FALSE) 
[17:28:02.376]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:02.376]                     ...future.globalenv.names))
[17:28:02.376]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:02.376]         }, condition = base::local({
[17:28:02.376]             c <- base::c
[17:28:02.376]             inherits <- base::inherits
[17:28:02.376]             invokeRestart <- base::invokeRestart
[17:28:02.376]             length <- base::length
[17:28:02.376]             list <- base::list
[17:28:02.376]             seq.int <- base::seq.int
[17:28:02.376]             signalCondition <- base::signalCondition
[17:28:02.376]             sys.calls <- base::sys.calls
[17:28:02.376]             `[[` <- base::`[[`
[17:28:02.376]             `+` <- base::`+`
[17:28:02.376]             `<<-` <- base::`<<-`
[17:28:02.376]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:02.376]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:02.376]                   3L)]
[17:28:02.376]             }
[17:28:02.376]             function(cond) {
[17:28:02.376]                 is_error <- inherits(cond, "error")
[17:28:02.376]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:02.376]                   NULL)
[17:28:02.376]                 if (is_error) {
[17:28:02.376]                   sessionInformation <- function() {
[17:28:02.376]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:02.376]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:02.376]                       search = base::search(), system = base::Sys.info())
[17:28:02.376]                   }
[17:28:02.376]                   ...future.conditions[[length(...future.conditions) + 
[17:28:02.376]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:02.376]                     cond$call), session = sessionInformation(), 
[17:28:02.376]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:02.376]                   signalCondition(cond)
[17:28:02.376]                 }
[17:28:02.376]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:02.376]                 "immediateCondition"))) {
[17:28:02.376]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:02.376]                   ...future.conditions[[length(...future.conditions) + 
[17:28:02.376]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:02.376]                   if (TRUE && !signal) {
[17:28:02.376]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:02.376]                     {
[17:28:02.376]                       inherits <- base::inherits
[17:28:02.376]                       invokeRestart <- base::invokeRestart
[17:28:02.376]                       is.null <- base::is.null
[17:28:02.376]                       muffled <- FALSE
[17:28:02.376]                       if (inherits(cond, "message")) {
[17:28:02.376]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:02.376]                         if (muffled) 
[17:28:02.376]                           invokeRestart("muffleMessage")
[17:28:02.376]                       }
[17:28:02.376]                       else if (inherits(cond, "warning")) {
[17:28:02.376]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:02.376]                         if (muffled) 
[17:28:02.376]                           invokeRestart("muffleWarning")
[17:28:02.376]                       }
[17:28:02.376]                       else if (inherits(cond, "condition")) {
[17:28:02.376]                         if (!is.null(pattern)) {
[17:28:02.376]                           computeRestarts <- base::computeRestarts
[17:28:02.376]                           grepl <- base::grepl
[17:28:02.376]                           restarts <- computeRestarts(cond)
[17:28:02.376]                           for (restart in restarts) {
[17:28:02.376]                             name <- restart$name
[17:28:02.376]                             if (is.null(name)) 
[17:28:02.376]                               next
[17:28:02.376]                             if (!grepl(pattern, name)) 
[17:28:02.376]                               next
[17:28:02.376]                             invokeRestart(restart)
[17:28:02.376]                             muffled <- TRUE
[17:28:02.376]                             break
[17:28:02.376]                           }
[17:28:02.376]                         }
[17:28:02.376]                       }
[17:28:02.376]                       invisible(muffled)
[17:28:02.376]                     }
[17:28:02.376]                     muffleCondition(cond, pattern = "^muffle")
[17:28:02.376]                   }
[17:28:02.376]                 }
[17:28:02.376]                 else {
[17:28:02.376]                   if (TRUE) {
[17:28:02.376]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:02.376]                     {
[17:28:02.376]                       inherits <- base::inherits
[17:28:02.376]                       invokeRestart <- base::invokeRestart
[17:28:02.376]                       is.null <- base::is.null
[17:28:02.376]                       muffled <- FALSE
[17:28:02.376]                       if (inherits(cond, "message")) {
[17:28:02.376]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:02.376]                         if (muffled) 
[17:28:02.376]                           invokeRestart("muffleMessage")
[17:28:02.376]                       }
[17:28:02.376]                       else if (inherits(cond, "warning")) {
[17:28:02.376]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:02.376]                         if (muffled) 
[17:28:02.376]                           invokeRestart("muffleWarning")
[17:28:02.376]                       }
[17:28:02.376]                       else if (inherits(cond, "condition")) {
[17:28:02.376]                         if (!is.null(pattern)) {
[17:28:02.376]                           computeRestarts <- base::computeRestarts
[17:28:02.376]                           grepl <- base::grepl
[17:28:02.376]                           restarts <- computeRestarts(cond)
[17:28:02.376]                           for (restart in restarts) {
[17:28:02.376]                             name <- restart$name
[17:28:02.376]                             if (is.null(name)) 
[17:28:02.376]                               next
[17:28:02.376]                             if (!grepl(pattern, name)) 
[17:28:02.376]                               next
[17:28:02.376]                             invokeRestart(restart)
[17:28:02.376]                             muffled <- TRUE
[17:28:02.376]                             break
[17:28:02.376]                           }
[17:28:02.376]                         }
[17:28:02.376]                       }
[17:28:02.376]                       invisible(muffled)
[17:28:02.376]                     }
[17:28:02.376]                     muffleCondition(cond, pattern = "^muffle")
[17:28:02.376]                   }
[17:28:02.376]                 }
[17:28:02.376]             }
[17:28:02.376]         }))
[17:28:02.376]     }, error = function(ex) {
[17:28:02.376]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:02.376]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:02.376]                 ...future.rng), started = ...future.startTime, 
[17:28:02.376]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:02.376]             version = "1.8"), class = "FutureResult")
[17:28:02.376]     }, finally = {
[17:28:02.376]         if (!identical(...future.workdir, getwd())) 
[17:28:02.376]             setwd(...future.workdir)
[17:28:02.376]         {
[17:28:02.376]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:02.376]                 ...future.oldOptions$nwarnings <- NULL
[17:28:02.376]             }
[17:28:02.376]             base::options(...future.oldOptions)
[17:28:02.376]             if (.Platform$OS.type == "windows") {
[17:28:02.376]                 old_names <- names(...future.oldEnvVars)
[17:28:02.376]                 envs <- base::Sys.getenv()
[17:28:02.376]                 names <- names(envs)
[17:28:02.376]                 common <- intersect(names, old_names)
[17:28:02.376]                 added <- setdiff(names, old_names)
[17:28:02.376]                 removed <- setdiff(old_names, names)
[17:28:02.376]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:02.376]                   envs[common]]
[17:28:02.376]                 NAMES <- toupper(changed)
[17:28:02.376]                 args <- list()
[17:28:02.376]                 for (kk in seq_along(NAMES)) {
[17:28:02.376]                   name <- changed[[kk]]
[17:28:02.376]                   NAME <- NAMES[[kk]]
[17:28:02.376]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:02.376]                     next
[17:28:02.376]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:02.376]                 }
[17:28:02.376]                 NAMES <- toupper(added)
[17:28:02.376]                 for (kk in seq_along(NAMES)) {
[17:28:02.376]                   name <- added[[kk]]
[17:28:02.376]                   NAME <- NAMES[[kk]]
[17:28:02.376]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:02.376]                     next
[17:28:02.376]                   args[[name]] <- ""
[17:28:02.376]                 }
[17:28:02.376]                 NAMES <- toupper(removed)
[17:28:02.376]                 for (kk in seq_along(NAMES)) {
[17:28:02.376]                   name <- removed[[kk]]
[17:28:02.376]                   NAME <- NAMES[[kk]]
[17:28:02.376]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:02.376]                     next
[17:28:02.376]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:02.376]                 }
[17:28:02.376]                 if (length(args) > 0) 
[17:28:02.376]                   base::do.call(base::Sys.setenv, args = args)
[17:28:02.376]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:02.376]             }
[17:28:02.376]             else {
[17:28:02.376]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:02.376]             }
[17:28:02.376]             {
[17:28:02.376]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:02.376]                   0L) {
[17:28:02.376]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:02.376]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:02.376]                   base::options(opts)
[17:28:02.376]                 }
[17:28:02.376]                 {
[17:28:02.376]                   {
[17:28:02.376]                     base::options(mc.cores = ...future.mc.cores.old)
[17:28:02.376]                     NULL
[17:28:02.376]                   }
[17:28:02.376]                   options(future.plan = NULL)
[17:28:02.376]                   if (is.na(NA_character_)) 
[17:28:02.376]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:02.376]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:02.376]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:02.376]                     .init = FALSE)
[17:28:02.376]                 }
[17:28:02.376]             }
[17:28:02.376]         }
[17:28:02.376]     })
[17:28:02.376]     if (TRUE) {
[17:28:02.376]         base::sink(type = "output", split = FALSE)
[17:28:02.376]         if (TRUE) {
[17:28:02.376]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:02.376]         }
[17:28:02.376]         else {
[17:28:02.376]             ...future.result["stdout"] <- base::list(NULL)
[17:28:02.376]         }
[17:28:02.376]         base::close(...future.stdout)
[17:28:02.376]         ...future.stdout <- NULL
[17:28:02.376]     }
[17:28:02.376]     ...future.result$conditions <- ...future.conditions
[17:28:02.376]     ...future.result$finished <- base::Sys.time()
[17:28:02.376]     ...future.result
[17:28:02.376] }
[17:28:02.385] MultisessionFuture started
[17:28:02.385] - Launch lazy future ... done
[17:28:02.386] run() for 'MultisessionFuture' ... done
[17:28:02.386] result() for ClusterFuture ...
[17:28:02.386] receiveMessageFromWorker() for ClusterFuture ...
[17:28:02.387] - Validating connection of MultisessionFuture
[17:28:02.414] - received message: FutureResult
[17:28:02.415] - Received FutureResult
[17:28:02.415] - Erased future from FutureRegistry
[17:28:02.415] result() for ClusterFuture ...
[17:28:02.416] - result already collected: FutureResult
[17:28:02.416] result() for ClusterFuture ... done
[17:28:02.416] receiveMessageFromWorker() for ClusterFuture ... done
[17:28:02.416] result() for ClusterFuture ... done
[17:28:02.416] result() for ClusterFuture ...
[17:28:02.417] - result already collected: FutureResult
[17:28:02.417] result() for ClusterFuture ... done
$b
[1] 2

$a
[1] 1

Warning in getGlobalsAndPackages(expr, envir = envir, tweak = tweakExpression,  :
  R option 'future.globals.resolve' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'TRUE'
[17:28:02.417] getGlobalsAndPackages() ...
Warning in getGlobalsAndPackages(expr, envir = envir, tweak = tweakExpression,  :
  R option 'future.globals.onMissing' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'error'
[17:28:02.418] Searching for globals...
[17:28:02.421] - globals found: [5] '{', 'x', '<-', '[[', '[[<-'
[17:28:02.422] Searching for globals ... DONE
[17:28:02.422] Resolving globals: TRUE
[17:28:02.423] Resolving any globals that are futures ...
[17:28:02.423] - globals: [5] '{', 'x', '<-', '[[', '[[<-'
[17:28:02.423] Resolving any globals that are futures ... DONE
[17:28:02.424] Resolving futures part of globals (recursively) ...
[17:28:02.425] resolve() on list ...
[17:28:02.425]  recursive: 99
[17:28:02.425]  length: 1
[17:28:02.426]  elements: 'x'
[17:28:02.426]  length: 0 (resolved future 1)
[17:28:02.426] resolve() on list ... DONE
[17:28:02.426] - globals: [1] 'x'
[17:28:02.427] Resolving futures part of globals (recursively) ... DONE
[17:28:02.427] The total size of the 1 globals is 31 bytes (31 bytes)
[17:28:02.428] The total size of the 1 globals exported for future expression ('{; x[["a"]] <- 1; x; }') is 31 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (31 bytes of class 'list')
[17:28:02.428] - globals: [1] 'x'
[17:28:02.428] 
[17:28:02.428] getGlobalsAndPackages() ... DONE
[17:28:02.429] run() for 'Future' ...
[17:28:02.429] - state: 'created'
[17:28:02.429] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:28:02.449] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:28:02.450] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:28:02.450]   - Field: 'node'
[17:28:02.450]   - Field: 'label'
[17:28:02.450]   - Field: 'local'
[17:28:02.450]   - Field: 'owner'
[17:28:02.451]   - Field: 'envir'
[17:28:02.451]   - Field: 'workers'
[17:28:02.451]   - Field: 'packages'
[17:28:02.451]   - Field: 'gc'
[17:28:02.451]   - Field: 'conditions'
[17:28:02.452]   - Field: 'persistent'
[17:28:02.452]   - Field: 'expr'
[17:28:02.452]   - Field: 'uuid'
[17:28:02.452]   - Field: 'seed'
[17:28:02.453]   - Field: 'version'
[17:28:02.453]   - Field: 'result'
[17:28:02.453]   - Field: 'asynchronous'
[17:28:02.453]   - Field: 'calls'
[17:28:02.453]   - Field: 'globals'
[17:28:02.454]   - Field: 'stdout'
[17:28:02.454]   - Field: 'earlySignal'
[17:28:02.454]   - Field: 'lazy'
[17:28:02.454]   - Field: 'state'
[17:28:02.454] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:28:02.455] - Launch lazy future ...
[17:28:02.455] Packages needed by the future expression (n = 0): <none>
[17:28:02.456] Packages needed by future strategies (n = 0): <none>
[17:28:02.457] {
[17:28:02.457]     {
[17:28:02.457]         {
[17:28:02.457]             ...future.startTime <- base::Sys.time()
[17:28:02.457]             {
[17:28:02.457]                 {
[17:28:02.457]                   {
[17:28:02.457]                     {
[17:28:02.457]                       base::local({
[17:28:02.457]                         has_future <- base::requireNamespace("future", 
[17:28:02.457]                           quietly = TRUE)
[17:28:02.457]                         if (has_future) {
[17:28:02.457]                           ns <- base::getNamespace("future")
[17:28:02.457]                           version <- ns[[".package"]][["version"]]
[17:28:02.457]                           if (is.null(version)) 
[17:28:02.457]                             version <- utils::packageVersion("future")
[17:28:02.457]                         }
[17:28:02.457]                         else {
[17:28:02.457]                           version <- NULL
[17:28:02.457]                         }
[17:28:02.457]                         if (!has_future || version < "1.8.0") {
[17:28:02.457]                           info <- base::c(r_version = base::gsub("R version ", 
[17:28:02.457]                             "", base::R.version$version.string), 
[17:28:02.457]                             platform = base::sprintf("%s (%s-bit)", 
[17:28:02.457]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:02.457]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:02.457]                               "release", "version")], collapse = " "), 
[17:28:02.457]                             hostname = base::Sys.info()[["nodename"]])
[17:28:02.457]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:28:02.457]                             info)
[17:28:02.457]                           info <- base::paste(info, collapse = "; ")
[17:28:02.457]                           if (!has_future) {
[17:28:02.457]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:02.457]                               info)
[17:28:02.457]                           }
[17:28:02.457]                           else {
[17:28:02.457]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:02.457]                               info, version)
[17:28:02.457]                           }
[17:28:02.457]                           base::stop(msg)
[17:28:02.457]                         }
[17:28:02.457]                       })
[17:28:02.457]                     }
[17:28:02.457]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:28:02.457]                     base::options(mc.cores = 1L)
[17:28:02.457]                   }
[17:28:02.457]                   ...future.strategy.old <- future::plan("list")
[17:28:02.457]                   options(future.plan = NULL)
[17:28:02.457]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:02.457]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:02.457]                 }
[17:28:02.457]                 ...future.workdir <- getwd()
[17:28:02.457]             }
[17:28:02.457]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:02.457]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:02.457]         }
[17:28:02.457]         base::options(future.startup.script = FALSE, future.globals.onMissing = "error", 
[17:28:02.457]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:02.457]             future.globals.onMissing = "error", future.globals.onReference = NULL, 
[17:28:02.457]             future.globals.resolve = TRUE, future.resolve.recursive = NULL, 
[17:28:02.457]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:28:02.457]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:02.457]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:02.457]             base::names(...future.oldOptions))
[17:28:02.457]     }
[17:28:02.457]     if (FALSE) {
[17:28:02.457]     }
[17:28:02.457]     else {
[17:28:02.457]         if (TRUE) {
[17:28:02.457]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:02.457]                 open = "w")
[17:28:02.457]         }
[17:28:02.457]         else {
[17:28:02.457]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:02.457]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:02.457]         }
[17:28:02.457]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:02.457]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:02.457]             base::sink(type = "output", split = FALSE)
[17:28:02.457]             base::close(...future.stdout)
[17:28:02.457]         }, add = TRUE)
[17:28:02.457]     }
[17:28:02.457]     ...future.frame <- base::sys.nframe()
[17:28:02.457]     ...future.conditions <- base::list()
[17:28:02.457]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:02.457]     if (FALSE) {
[17:28:02.457]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:02.457]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:02.457]     }
[17:28:02.457]     ...future.result <- base::tryCatch({
[17:28:02.457]         base::withCallingHandlers({
[17:28:02.457]             ...future.value <- base::withVisible(base::local({
[17:28:02.457]                 ...future.makeSendCondition <- base::local({
[17:28:02.457]                   sendCondition <- NULL
[17:28:02.457]                   function(frame = 1L) {
[17:28:02.457]                     if (is.function(sendCondition)) 
[17:28:02.457]                       return(sendCondition)
[17:28:02.457]                     ns <- getNamespace("parallel")
[17:28:02.457]                     if (exists("sendData", mode = "function", 
[17:28:02.457]                       envir = ns)) {
[17:28:02.457]                       parallel_sendData <- get("sendData", mode = "function", 
[17:28:02.457]                         envir = ns)
[17:28:02.457]                       envir <- sys.frame(frame)
[17:28:02.457]                       master <- NULL
[17:28:02.457]                       while (!identical(envir, .GlobalEnv) && 
[17:28:02.457]                         !identical(envir, emptyenv())) {
[17:28:02.457]                         if (exists("master", mode = "list", envir = envir, 
[17:28:02.457]                           inherits = FALSE)) {
[17:28:02.457]                           master <- get("master", mode = "list", 
[17:28:02.457]                             envir = envir, inherits = FALSE)
[17:28:02.457]                           if (inherits(master, c("SOCKnode", 
[17:28:02.457]                             "SOCK0node"))) {
[17:28:02.457]                             sendCondition <<- function(cond) {
[17:28:02.457]                               data <- list(type = "VALUE", value = cond, 
[17:28:02.457]                                 success = TRUE)
[17:28:02.457]                               parallel_sendData(master, data)
[17:28:02.457]                             }
[17:28:02.457]                             return(sendCondition)
[17:28:02.457]                           }
[17:28:02.457]                         }
[17:28:02.457]                         frame <- frame + 1L
[17:28:02.457]                         envir <- sys.frame(frame)
[17:28:02.457]                       }
[17:28:02.457]                     }
[17:28:02.457]                     sendCondition <<- function(cond) NULL
[17:28:02.457]                   }
[17:28:02.457]                 })
[17:28:02.457]                 withCallingHandlers({
[17:28:02.457]                   {
[17:28:02.457]                     x[["a"]] <- 1
[17:28:02.457]                     x
[17:28:02.457]                   }
[17:28:02.457]                 }, immediateCondition = function(cond) {
[17:28:02.457]                   sendCondition <- ...future.makeSendCondition()
[17:28:02.457]                   sendCondition(cond)
[17:28:02.457]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:02.457]                   {
[17:28:02.457]                     inherits <- base::inherits
[17:28:02.457]                     invokeRestart <- base::invokeRestart
[17:28:02.457]                     is.null <- base::is.null
[17:28:02.457]                     muffled <- FALSE
[17:28:02.457]                     if (inherits(cond, "message")) {
[17:28:02.457]                       muffled <- grepl(pattern, "muffleMessage")
[17:28:02.457]                       if (muffled) 
[17:28:02.457]                         invokeRestart("muffleMessage")
[17:28:02.457]                     }
[17:28:02.457]                     else if (inherits(cond, "warning")) {
[17:28:02.457]                       muffled <- grepl(pattern, "muffleWarning")
[17:28:02.457]                       if (muffled) 
[17:28:02.457]                         invokeRestart("muffleWarning")
[17:28:02.457]                     }
[17:28:02.457]                     else if (inherits(cond, "condition")) {
[17:28:02.457]                       if (!is.null(pattern)) {
[17:28:02.457]                         computeRestarts <- base::computeRestarts
[17:28:02.457]                         grepl <- base::grepl
[17:28:02.457]                         restarts <- computeRestarts(cond)
[17:28:02.457]                         for (restart in restarts) {
[17:28:02.457]                           name <- restart$name
[17:28:02.457]                           if (is.null(name)) 
[17:28:02.457]                             next
[17:28:02.457]                           if (!grepl(pattern, name)) 
[17:28:02.457]                             next
[17:28:02.457]                           invokeRestart(restart)
[17:28:02.457]                           muffled <- TRUE
[17:28:02.457]                           break
[17:28:02.457]                         }
[17:28:02.457]                       }
[17:28:02.457]                     }
[17:28:02.457]                     invisible(muffled)
[17:28:02.457]                   }
[17:28:02.457]                   muffleCondition(cond)
[17:28:02.457]                 })
[17:28:02.457]             }))
[17:28:02.457]             future::FutureResult(value = ...future.value$value, 
[17:28:02.457]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:02.457]                   ...future.rng), globalenv = if (FALSE) 
[17:28:02.457]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:02.457]                     ...future.globalenv.names))
[17:28:02.457]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:02.457]         }, condition = base::local({
[17:28:02.457]             c <- base::c
[17:28:02.457]             inherits <- base::inherits
[17:28:02.457]             invokeRestart <- base::invokeRestart
[17:28:02.457]             length <- base::length
[17:28:02.457]             list <- base::list
[17:28:02.457]             seq.int <- base::seq.int
[17:28:02.457]             signalCondition <- base::signalCondition
[17:28:02.457]             sys.calls <- base::sys.calls
[17:28:02.457]             `[[` <- base::`[[`
[17:28:02.457]             `+` <- base::`+`
[17:28:02.457]             `<<-` <- base::`<<-`
[17:28:02.457]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:02.457]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:02.457]                   3L)]
[17:28:02.457]             }
[17:28:02.457]             function(cond) {
[17:28:02.457]                 is_error <- inherits(cond, "error")
[17:28:02.457]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:02.457]                   NULL)
[17:28:02.457]                 if (is_error) {
[17:28:02.457]                   sessionInformation <- function() {
[17:28:02.457]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:02.457]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:02.457]                       search = base::search(), system = base::Sys.info())
[17:28:02.457]                   }
[17:28:02.457]                   ...future.conditions[[length(...future.conditions) + 
[17:28:02.457]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:02.457]                     cond$call), session = sessionInformation(), 
[17:28:02.457]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:02.457]                   signalCondition(cond)
[17:28:02.457]                 }
[17:28:02.457]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:02.457]                 "immediateCondition"))) {
[17:28:02.457]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:02.457]                   ...future.conditions[[length(...future.conditions) + 
[17:28:02.457]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:02.457]                   if (TRUE && !signal) {
[17:28:02.457]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:02.457]                     {
[17:28:02.457]                       inherits <- base::inherits
[17:28:02.457]                       invokeRestart <- base::invokeRestart
[17:28:02.457]                       is.null <- base::is.null
[17:28:02.457]                       muffled <- FALSE
[17:28:02.457]                       if (inherits(cond, "message")) {
[17:28:02.457]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:02.457]                         if (muffled) 
[17:28:02.457]                           invokeRestart("muffleMessage")
[17:28:02.457]                       }
[17:28:02.457]                       else if (inherits(cond, "warning")) {
[17:28:02.457]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:02.457]                         if (muffled) 
[17:28:02.457]                           invokeRestart("muffleWarning")
[17:28:02.457]                       }
[17:28:02.457]                       else if (inherits(cond, "condition")) {
[17:28:02.457]                         if (!is.null(pattern)) {
[17:28:02.457]                           computeRestarts <- base::computeRestarts
[17:28:02.457]                           grepl <- base::grepl
[17:28:02.457]                           restarts <- computeRestarts(cond)
[17:28:02.457]                           for (restart in restarts) {
[17:28:02.457]                             name <- restart$name
[17:28:02.457]                             if (is.null(name)) 
[17:28:02.457]                               next
[17:28:02.457]                             if (!grepl(pattern, name)) 
[17:28:02.457]                               next
[17:28:02.457]                             invokeRestart(restart)
[17:28:02.457]                             muffled <- TRUE
[17:28:02.457]                             break
[17:28:02.457]                           }
[17:28:02.457]                         }
[17:28:02.457]                       }
[17:28:02.457]                       invisible(muffled)
[17:28:02.457]                     }
[17:28:02.457]                     muffleCondition(cond, pattern = "^muffle")
[17:28:02.457]                   }
[17:28:02.457]                 }
[17:28:02.457]                 else {
[17:28:02.457]                   if (TRUE) {
[17:28:02.457]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:02.457]                     {
[17:28:02.457]                       inherits <- base::inherits
[17:28:02.457]                       invokeRestart <- base::invokeRestart
[17:28:02.457]                       is.null <- base::is.null
[17:28:02.457]                       muffled <- FALSE
[17:28:02.457]                       if (inherits(cond, "message")) {
[17:28:02.457]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:02.457]                         if (muffled) 
[17:28:02.457]                           invokeRestart("muffleMessage")
[17:28:02.457]                       }
[17:28:02.457]                       else if (inherits(cond, "warning")) {
[17:28:02.457]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:02.457]                         if (muffled) 
[17:28:02.457]                           invokeRestart("muffleWarning")
[17:28:02.457]                       }
[17:28:02.457]                       else if (inherits(cond, "condition")) {
[17:28:02.457]                         if (!is.null(pattern)) {
[17:28:02.457]                           computeRestarts <- base::computeRestarts
[17:28:02.457]                           grepl <- base::grepl
[17:28:02.457]                           restarts <- computeRestarts(cond)
[17:28:02.457]                           for (restart in restarts) {
[17:28:02.457]                             name <- restart$name
[17:28:02.457]                             if (is.null(name)) 
[17:28:02.457]                               next
[17:28:02.457]                             if (!grepl(pattern, name)) 
[17:28:02.457]                               next
[17:28:02.457]                             invokeRestart(restart)
[17:28:02.457]                             muffled <- TRUE
[17:28:02.457]                             break
[17:28:02.457]                           }
[17:28:02.457]                         }
[17:28:02.457]                       }
[17:28:02.457]                       invisible(muffled)
[17:28:02.457]                     }
[17:28:02.457]                     muffleCondition(cond, pattern = "^muffle")
[17:28:02.457]                   }
[17:28:02.457]                 }
[17:28:02.457]             }
[17:28:02.457]         }))
[17:28:02.457]     }, error = function(ex) {
[17:28:02.457]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:02.457]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:02.457]                 ...future.rng), started = ...future.startTime, 
[17:28:02.457]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:02.457]             version = "1.8"), class = "FutureResult")
[17:28:02.457]     }, finally = {
[17:28:02.457]         if (!identical(...future.workdir, getwd())) 
[17:28:02.457]             setwd(...future.workdir)
[17:28:02.457]         {
[17:28:02.457]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:02.457]                 ...future.oldOptions$nwarnings <- NULL
[17:28:02.457]             }
[17:28:02.457]             base::options(...future.oldOptions)
[17:28:02.457]             if (.Platform$OS.type == "windows") {
[17:28:02.457]                 old_names <- names(...future.oldEnvVars)
[17:28:02.457]                 envs <- base::Sys.getenv()
[17:28:02.457]                 names <- names(envs)
[17:28:02.457]                 common <- intersect(names, old_names)
[17:28:02.457]                 added <- setdiff(names, old_names)
[17:28:02.457]                 removed <- setdiff(old_names, names)
[17:28:02.457]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:02.457]                   envs[common]]
[17:28:02.457]                 NAMES <- toupper(changed)
[17:28:02.457]                 args <- list()
[17:28:02.457]                 for (kk in seq_along(NAMES)) {
[17:28:02.457]                   name <- changed[[kk]]
[17:28:02.457]                   NAME <- NAMES[[kk]]
[17:28:02.457]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:02.457]                     next
[17:28:02.457]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:02.457]                 }
[17:28:02.457]                 NAMES <- toupper(added)
[17:28:02.457]                 for (kk in seq_along(NAMES)) {
[17:28:02.457]                   name <- added[[kk]]
[17:28:02.457]                   NAME <- NAMES[[kk]]
[17:28:02.457]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:02.457]                     next
[17:28:02.457]                   args[[name]] <- ""
[17:28:02.457]                 }
[17:28:02.457]                 NAMES <- toupper(removed)
[17:28:02.457]                 for (kk in seq_along(NAMES)) {
[17:28:02.457]                   name <- removed[[kk]]
[17:28:02.457]                   NAME <- NAMES[[kk]]
[17:28:02.457]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:02.457]                     next
[17:28:02.457]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:02.457]                 }
[17:28:02.457]                 if (length(args) > 0) 
[17:28:02.457]                   base::do.call(base::Sys.setenv, args = args)
[17:28:02.457]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:02.457]             }
[17:28:02.457]             else {
[17:28:02.457]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:02.457]             }
[17:28:02.457]             {
[17:28:02.457]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:02.457]                   0L) {
[17:28:02.457]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:02.457]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:02.457]                   base::options(opts)
[17:28:02.457]                 }
[17:28:02.457]                 {
[17:28:02.457]                   {
[17:28:02.457]                     base::options(mc.cores = ...future.mc.cores.old)
[17:28:02.457]                     NULL
[17:28:02.457]                   }
[17:28:02.457]                   options(future.plan = NULL)
[17:28:02.457]                   if (is.na(NA_character_)) 
[17:28:02.457]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:02.457]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:02.457]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:02.457]                     .init = FALSE)
[17:28:02.457]                 }
[17:28:02.457]             }
[17:28:02.457]         }
[17:28:02.457]     })
[17:28:02.457]     if (TRUE) {
[17:28:02.457]         base::sink(type = "output", split = FALSE)
[17:28:02.457]         if (TRUE) {
[17:28:02.457]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:02.457]         }
[17:28:02.457]         else {
[17:28:02.457]             ...future.result["stdout"] <- base::list(NULL)
[17:28:02.457]         }
[17:28:02.457]         base::close(...future.stdout)
[17:28:02.457]         ...future.stdout <- NULL
[17:28:02.457]     }
[17:28:02.457]     ...future.result$conditions <- ...future.conditions
[17:28:02.457]     ...future.result$finished <- base::Sys.time()
[17:28:02.457]     ...future.result
[17:28:02.457] }
[17:28:02.464] Exporting 1 global objects (334 bytes) to cluster node #1 ...
[17:28:02.465] Exporting 'x' (31 bytes) to cluster node #1 ...
[17:28:02.465] Exporting 'x' (31 bytes) to cluster node #1 ... DONE
[17:28:02.465] Exporting 1 global objects (334 bytes) to cluster node #1 ... DONE
[17:28:02.466] MultisessionFuture started
[17:28:02.467] - Launch lazy future ... done
[17:28:02.467] run() for 'MultisessionFuture' ... done
[17:28:02.467] result() for ClusterFuture ...
[17:28:02.468] receiveMessageFromWorker() for ClusterFuture ...
[17:28:02.468] - Validating connection of MultisessionFuture
[17:28:02.494] - received message: FutureResult
[17:28:02.494] - Received FutureResult
[17:28:02.494] - Erased future from FutureRegistry
[17:28:02.494] result() for ClusterFuture ...
[17:28:02.495] - result already collected: FutureResult
[17:28:02.495] result() for ClusterFuture ... done
[17:28:02.495] receiveMessageFromWorker() for ClusterFuture ... done
[17:28:02.495] result() for ClusterFuture ... done
[17:28:02.495] result() for ClusterFuture ...
[17:28:02.495] - result already collected: FutureResult
[17:28:02.496] result() for ClusterFuture ... done
$a
[1] 1

Warning in getGlobalsAndPackages(expr, envir = envir, tweak = tweakExpression,  :
  R option 'future.globals.resolve' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'TRUE'
[17:28:02.496] getGlobalsAndPackages() ...
Warning in getGlobalsAndPackages(expr, envir = envir, tweak = tweakExpression,  :
  R option 'future.globals.onMissing' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'error'
[17:28:02.496] Searching for globals...
[17:28:02.499] - globals found: [5] '{', 'x', '<-', '[[', '[[<-'
[17:28:02.499] Searching for globals ... DONE
[17:28:02.499] Resolving globals: TRUE
[17:28:02.500] Resolving any globals that are futures ...
[17:28:02.500] - globals: [5] '{', 'x', '<-', '[[', '[[<-'
[17:28:02.500] Resolving any globals that are futures ... DONE
[17:28:02.501] Resolving futures part of globals (recursively) ...
[17:28:02.501] resolve() on list ...
[17:28:02.501]  recursive: 99
[17:28:02.501]  length: 1
[17:28:02.501]  elements: 'x'
[17:28:02.502]  length: 0 (resolved future 1)
[17:28:02.502] resolve() on list ... DONE
[17:28:02.502] - globals: [1] 'x'
[17:28:02.503] Resolving futures part of globals (recursively) ... DONE
[17:28:02.503] The total size of the 1 globals is 31 bytes (31 bytes)
[17:28:02.504] The total size of the 1 globals exported for future expression ('{; x[["a"]] <- 1; x; }') is 31 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (31 bytes of class 'list')
[17:28:02.504] - globals: [1] 'x'
[17:28:02.504] 
[17:28:02.504] getGlobalsAndPackages() ... DONE
[17:28:02.505] run() for 'Future' ...
[17:28:02.505] - state: 'created'
[17:28:02.505] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:28:02.521] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:28:02.521] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:28:02.522]   - Field: 'node'
[17:28:02.522]   - Field: 'label'
[17:28:02.522]   - Field: 'local'
[17:28:02.522]   - Field: 'owner'
[17:28:02.522]   - Field: 'envir'
[17:28:02.523]   - Field: 'workers'
[17:28:02.523]   - Field: 'packages'
[17:28:02.523]   - Field: 'gc'
[17:28:02.523]   - Field: 'conditions'
[17:28:02.523]   - Field: 'persistent'
[17:28:02.523]   - Field: 'expr'
[17:28:02.524]   - Field: 'uuid'
[17:28:02.524]   - Field: 'seed'
[17:28:02.524]   - Field: 'version'
[17:28:02.524]   - Field: 'result'
[17:28:02.524]   - Field: 'asynchronous'
[17:28:02.524]   - Field: 'calls'
[17:28:02.525]   - Field: 'globals'
[17:28:02.525]   - Field: 'stdout'
[17:28:02.525]   - Field: 'earlySignal'
[17:28:02.525]   - Field: 'lazy'
[17:28:02.525]   - Field: 'state'
[17:28:02.526] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:28:02.526] - Launch lazy future ...
[17:28:02.526] Packages needed by the future expression (n = 0): <none>
[17:28:02.526] Packages needed by future strategies (n = 0): <none>
[17:28:02.527] {
[17:28:02.527]     {
[17:28:02.527]         {
[17:28:02.527]             ...future.startTime <- base::Sys.time()
[17:28:02.527]             {
[17:28:02.527]                 {
[17:28:02.527]                   {
[17:28:02.527]                     {
[17:28:02.527]                       base::local({
[17:28:02.527]                         has_future <- base::requireNamespace("future", 
[17:28:02.527]                           quietly = TRUE)
[17:28:02.527]                         if (has_future) {
[17:28:02.527]                           ns <- base::getNamespace("future")
[17:28:02.527]                           version <- ns[[".package"]][["version"]]
[17:28:02.527]                           if (is.null(version)) 
[17:28:02.527]                             version <- utils::packageVersion("future")
[17:28:02.527]                         }
[17:28:02.527]                         else {
[17:28:02.527]                           version <- NULL
[17:28:02.527]                         }
[17:28:02.527]                         if (!has_future || version < "1.8.0") {
[17:28:02.527]                           info <- base::c(r_version = base::gsub("R version ", 
[17:28:02.527]                             "", base::R.version$version.string), 
[17:28:02.527]                             platform = base::sprintf("%s (%s-bit)", 
[17:28:02.527]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:02.527]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:02.527]                               "release", "version")], collapse = " "), 
[17:28:02.527]                             hostname = base::Sys.info()[["nodename"]])
[17:28:02.527]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:28:02.527]                             info)
[17:28:02.527]                           info <- base::paste(info, collapse = "; ")
[17:28:02.527]                           if (!has_future) {
[17:28:02.527]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:02.527]                               info)
[17:28:02.527]                           }
[17:28:02.527]                           else {
[17:28:02.527]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:02.527]                               info, version)
[17:28:02.527]                           }
[17:28:02.527]                           base::stop(msg)
[17:28:02.527]                         }
[17:28:02.527]                       })
[17:28:02.527]                     }
[17:28:02.527]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:28:02.527]                     base::options(mc.cores = 1L)
[17:28:02.527]                   }
[17:28:02.527]                   ...future.strategy.old <- future::plan("list")
[17:28:02.527]                   options(future.plan = NULL)
[17:28:02.527]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:02.527]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:02.527]                 }
[17:28:02.527]                 ...future.workdir <- getwd()
[17:28:02.527]             }
[17:28:02.527]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:02.527]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:02.527]         }
[17:28:02.527]         base::options(future.startup.script = FALSE, future.globals.onMissing = "error", 
[17:28:02.527]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:02.527]             future.globals.onMissing = "error", future.globals.onReference = NULL, 
[17:28:02.527]             future.globals.resolve = TRUE, future.resolve.recursive = NULL, 
[17:28:02.527]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:28:02.527]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:02.527]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:02.527]             base::names(...future.oldOptions))
[17:28:02.527]     }
[17:28:02.527]     if (FALSE) {
[17:28:02.527]     }
[17:28:02.527]     else {
[17:28:02.527]         if (TRUE) {
[17:28:02.527]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:02.527]                 open = "w")
[17:28:02.527]         }
[17:28:02.527]         else {
[17:28:02.527]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:02.527]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:02.527]         }
[17:28:02.527]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:02.527]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:02.527]             base::sink(type = "output", split = FALSE)
[17:28:02.527]             base::close(...future.stdout)
[17:28:02.527]         }, add = TRUE)
[17:28:02.527]     }
[17:28:02.527]     ...future.frame <- base::sys.nframe()
[17:28:02.527]     ...future.conditions <- base::list()
[17:28:02.527]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:02.527]     if (FALSE) {
[17:28:02.527]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:02.527]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:02.527]     }
[17:28:02.527]     ...future.result <- base::tryCatch({
[17:28:02.527]         base::withCallingHandlers({
[17:28:02.527]             ...future.value <- base::withVisible(base::local({
[17:28:02.527]                 ...future.makeSendCondition <- base::local({
[17:28:02.527]                   sendCondition <- NULL
[17:28:02.527]                   function(frame = 1L) {
[17:28:02.527]                     if (is.function(sendCondition)) 
[17:28:02.527]                       return(sendCondition)
[17:28:02.527]                     ns <- getNamespace("parallel")
[17:28:02.527]                     if (exists("sendData", mode = "function", 
[17:28:02.527]                       envir = ns)) {
[17:28:02.527]                       parallel_sendData <- get("sendData", mode = "function", 
[17:28:02.527]                         envir = ns)
[17:28:02.527]                       envir <- sys.frame(frame)
[17:28:02.527]                       master <- NULL
[17:28:02.527]                       while (!identical(envir, .GlobalEnv) && 
[17:28:02.527]                         !identical(envir, emptyenv())) {
[17:28:02.527]                         if (exists("master", mode = "list", envir = envir, 
[17:28:02.527]                           inherits = FALSE)) {
[17:28:02.527]                           master <- get("master", mode = "list", 
[17:28:02.527]                             envir = envir, inherits = FALSE)
[17:28:02.527]                           if (inherits(master, c("SOCKnode", 
[17:28:02.527]                             "SOCK0node"))) {
[17:28:02.527]                             sendCondition <<- function(cond) {
[17:28:02.527]                               data <- list(type = "VALUE", value = cond, 
[17:28:02.527]                                 success = TRUE)
[17:28:02.527]                               parallel_sendData(master, data)
[17:28:02.527]                             }
[17:28:02.527]                             return(sendCondition)
[17:28:02.527]                           }
[17:28:02.527]                         }
[17:28:02.527]                         frame <- frame + 1L
[17:28:02.527]                         envir <- sys.frame(frame)
[17:28:02.527]                       }
[17:28:02.527]                     }
[17:28:02.527]                     sendCondition <<- function(cond) NULL
[17:28:02.527]                   }
[17:28:02.527]                 })
[17:28:02.527]                 withCallingHandlers({
[17:28:02.527]                   {
[17:28:02.527]                     x[["a"]] <- 1
[17:28:02.527]                     x
[17:28:02.527]                   }
[17:28:02.527]                 }, immediateCondition = function(cond) {
[17:28:02.527]                   sendCondition <- ...future.makeSendCondition()
[17:28:02.527]                   sendCondition(cond)
[17:28:02.527]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:02.527]                   {
[17:28:02.527]                     inherits <- base::inherits
[17:28:02.527]                     invokeRestart <- base::invokeRestart
[17:28:02.527]                     is.null <- base::is.null
[17:28:02.527]                     muffled <- FALSE
[17:28:02.527]                     if (inherits(cond, "message")) {
[17:28:02.527]                       muffled <- grepl(pattern, "muffleMessage")
[17:28:02.527]                       if (muffled) 
[17:28:02.527]                         invokeRestart("muffleMessage")
[17:28:02.527]                     }
[17:28:02.527]                     else if (inherits(cond, "warning")) {
[17:28:02.527]                       muffled <- grepl(pattern, "muffleWarning")
[17:28:02.527]                       if (muffled) 
[17:28:02.527]                         invokeRestart("muffleWarning")
[17:28:02.527]                     }
[17:28:02.527]                     else if (inherits(cond, "condition")) {
[17:28:02.527]                       if (!is.null(pattern)) {
[17:28:02.527]                         computeRestarts <- base::computeRestarts
[17:28:02.527]                         grepl <- base::grepl
[17:28:02.527]                         restarts <- computeRestarts(cond)
[17:28:02.527]                         for (restart in restarts) {
[17:28:02.527]                           name <- restart$name
[17:28:02.527]                           if (is.null(name)) 
[17:28:02.527]                             next
[17:28:02.527]                           if (!grepl(pattern, name)) 
[17:28:02.527]                             next
[17:28:02.527]                           invokeRestart(restart)
[17:28:02.527]                           muffled <- TRUE
[17:28:02.527]                           break
[17:28:02.527]                         }
[17:28:02.527]                       }
[17:28:02.527]                     }
[17:28:02.527]                     invisible(muffled)
[17:28:02.527]                   }
[17:28:02.527]                   muffleCondition(cond)
[17:28:02.527]                 })
[17:28:02.527]             }))
[17:28:02.527]             future::FutureResult(value = ...future.value$value, 
[17:28:02.527]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:02.527]                   ...future.rng), globalenv = if (FALSE) 
[17:28:02.527]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:02.527]                     ...future.globalenv.names))
[17:28:02.527]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:02.527]         }, condition = base::local({
[17:28:02.527]             c <- base::c
[17:28:02.527]             inherits <- base::inherits
[17:28:02.527]             invokeRestart <- base::invokeRestart
[17:28:02.527]             length <- base::length
[17:28:02.527]             list <- base::list
[17:28:02.527]             seq.int <- base::seq.int
[17:28:02.527]             signalCondition <- base::signalCondition
[17:28:02.527]             sys.calls <- base::sys.calls
[17:28:02.527]             `[[` <- base::`[[`
[17:28:02.527]             `+` <- base::`+`
[17:28:02.527]             `<<-` <- base::`<<-`
[17:28:02.527]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:02.527]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:02.527]                   3L)]
[17:28:02.527]             }
[17:28:02.527]             function(cond) {
[17:28:02.527]                 is_error <- inherits(cond, "error")
[17:28:02.527]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:02.527]                   NULL)
[17:28:02.527]                 if (is_error) {
[17:28:02.527]                   sessionInformation <- function() {
[17:28:02.527]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:02.527]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:02.527]                       search = base::search(), system = base::Sys.info())
[17:28:02.527]                   }
[17:28:02.527]                   ...future.conditions[[length(...future.conditions) + 
[17:28:02.527]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:02.527]                     cond$call), session = sessionInformation(), 
[17:28:02.527]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:02.527]                   signalCondition(cond)
[17:28:02.527]                 }
[17:28:02.527]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:02.527]                 "immediateCondition"))) {
[17:28:02.527]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:02.527]                   ...future.conditions[[length(...future.conditions) + 
[17:28:02.527]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:02.527]                   if (TRUE && !signal) {
[17:28:02.527]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:02.527]                     {
[17:28:02.527]                       inherits <- base::inherits
[17:28:02.527]                       invokeRestart <- base::invokeRestart
[17:28:02.527]                       is.null <- base::is.null
[17:28:02.527]                       muffled <- FALSE
[17:28:02.527]                       if (inherits(cond, "message")) {
[17:28:02.527]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:02.527]                         if (muffled) 
[17:28:02.527]                           invokeRestart("muffleMessage")
[17:28:02.527]                       }
[17:28:02.527]                       else if (inherits(cond, "warning")) {
[17:28:02.527]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:02.527]                         if (muffled) 
[17:28:02.527]                           invokeRestart("muffleWarning")
[17:28:02.527]                       }
[17:28:02.527]                       else if (inherits(cond, "condition")) {
[17:28:02.527]                         if (!is.null(pattern)) {
[17:28:02.527]                           computeRestarts <- base::computeRestarts
[17:28:02.527]                           grepl <- base::grepl
[17:28:02.527]                           restarts <- computeRestarts(cond)
[17:28:02.527]                           for (restart in restarts) {
[17:28:02.527]                             name <- restart$name
[17:28:02.527]                             if (is.null(name)) 
[17:28:02.527]                               next
[17:28:02.527]                             if (!grepl(pattern, name)) 
[17:28:02.527]                               next
[17:28:02.527]                             invokeRestart(restart)
[17:28:02.527]                             muffled <- TRUE
[17:28:02.527]                             break
[17:28:02.527]                           }
[17:28:02.527]                         }
[17:28:02.527]                       }
[17:28:02.527]                       invisible(muffled)
[17:28:02.527]                     }
[17:28:02.527]                     muffleCondition(cond, pattern = "^muffle")
[17:28:02.527]                   }
[17:28:02.527]                 }
[17:28:02.527]                 else {
[17:28:02.527]                   if (TRUE) {
[17:28:02.527]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:02.527]                     {
[17:28:02.527]                       inherits <- base::inherits
[17:28:02.527]                       invokeRestart <- base::invokeRestart
[17:28:02.527]                       is.null <- base::is.null
[17:28:02.527]                       muffled <- FALSE
[17:28:02.527]                       if (inherits(cond, "message")) {
[17:28:02.527]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:02.527]                         if (muffled) 
[17:28:02.527]                           invokeRestart("muffleMessage")
[17:28:02.527]                       }
[17:28:02.527]                       else if (inherits(cond, "warning")) {
[17:28:02.527]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:02.527]                         if (muffled) 
[17:28:02.527]                           invokeRestart("muffleWarning")
[17:28:02.527]                       }
[17:28:02.527]                       else if (inherits(cond, "condition")) {
[17:28:02.527]                         if (!is.null(pattern)) {
[17:28:02.527]                           computeRestarts <- base::computeRestarts
[17:28:02.527]                           grepl <- base::grepl
[17:28:02.527]                           restarts <- computeRestarts(cond)
[17:28:02.527]                           for (restart in restarts) {
[17:28:02.527]                             name <- restart$name
[17:28:02.527]                             if (is.null(name)) 
[17:28:02.527]                               next
[17:28:02.527]                             if (!grepl(pattern, name)) 
[17:28:02.527]                               next
[17:28:02.527]                             invokeRestart(restart)
[17:28:02.527]                             muffled <- TRUE
[17:28:02.527]                             break
[17:28:02.527]                           }
[17:28:02.527]                         }
[17:28:02.527]                       }
[17:28:02.527]                       invisible(muffled)
[17:28:02.527]                     }
[17:28:02.527]                     muffleCondition(cond, pattern = "^muffle")
[17:28:02.527]                   }
[17:28:02.527]                 }
[17:28:02.527]             }
[17:28:02.527]         }))
[17:28:02.527]     }, error = function(ex) {
[17:28:02.527]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:02.527]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:02.527]                 ...future.rng), started = ...future.startTime, 
[17:28:02.527]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:02.527]             version = "1.8"), class = "FutureResult")
[17:28:02.527]     }, finally = {
[17:28:02.527]         if (!identical(...future.workdir, getwd())) 
[17:28:02.527]             setwd(...future.workdir)
[17:28:02.527]         {
[17:28:02.527]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:02.527]                 ...future.oldOptions$nwarnings <- NULL
[17:28:02.527]             }
[17:28:02.527]             base::options(...future.oldOptions)
[17:28:02.527]             if (.Platform$OS.type == "windows") {
[17:28:02.527]                 old_names <- names(...future.oldEnvVars)
[17:28:02.527]                 envs <- base::Sys.getenv()
[17:28:02.527]                 names <- names(envs)
[17:28:02.527]                 common <- intersect(names, old_names)
[17:28:02.527]                 added <- setdiff(names, old_names)
[17:28:02.527]                 removed <- setdiff(old_names, names)
[17:28:02.527]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:02.527]                   envs[common]]
[17:28:02.527]                 NAMES <- toupper(changed)
[17:28:02.527]                 args <- list()
[17:28:02.527]                 for (kk in seq_along(NAMES)) {
[17:28:02.527]                   name <- changed[[kk]]
[17:28:02.527]                   NAME <- NAMES[[kk]]
[17:28:02.527]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:02.527]                     next
[17:28:02.527]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:02.527]                 }
[17:28:02.527]                 NAMES <- toupper(added)
[17:28:02.527]                 for (kk in seq_along(NAMES)) {
[17:28:02.527]                   name <- added[[kk]]
[17:28:02.527]                   NAME <- NAMES[[kk]]
[17:28:02.527]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:02.527]                     next
[17:28:02.527]                   args[[name]] <- ""
[17:28:02.527]                 }
[17:28:02.527]                 NAMES <- toupper(removed)
[17:28:02.527]                 for (kk in seq_along(NAMES)) {
[17:28:02.527]                   name <- removed[[kk]]
[17:28:02.527]                   NAME <- NAMES[[kk]]
[17:28:02.527]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:02.527]                     next
[17:28:02.527]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:02.527]                 }
[17:28:02.527]                 if (length(args) > 0) 
[17:28:02.527]                   base::do.call(base::Sys.setenv, args = args)
[17:28:02.527]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:02.527]             }
[17:28:02.527]             else {
[17:28:02.527]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:02.527]             }
[17:28:02.527]             {
[17:28:02.527]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:02.527]                   0L) {
[17:28:02.527]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:02.527]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:02.527]                   base::options(opts)
[17:28:02.527]                 }
[17:28:02.527]                 {
[17:28:02.527]                   {
[17:28:02.527]                     base::options(mc.cores = ...future.mc.cores.old)
[17:28:02.527]                     NULL
[17:28:02.527]                   }
[17:28:02.527]                   options(future.plan = NULL)
[17:28:02.527]                   if (is.na(NA_character_)) 
[17:28:02.527]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:02.527]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:02.527]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:02.527]                     .init = FALSE)
[17:28:02.527]                 }
[17:28:02.527]             }
[17:28:02.527]         }
[17:28:02.527]     })
[17:28:02.527]     if (TRUE) {
[17:28:02.527]         base::sink(type = "output", split = FALSE)
[17:28:02.527]         if (TRUE) {
[17:28:02.527]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:02.527]         }
[17:28:02.527]         else {
[17:28:02.527]             ...future.result["stdout"] <- base::list(NULL)
[17:28:02.527]         }
[17:28:02.527]         base::close(...future.stdout)
[17:28:02.527]         ...future.stdout <- NULL
[17:28:02.527]     }
[17:28:02.527]     ...future.result$conditions <- ...future.conditions
[17:28:02.527]     ...future.result$finished <- base::Sys.time()
[17:28:02.527]     ...future.result
[17:28:02.527] }
[17:28:02.534] Exporting 1 global objects (334 bytes) to cluster node #1 ...
[17:28:02.535] Exporting 'x' (31 bytes) to cluster node #1 ...
[17:28:02.535] Exporting 'x' (31 bytes) to cluster node #1 ... DONE
[17:28:02.536] Exporting 1 global objects (334 bytes) to cluster node #1 ... DONE
[17:28:02.536] MultisessionFuture started
[17:28:02.537] - Launch lazy future ... done
[17:28:02.537] run() for 'MultisessionFuture' ... done
[17:28:02.537] result() for ClusterFuture ...
[17:28:02.537] receiveMessageFromWorker() for ClusterFuture ...
[17:28:02.537] - Validating connection of MultisessionFuture
[17:28:02.556] - received message: FutureResult
[17:28:02.557] - Received FutureResult
[17:28:02.557] - Erased future from FutureRegistry
[17:28:02.557] result() for ClusterFuture ...
[17:28:02.557] - result already collected: FutureResult
[17:28:02.558] result() for ClusterFuture ... done
[17:28:02.558] receiveMessageFromWorker() for ClusterFuture ... done
[17:28:02.558] result() for ClusterFuture ... done
[17:28:02.558] result() for ClusterFuture ...
[17:28:02.558] - result already collected: FutureResult
[17:28:02.558] result() for ClusterFuture ... done
$a
[1] 1

Warning in getGlobalsAndPackages(expr, envir = envir, tweak = tweakExpression,  :
  R option 'future.globals.resolve' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'TRUE'
[17:28:02.559] getGlobalsAndPackages() ...
Warning in getGlobalsAndPackages(expr, envir = envir, tweak = tweakExpression,  :
  R option 'future.globals.onMissing' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'error'
[17:28:02.559] Searching for globals...
[17:28:02.562] - globals found: [5] '{', 'x', '<-', '[[', '[[<-'
[17:28:02.562] Searching for globals ... DONE
[17:28:02.563] Resolving globals: TRUE
[17:28:02.563] Resolving any globals that are futures ...
[17:28:02.563] - globals: [5] '{', 'x', '<-', '[[', '[[<-'
[17:28:02.563] Resolving any globals that are futures ... DONE
[17:28:02.564] Resolving futures part of globals (recursively) ...
[17:28:02.564] resolve() on list ...
[17:28:02.564]  recursive: 99
[17:28:02.565]  length: 1
[17:28:02.565]  elements: 'x'
[17:28:02.565]  length: 0 (resolved future 1)
[17:28:02.565] resolve() on list ... DONE
[17:28:02.565] - globals: [1] 'x'
[17:28:02.565] Resolving futures part of globals (recursively) ... DONE
[17:28:02.566] The total size of the 1 globals is 31 bytes (31 bytes)
[17:28:02.566] The total size of the 1 globals exported for future expression ('{; x[["a"]] <- 1; x; }') is 31 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (31 bytes of class 'list')
[17:28:02.566] - globals: [1] 'x'
[17:28:02.567] 
[17:28:02.567] getGlobalsAndPackages() ... DONE
[17:28:02.567] run() for 'Future' ...
[17:28:02.567] - state: 'created'
[17:28:02.568] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:28:02.587] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:28:02.587] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:28:02.587]   - Field: 'node'
[17:28:02.587]   - Field: 'label'
[17:28:02.588]   - Field: 'local'
[17:28:02.588]   - Field: 'owner'
[17:28:02.588]   - Field: 'envir'
[17:28:02.588]   - Field: 'workers'
[17:28:02.588]   - Field: 'packages'
[17:28:02.588]   - Field: 'gc'
[17:28:02.589]   - Field: 'conditions'
[17:28:02.589]   - Field: 'persistent'
[17:28:02.589]   - Field: 'expr'
[17:28:02.589]   - Field: 'uuid'
[17:28:02.589]   - Field: 'seed'
[17:28:02.589]   - Field: 'version'
[17:28:02.590]   - Field: 'result'
[17:28:02.590]   - Field: 'asynchronous'
[17:28:02.590]   - Field: 'calls'
[17:28:02.590]   - Field: 'globals'
[17:28:02.590]   - Field: 'stdout'
[17:28:02.591]   - Field: 'earlySignal'
[17:28:02.591]   - Field: 'lazy'
[17:28:02.591]   - Field: 'state'
[17:28:02.591] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:28:02.591] - Launch lazy future ...
[17:28:02.592] Packages needed by the future expression (n = 0): <none>
[17:28:02.592] Packages needed by future strategies (n = 0): <none>
[17:28:02.592] {
[17:28:02.592]     {
[17:28:02.592]         {
[17:28:02.592]             ...future.startTime <- base::Sys.time()
[17:28:02.592]             {
[17:28:02.592]                 {
[17:28:02.592]                   {
[17:28:02.592]                     {
[17:28:02.592]                       base::local({
[17:28:02.592]                         has_future <- base::requireNamespace("future", 
[17:28:02.592]                           quietly = TRUE)
[17:28:02.592]                         if (has_future) {
[17:28:02.592]                           ns <- base::getNamespace("future")
[17:28:02.592]                           version <- ns[[".package"]][["version"]]
[17:28:02.592]                           if (is.null(version)) 
[17:28:02.592]                             version <- utils::packageVersion("future")
[17:28:02.592]                         }
[17:28:02.592]                         else {
[17:28:02.592]                           version <- NULL
[17:28:02.592]                         }
[17:28:02.592]                         if (!has_future || version < "1.8.0") {
[17:28:02.592]                           info <- base::c(r_version = base::gsub("R version ", 
[17:28:02.592]                             "", base::R.version$version.string), 
[17:28:02.592]                             platform = base::sprintf("%s (%s-bit)", 
[17:28:02.592]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:02.592]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:02.592]                               "release", "version")], collapse = " "), 
[17:28:02.592]                             hostname = base::Sys.info()[["nodename"]])
[17:28:02.592]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:28:02.592]                             info)
[17:28:02.592]                           info <- base::paste(info, collapse = "; ")
[17:28:02.592]                           if (!has_future) {
[17:28:02.592]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:02.592]                               info)
[17:28:02.592]                           }
[17:28:02.592]                           else {
[17:28:02.592]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:02.592]                               info, version)
[17:28:02.592]                           }
[17:28:02.592]                           base::stop(msg)
[17:28:02.592]                         }
[17:28:02.592]                       })
[17:28:02.592]                     }
[17:28:02.592]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:28:02.592]                     base::options(mc.cores = 1L)
[17:28:02.592]                   }
[17:28:02.592]                   ...future.strategy.old <- future::plan("list")
[17:28:02.592]                   options(future.plan = NULL)
[17:28:02.592]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:02.592]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:02.592]                 }
[17:28:02.592]                 ...future.workdir <- getwd()
[17:28:02.592]             }
[17:28:02.592]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:02.592]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:02.592]         }
[17:28:02.592]         base::options(future.startup.script = FALSE, future.globals.onMissing = "error", 
[17:28:02.592]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:02.592]             future.globals.onMissing = "error", future.globals.onReference = NULL, 
[17:28:02.592]             future.globals.resolve = TRUE, future.resolve.recursive = NULL, 
[17:28:02.592]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:28:02.592]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:02.592]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:02.592]             base::names(...future.oldOptions))
[17:28:02.592]     }
[17:28:02.592]     if (FALSE) {
[17:28:02.592]     }
[17:28:02.592]     else {
[17:28:02.592]         if (TRUE) {
[17:28:02.592]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:02.592]                 open = "w")
[17:28:02.592]         }
[17:28:02.592]         else {
[17:28:02.592]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:02.592]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:02.592]         }
[17:28:02.592]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:02.592]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:02.592]             base::sink(type = "output", split = FALSE)
[17:28:02.592]             base::close(...future.stdout)
[17:28:02.592]         }, add = TRUE)
[17:28:02.592]     }
[17:28:02.592]     ...future.frame <- base::sys.nframe()
[17:28:02.592]     ...future.conditions <- base::list()
[17:28:02.592]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:02.592]     if (FALSE) {
[17:28:02.592]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:02.592]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:02.592]     }
[17:28:02.592]     ...future.result <- base::tryCatch({
[17:28:02.592]         base::withCallingHandlers({
[17:28:02.592]             ...future.value <- base::withVisible(base::local({
[17:28:02.592]                 ...future.makeSendCondition <- base::local({
[17:28:02.592]                   sendCondition <- NULL
[17:28:02.592]                   function(frame = 1L) {
[17:28:02.592]                     if (is.function(sendCondition)) 
[17:28:02.592]                       return(sendCondition)
[17:28:02.592]                     ns <- getNamespace("parallel")
[17:28:02.592]                     if (exists("sendData", mode = "function", 
[17:28:02.592]                       envir = ns)) {
[17:28:02.592]                       parallel_sendData <- get("sendData", mode = "function", 
[17:28:02.592]                         envir = ns)
[17:28:02.592]                       envir <- sys.frame(frame)
[17:28:02.592]                       master <- NULL
[17:28:02.592]                       while (!identical(envir, .GlobalEnv) && 
[17:28:02.592]                         !identical(envir, emptyenv())) {
[17:28:02.592]                         if (exists("master", mode = "list", envir = envir, 
[17:28:02.592]                           inherits = FALSE)) {
[17:28:02.592]                           master <- get("master", mode = "list", 
[17:28:02.592]                             envir = envir, inherits = FALSE)
[17:28:02.592]                           if (inherits(master, c("SOCKnode", 
[17:28:02.592]                             "SOCK0node"))) {
[17:28:02.592]                             sendCondition <<- function(cond) {
[17:28:02.592]                               data <- list(type = "VALUE", value = cond, 
[17:28:02.592]                                 success = TRUE)
[17:28:02.592]                               parallel_sendData(master, data)
[17:28:02.592]                             }
[17:28:02.592]                             return(sendCondition)
[17:28:02.592]                           }
[17:28:02.592]                         }
[17:28:02.592]                         frame <- frame + 1L
[17:28:02.592]                         envir <- sys.frame(frame)
[17:28:02.592]                       }
[17:28:02.592]                     }
[17:28:02.592]                     sendCondition <<- function(cond) NULL
[17:28:02.592]                   }
[17:28:02.592]                 })
[17:28:02.592]                 withCallingHandlers({
[17:28:02.592]                   {
[17:28:02.592]                     x[["a"]] <- 1
[17:28:02.592]                     x
[17:28:02.592]                   }
[17:28:02.592]                 }, immediateCondition = function(cond) {
[17:28:02.592]                   sendCondition <- ...future.makeSendCondition()
[17:28:02.592]                   sendCondition(cond)
[17:28:02.592]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:02.592]                   {
[17:28:02.592]                     inherits <- base::inherits
[17:28:02.592]                     invokeRestart <- base::invokeRestart
[17:28:02.592]                     is.null <- base::is.null
[17:28:02.592]                     muffled <- FALSE
[17:28:02.592]                     if (inherits(cond, "message")) {
[17:28:02.592]                       muffled <- grepl(pattern, "muffleMessage")
[17:28:02.592]                       if (muffled) 
[17:28:02.592]                         invokeRestart("muffleMessage")
[17:28:02.592]                     }
[17:28:02.592]                     else if (inherits(cond, "warning")) {
[17:28:02.592]                       muffled <- grepl(pattern, "muffleWarning")
[17:28:02.592]                       if (muffled) 
[17:28:02.592]                         invokeRestart("muffleWarning")
[17:28:02.592]                     }
[17:28:02.592]                     else if (inherits(cond, "condition")) {
[17:28:02.592]                       if (!is.null(pattern)) {
[17:28:02.592]                         computeRestarts <- base::computeRestarts
[17:28:02.592]                         grepl <- base::grepl
[17:28:02.592]                         restarts <- computeRestarts(cond)
[17:28:02.592]                         for (restart in restarts) {
[17:28:02.592]                           name <- restart$name
[17:28:02.592]                           if (is.null(name)) 
[17:28:02.592]                             next
[17:28:02.592]                           if (!grepl(pattern, name)) 
[17:28:02.592]                             next
[17:28:02.592]                           invokeRestart(restart)
[17:28:02.592]                           muffled <- TRUE
[17:28:02.592]                           break
[17:28:02.592]                         }
[17:28:02.592]                       }
[17:28:02.592]                     }
[17:28:02.592]                     invisible(muffled)
[17:28:02.592]                   }
[17:28:02.592]                   muffleCondition(cond)
[17:28:02.592]                 })
[17:28:02.592]             }))
[17:28:02.592]             future::FutureResult(value = ...future.value$value, 
[17:28:02.592]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:02.592]                   ...future.rng), globalenv = if (FALSE) 
[17:28:02.592]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:02.592]                     ...future.globalenv.names))
[17:28:02.592]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:02.592]         }, condition = base::local({
[17:28:02.592]             c <- base::c
[17:28:02.592]             inherits <- base::inherits
[17:28:02.592]             invokeRestart <- base::invokeRestart
[17:28:02.592]             length <- base::length
[17:28:02.592]             list <- base::list
[17:28:02.592]             seq.int <- base::seq.int
[17:28:02.592]             signalCondition <- base::signalCondition
[17:28:02.592]             sys.calls <- base::sys.calls
[17:28:02.592]             `[[` <- base::`[[`
[17:28:02.592]             `+` <- base::`+`
[17:28:02.592]             `<<-` <- base::`<<-`
[17:28:02.592]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:02.592]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:02.592]                   3L)]
[17:28:02.592]             }
[17:28:02.592]             function(cond) {
[17:28:02.592]                 is_error <- inherits(cond, "error")
[17:28:02.592]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:02.592]                   NULL)
[17:28:02.592]                 if (is_error) {
[17:28:02.592]                   sessionInformation <- function() {
[17:28:02.592]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:02.592]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:02.592]                       search = base::search(), system = base::Sys.info())
[17:28:02.592]                   }
[17:28:02.592]                   ...future.conditions[[length(...future.conditions) + 
[17:28:02.592]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:02.592]                     cond$call), session = sessionInformation(), 
[17:28:02.592]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:02.592]                   signalCondition(cond)
[17:28:02.592]                 }
[17:28:02.592]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:02.592]                 "immediateCondition"))) {
[17:28:02.592]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:02.592]                   ...future.conditions[[length(...future.conditions) + 
[17:28:02.592]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:02.592]                   if (TRUE && !signal) {
[17:28:02.592]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:02.592]                     {
[17:28:02.592]                       inherits <- base::inherits
[17:28:02.592]                       invokeRestart <- base::invokeRestart
[17:28:02.592]                       is.null <- base::is.null
[17:28:02.592]                       muffled <- FALSE
[17:28:02.592]                       if (inherits(cond, "message")) {
[17:28:02.592]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:02.592]                         if (muffled) 
[17:28:02.592]                           invokeRestart("muffleMessage")
[17:28:02.592]                       }
[17:28:02.592]                       else if (inherits(cond, "warning")) {
[17:28:02.592]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:02.592]                         if (muffled) 
[17:28:02.592]                           invokeRestart("muffleWarning")
[17:28:02.592]                       }
[17:28:02.592]                       else if (inherits(cond, "condition")) {
[17:28:02.592]                         if (!is.null(pattern)) {
[17:28:02.592]                           computeRestarts <- base::computeRestarts
[17:28:02.592]                           grepl <- base::grepl
[17:28:02.592]                           restarts <- computeRestarts(cond)
[17:28:02.592]                           for (restart in restarts) {
[17:28:02.592]                             name <- restart$name
[17:28:02.592]                             if (is.null(name)) 
[17:28:02.592]                               next
[17:28:02.592]                             if (!grepl(pattern, name)) 
[17:28:02.592]                               next
[17:28:02.592]                             invokeRestart(restart)
[17:28:02.592]                             muffled <- TRUE
[17:28:02.592]                             break
[17:28:02.592]                           }
[17:28:02.592]                         }
[17:28:02.592]                       }
[17:28:02.592]                       invisible(muffled)
[17:28:02.592]                     }
[17:28:02.592]                     muffleCondition(cond, pattern = "^muffle")
[17:28:02.592]                   }
[17:28:02.592]                 }
[17:28:02.592]                 else {
[17:28:02.592]                   if (TRUE) {
[17:28:02.592]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:02.592]                     {
[17:28:02.592]                       inherits <- base::inherits
[17:28:02.592]                       invokeRestart <- base::invokeRestart
[17:28:02.592]                       is.null <- base::is.null
[17:28:02.592]                       muffled <- FALSE
[17:28:02.592]                       if (inherits(cond, "message")) {
[17:28:02.592]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:02.592]                         if (muffled) 
[17:28:02.592]                           invokeRestart("muffleMessage")
[17:28:02.592]                       }
[17:28:02.592]                       else if (inherits(cond, "warning")) {
[17:28:02.592]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:02.592]                         if (muffled) 
[17:28:02.592]                           invokeRestart("muffleWarning")
[17:28:02.592]                       }
[17:28:02.592]                       else if (inherits(cond, "condition")) {
[17:28:02.592]                         if (!is.null(pattern)) {
[17:28:02.592]                           computeRestarts <- base::computeRestarts
[17:28:02.592]                           grepl <- base::grepl
[17:28:02.592]                           restarts <- computeRestarts(cond)
[17:28:02.592]                           for (restart in restarts) {
[17:28:02.592]                             name <- restart$name
[17:28:02.592]                             if (is.null(name)) 
[17:28:02.592]                               next
[17:28:02.592]                             if (!grepl(pattern, name)) 
[17:28:02.592]                               next
[17:28:02.592]                             invokeRestart(restart)
[17:28:02.592]                             muffled <- TRUE
[17:28:02.592]                             break
[17:28:02.592]                           }
[17:28:02.592]                         }
[17:28:02.592]                       }
[17:28:02.592]                       invisible(muffled)
[17:28:02.592]                     }
[17:28:02.592]                     muffleCondition(cond, pattern = "^muffle")
[17:28:02.592]                   }
[17:28:02.592]                 }
[17:28:02.592]             }
[17:28:02.592]         }))
[17:28:02.592]     }, error = function(ex) {
[17:28:02.592]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:02.592]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:02.592]                 ...future.rng), started = ...future.startTime, 
[17:28:02.592]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:02.592]             version = "1.8"), class = "FutureResult")
[17:28:02.592]     }, finally = {
[17:28:02.592]         if (!identical(...future.workdir, getwd())) 
[17:28:02.592]             setwd(...future.workdir)
[17:28:02.592]         {
[17:28:02.592]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:02.592]                 ...future.oldOptions$nwarnings <- NULL
[17:28:02.592]             }
[17:28:02.592]             base::options(...future.oldOptions)
[17:28:02.592]             if (.Platform$OS.type == "windows") {
[17:28:02.592]                 old_names <- names(...future.oldEnvVars)
[17:28:02.592]                 envs <- base::Sys.getenv()
[17:28:02.592]                 names <- names(envs)
[17:28:02.592]                 common <- intersect(names, old_names)
[17:28:02.592]                 added <- setdiff(names, old_names)
[17:28:02.592]                 removed <- setdiff(old_names, names)
[17:28:02.592]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:02.592]                   envs[common]]
[17:28:02.592]                 NAMES <- toupper(changed)
[17:28:02.592]                 args <- list()
[17:28:02.592]                 for (kk in seq_along(NAMES)) {
[17:28:02.592]                   name <- changed[[kk]]
[17:28:02.592]                   NAME <- NAMES[[kk]]
[17:28:02.592]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:02.592]                     next
[17:28:02.592]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:02.592]                 }
[17:28:02.592]                 NAMES <- toupper(added)
[17:28:02.592]                 for (kk in seq_along(NAMES)) {
[17:28:02.592]                   name <- added[[kk]]
[17:28:02.592]                   NAME <- NAMES[[kk]]
[17:28:02.592]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:02.592]                     next
[17:28:02.592]                   args[[name]] <- ""
[17:28:02.592]                 }
[17:28:02.592]                 NAMES <- toupper(removed)
[17:28:02.592]                 for (kk in seq_along(NAMES)) {
[17:28:02.592]                   name <- removed[[kk]]
[17:28:02.592]                   NAME <- NAMES[[kk]]
[17:28:02.592]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:02.592]                     next
[17:28:02.592]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:02.592]                 }
[17:28:02.592]                 if (length(args) > 0) 
[17:28:02.592]                   base::do.call(base::Sys.setenv, args = args)
[17:28:02.592]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:02.592]             }
[17:28:02.592]             else {
[17:28:02.592]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:02.592]             }
[17:28:02.592]             {
[17:28:02.592]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:02.592]                   0L) {
[17:28:02.592]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:02.592]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:02.592]                   base::options(opts)
[17:28:02.592]                 }
[17:28:02.592]                 {
[17:28:02.592]                   {
[17:28:02.592]                     base::options(mc.cores = ...future.mc.cores.old)
[17:28:02.592]                     NULL
[17:28:02.592]                   }
[17:28:02.592]                   options(future.plan = NULL)
[17:28:02.592]                   if (is.na(NA_character_)) 
[17:28:02.592]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:02.592]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:02.592]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:02.592]                     .init = FALSE)
[17:28:02.592]                 }
[17:28:02.592]             }
[17:28:02.592]         }
[17:28:02.592]     })
[17:28:02.592]     if (TRUE) {
[17:28:02.592]         base::sink(type = "output", split = FALSE)
[17:28:02.592]         if (TRUE) {
[17:28:02.592]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:02.592]         }
[17:28:02.592]         else {
[17:28:02.592]             ...future.result["stdout"] <- base::list(NULL)
[17:28:02.592]         }
[17:28:02.592]         base::close(...future.stdout)
[17:28:02.592]         ...future.stdout <- NULL
[17:28:02.592]     }
[17:28:02.592]     ...future.result$conditions <- ...future.conditions
[17:28:02.592]     ...future.result$finished <- base::Sys.time()
[17:28:02.592]     ...future.result
[17:28:02.592] }
[17:28:02.600] Exporting 1 global objects (334 bytes) to cluster node #1 ...
[17:28:02.600] Exporting 'x' (31 bytes) to cluster node #1 ...
[17:28:02.601] Exporting 'x' (31 bytes) to cluster node #1 ... DONE
[17:28:02.601] Exporting 1 global objects (334 bytes) to cluster node #1 ... DONE
[17:28:02.602] MultisessionFuture started
[17:28:02.603] - Launch lazy future ... done
[17:28:02.603] run() for 'MultisessionFuture' ... done
[17:28:02.603] result() for ClusterFuture ...
[17:28:02.604] receiveMessageFromWorker() for ClusterFuture ...
[17:28:02.604] - Validating connection of MultisessionFuture
[17:28:02.627] - received message: FutureResult
[17:28:02.628] - Received FutureResult
[17:28:02.628] - Erased future from FutureRegistry
[17:28:02.628] result() for ClusterFuture ...
[17:28:02.628] - result already collected: FutureResult
[17:28:02.629] result() for ClusterFuture ... done
[17:28:02.629] receiveMessageFromWorker() for ClusterFuture ... done
[17:28:02.629] result() for ClusterFuture ... done
[17:28:02.629] result() for ClusterFuture ...
[17:28:02.629] - result already collected: FutureResult
[17:28:02.629] result() for ClusterFuture ... done
$a
[1] 1

Warning in getGlobalsAndPackages(expr, envir = envir, tweak = tweakExpression,  :
  R option 'future.globals.resolve' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'TRUE'
[17:28:02.630] getGlobalsAndPackages() ...
Warning in getGlobalsAndPackages(expr, envir = envir, tweak = tweakExpression,  :
  R option 'future.globals.onMissing' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'error'
[17:28:02.630] Searching for globals...
[17:28:02.633] - globals found: [6] '{', 'x', '<-', '[', '[<-', 'list'
[17:28:02.634] Searching for globals ... DONE
[17:28:02.634] Resolving globals: TRUE
[17:28:02.634] Resolving any globals that are futures ...
[17:28:02.634] - globals: [6] '{', 'x', '<-', '[', '[<-', 'list'
[17:28:02.634] Resolving any globals that are futures ... DONE
[17:28:02.635] Resolving futures part of globals (recursively) ...
[17:28:02.635] resolve() on list ...
[17:28:02.636]  recursive: 99
[17:28:02.636]  length: 1
[17:28:02.636]  elements: 'x'
[17:28:02.637]  length: 0 (resolved future 1)
[17:28:02.637] resolve() on list ... DONE
[17:28:02.637] - globals: [1] 'x'
[17:28:02.637] Resolving futures part of globals (recursively) ... DONE
[17:28:02.638] The total size of the 1 globals is 31 bytes (31 bytes)
[17:28:02.638] The total size of the 1 globals exported for future expression ('{; x["a"] <- list(1); x; }') is 31 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (31 bytes of class 'list')
[17:28:02.638] - globals: [1] 'x'
[17:28:02.639] 
[17:28:02.639] getGlobalsAndPackages() ... DONE
[17:28:02.639] run() for 'Future' ...
[17:28:02.639] - state: 'created'
[17:28:02.640] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:28:02.658] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:28:02.659] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:28:02.659]   - Field: 'node'
[17:28:02.659]   - Field: 'label'
[17:28:02.660]   - Field: 'local'
[17:28:02.660]   - Field: 'owner'
[17:28:02.660]   - Field: 'envir'
[17:28:02.661]   - Field: 'workers'
[17:28:02.661]   - Field: 'packages'
[17:28:02.661]   - Field: 'gc'
[17:28:02.661]   - Field: 'conditions'
[17:28:02.662]   - Field: 'persistent'
[17:28:02.662]   - Field: 'expr'
[17:28:02.662]   - Field: 'uuid'
[17:28:02.662]   - Field: 'seed'
[17:28:02.663]   - Field: 'version'
[17:28:02.663]   - Field: 'result'
[17:28:02.663]   - Field: 'asynchronous'
[17:28:02.664]   - Field: 'calls'
[17:28:02.664]   - Field: 'globals'
[17:28:02.664]   - Field: 'stdout'
[17:28:02.664]   - Field: 'earlySignal'
[17:28:02.665]   - Field: 'lazy'
[17:28:02.665]   - Field: 'state'
[17:28:02.665] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:28:02.666] - Launch lazy future ...
[17:28:02.666] Packages needed by the future expression (n = 0): <none>
[17:28:02.666] Packages needed by future strategies (n = 0): <none>
[17:28:02.667] {
[17:28:02.667]     {
[17:28:02.667]         {
[17:28:02.667]             ...future.startTime <- base::Sys.time()
[17:28:02.667]             {
[17:28:02.667]                 {
[17:28:02.667]                   {
[17:28:02.667]                     {
[17:28:02.667]                       base::local({
[17:28:02.667]                         has_future <- base::requireNamespace("future", 
[17:28:02.667]                           quietly = TRUE)
[17:28:02.667]                         if (has_future) {
[17:28:02.667]                           ns <- base::getNamespace("future")
[17:28:02.667]                           version <- ns[[".package"]][["version"]]
[17:28:02.667]                           if (is.null(version)) 
[17:28:02.667]                             version <- utils::packageVersion("future")
[17:28:02.667]                         }
[17:28:02.667]                         else {
[17:28:02.667]                           version <- NULL
[17:28:02.667]                         }
[17:28:02.667]                         if (!has_future || version < "1.8.0") {
[17:28:02.667]                           info <- base::c(r_version = base::gsub("R version ", 
[17:28:02.667]                             "", base::R.version$version.string), 
[17:28:02.667]                             platform = base::sprintf("%s (%s-bit)", 
[17:28:02.667]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:02.667]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:02.667]                               "release", "version")], collapse = " "), 
[17:28:02.667]                             hostname = base::Sys.info()[["nodename"]])
[17:28:02.667]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:28:02.667]                             info)
[17:28:02.667]                           info <- base::paste(info, collapse = "; ")
[17:28:02.667]                           if (!has_future) {
[17:28:02.667]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:02.667]                               info)
[17:28:02.667]                           }
[17:28:02.667]                           else {
[17:28:02.667]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:02.667]                               info, version)
[17:28:02.667]                           }
[17:28:02.667]                           base::stop(msg)
[17:28:02.667]                         }
[17:28:02.667]                       })
[17:28:02.667]                     }
[17:28:02.667]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:28:02.667]                     base::options(mc.cores = 1L)
[17:28:02.667]                   }
[17:28:02.667]                   ...future.strategy.old <- future::plan("list")
[17:28:02.667]                   options(future.plan = NULL)
[17:28:02.667]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:02.667]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:02.667]                 }
[17:28:02.667]                 ...future.workdir <- getwd()
[17:28:02.667]             }
[17:28:02.667]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:02.667]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:02.667]         }
[17:28:02.667]         base::options(future.startup.script = FALSE, future.globals.onMissing = "error", 
[17:28:02.667]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:02.667]             future.globals.onMissing = "error", future.globals.onReference = NULL, 
[17:28:02.667]             future.globals.resolve = TRUE, future.resolve.recursive = NULL, 
[17:28:02.667]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:28:02.667]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:02.667]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:02.667]             base::names(...future.oldOptions))
[17:28:02.667]     }
[17:28:02.667]     if (FALSE) {
[17:28:02.667]     }
[17:28:02.667]     else {
[17:28:02.667]         if (TRUE) {
[17:28:02.667]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:02.667]                 open = "w")
[17:28:02.667]         }
[17:28:02.667]         else {
[17:28:02.667]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:02.667]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:02.667]         }
[17:28:02.667]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:02.667]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:02.667]             base::sink(type = "output", split = FALSE)
[17:28:02.667]             base::close(...future.stdout)
[17:28:02.667]         }, add = TRUE)
[17:28:02.667]     }
[17:28:02.667]     ...future.frame <- base::sys.nframe()
[17:28:02.667]     ...future.conditions <- base::list()
[17:28:02.667]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:02.667]     if (FALSE) {
[17:28:02.667]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:02.667]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:02.667]     }
[17:28:02.667]     ...future.result <- base::tryCatch({
[17:28:02.667]         base::withCallingHandlers({
[17:28:02.667]             ...future.value <- base::withVisible(base::local({
[17:28:02.667]                 ...future.makeSendCondition <- base::local({
[17:28:02.667]                   sendCondition <- NULL
[17:28:02.667]                   function(frame = 1L) {
[17:28:02.667]                     if (is.function(sendCondition)) 
[17:28:02.667]                       return(sendCondition)
[17:28:02.667]                     ns <- getNamespace("parallel")
[17:28:02.667]                     if (exists("sendData", mode = "function", 
[17:28:02.667]                       envir = ns)) {
[17:28:02.667]                       parallel_sendData <- get("sendData", mode = "function", 
[17:28:02.667]                         envir = ns)
[17:28:02.667]                       envir <- sys.frame(frame)
[17:28:02.667]                       master <- NULL
[17:28:02.667]                       while (!identical(envir, .GlobalEnv) && 
[17:28:02.667]                         !identical(envir, emptyenv())) {
[17:28:02.667]                         if (exists("master", mode = "list", envir = envir, 
[17:28:02.667]                           inherits = FALSE)) {
[17:28:02.667]                           master <- get("master", mode = "list", 
[17:28:02.667]                             envir = envir, inherits = FALSE)
[17:28:02.667]                           if (inherits(master, c("SOCKnode", 
[17:28:02.667]                             "SOCK0node"))) {
[17:28:02.667]                             sendCondition <<- function(cond) {
[17:28:02.667]                               data <- list(type = "VALUE", value = cond, 
[17:28:02.667]                                 success = TRUE)
[17:28:02.667]                               parallel_sendData(master, data)
[17:28:02.667]                             }
[17:28:02.667]                             return(sendCondition)
[17:28:02.667]                           }
[17:28:02.667]                         }
[17:28:02.667]                         frame <- frame + 1L
[17:28:02.667]                         envir <- sys.frame(frame)
[17:28:02.667]                       }
[17:28:02.667]                     }
[17:28:02.667]                     sendCondition <<- function(cond) NULL
[17:28:02.667]                   }
[17:28:02.667]                 })
[17:28:02.667]                 withCallingHandlers({
[17:28:02.667]                   {
[17:28:02.667]                     x["a"] <- list(1)
[17:28:02.667]                     x
[17:28:02.667]                   }
[17:28:02.667]                 }, immediateCondition = function(cond) {
[17:28:02.667]                   sendCondition <- ...future.makeSendCondition()
[17:28:02.667]                   sendCondition(cond)
[17:28:02.667]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:02.667]                   {
[17:28:02.667]                     inherits <- base::inherits
[17:28:02.667]                     invokeRestart <- base::invokeRestart
[17:28:02.667]                     is.null <- base::is.null
[17:28:02.667]                     muffled <- FALSE
[17:28:02.667]                     if (inherits(cond, "message")) {
[17:28:02.667]                       muffled <- grepl(pattern, "muffleMessage")
[17:28:02.667]                       if (muffled) 
[17:28:02.667]                         invokeRestart("muffleMessage")
[17:28:02.667]                     }
[17:28:02.667]                     else if (inherits(cond, "warning")) {
[17:28:02.667]                       muffled <- grepl(pattern, "muffleWarning")
[17:28:02.667]                       if (muffled) 
[17:28:02.667]                         invokeRestart("muffleWarning")
[17:28:02.667]                     }
[17:28:02.667]                     else if (inherits(cond, "condition")) {
[17:28:02.667]                       if (!is.null(pattern)) {
[17:28:02.667]                         computeRestarts <- base::computeRestarts
[17:28:02.667]                         grepl <- base::grepl
[17:28:02.667]                         restarts <- computeRestarts(cond)
[17:28:02.667]                         for (restart in restarts) {
[17:28:02.667]                           name <- restart$name
[17:28:02.667]                           if (is.null(name)) 
[17:28:02.667]                             next
[17:28:02.667]                           if (!grepl(pattern, name)) 
[17:28:02.667]                             next
[17:28:02.667]                           invokeRestart(restart)
[17:28:02.667]                           muffled <- TRUE
[17:28:02.667]                           break
[17:28:02.667]                         }
[17:28:02.667]                       }
[17:28:02.667]                     }
[17:28:02.667]                     invisible(muffled)
[17:28:02.667]                   }
[17:28:02.667]                   muffleCondition(cond)
[17:28:02.667]                 })
[17:28:02.667]             }))
[17:28:02.667]             future::FutureResult(value = ...future.value$value, 
[17:28:02.667]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:02.667]                   ...future.rng), globalenv = if (FALSE) 
[17:28:02.667]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:02.667]                     ...future.globalenv.names))
[17:28:02.667]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:02.667]         }, condition = base::local({
[17:28:02.667]             c <- base::c
[17:28:02.667]             inherits <- base::inherits
[17:28:02.667]             invokeRestart <- base::invokeRestart
[17:28:02.667]             length <- base::length
[17:28:02.667]             list <- base::list
[17:28:02.667]             seq.int <- base::seq.int
[17:28:02.667]             signalCondition <- base::signalCondition
[17:28:02.667]             sys.calls <- base::sys.calls
[17:28:02.667]             `[[` <- base::`[[`
[17:28:02.667]             `+` <- base::`+`
[17:28:02.667]             `<<-` <- base::`<<-`
[17:28:02.667]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:02.667]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:02.667]                   3L)]
[17:28:02.667]             }
[17:28:02.667]             function(cond) {
[17:28:02.667]                 is_error <- inherits(cond, "error")
[17:28:02.667]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:02.667]                   NULL)
[17:28:02.667]                 if (is_error) {
[17:28:02.667]                   sessionInformation <- function() {
[17:28:02.667]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:02.667]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:02.667]                       search = base::search(), system = base::Sys.info())
[17:28:02.667]                   }
[17:28:02.667]                   ...future.conditions[[length(...future.conditions) + 
[17:28:02.667]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:02.667]                     cond$call), session = sessionInformation(), 
[17:28:02.667]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:02.667]                   signalCondition(cond)
[17:28:02.667]                 }
[17:28:02.667]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:02.667]                 "immediateCondition"))) {
[17:28:02.667]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:02.667]                   ...future.conditions[[length(...future.conditions) + 
[17:28:02.667]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:02.667]                   if (TRUE && !signal) {
[17:28:02.667]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:02.667]                     {
[17:28:02.667]                       inherits <- base::inherits
[17:28:02.667]                       invokeRestart <- base::invokeRestart
[17:28:02.667]                       is.null <- base::is.null
[17:28:02.667]                       muffled <- FALSE
[17:28:02.667]                       if (inherits(cond, "message")) {
[17:28:02.667]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:02.667]                         if (muffled) 
[17:28:02.667]                           invokeRestart("muffleMessage")
[17:28:02.667]                       }
[17:28:02.667]                       else if (inherits(cond, "warning")) {
[17:28:02.667]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:02.667]                         if (muffled) 
[17:28:02.667]                           invokeRestart("muffleWarning")
[17:28:02.667]                       }
[17:28:02.667]                       else if (inherits(cond, "condition")) {
[17:28:02.667]                         if (!is.null(pattern)) {
[17:28:02.667]                           computeRestarts <- base::computeRestarts
[17:28:02.667]                           grepl <- base::grepl
[17:28:02.667]                           restarts <- computeRestarts(cond)
[17:28:02.667]                           for (restart in restarts) {
[17:28:02.667]                             name <- restart$name
[17:28:02.667]                             if (is.null(name)) 
[17:28:02.667]                               next
[17:28:02.667]                             if (!grepl(pattern, name)) 
[17:28:02.667]                               next
[17:28:02.667]                             invokeRestart(restart)
[17:28:02.667]                             muffled <- TRUE
[17:28:02.667]                             break
[17:28:02.667]                           }
[17:28:02.667]                         }
[17:28:02.667]                       }
[17:28:02.667]                       invisible(muffled)
[17:28:02.667]                     }
[17:28:02.667]                     muffleCondition(cond, pattern = "^muffle")
[17:28:02.667]                   }
[17:28:02.667]                 }
[17:28:02.667]                 else {
[17:28:02.667]                   if (TRUE) {
[17:28:02.667]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:02.667]                     {
[17:28:02.667]                       inherits <- base::inherits
[17:28:02.667]                       invokeRestart <- base::invokeRestart
[17:28:02.667]                       is.null <- base::is.null
[17:28:02.667]                       muffled <- FALSE
[17:28:02.667]                       if (inherits(cond, "message")) {
[17:28:02.667]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:02.667]                         if (muffled) 
[17:28:02.667]                           invokeRestart("muffleMessage")
[17:28:02.667]                       }
[17:28:02.667]                       else if (inherits(cond, "warning")) {
[17:28:02.667]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:02.667]                         if (muffled) 
[17:28:02.667]                           invokeRestart("muffleWarning")
[17:28:02.667]                       }
[17:28:02.667]                       else if (inherits(cond, "condition")) {
[17:28:02.667]                         if (!is.null(pattern)) {
[17:28:02.667]                           computeRestarts <- base::computeRestarts
[17:28:02.667]                           grepl <- base::grepl
[17:28:02.667]                           restarts <- computeRestarts(cond)
[17:28:02.667]                           for (restart in restarts) {
[17:28:02.667]                             name <- restart$name
[17:28:02.667]                             if (is.null(name)) 
[17:28:02.667]                               next
[17:28:02.667]                             if (!grepl(pattern, name)) 
[17:28:02.667]                               next
[17:28:02.667]                             invokeRestart(restart)
[17:28:02.667]                             muffled <- TRUE
[17:28:02.667]                             break
[17:28:02.667]                           }
[17:28:02.667]                         }
[17:28:02.667]                       }
[17:28:02.667]                       invisible(muffled)
[17:28:02.667]                     }
[17:28:02.667]                     muffleCondition(cond, pattern = "^muffle")
[17:28:02.667]                   }
[17:28:02.667]                 }
[17:28:02.667]             }
[17:28:02.667]         }))
[17:28:02.667]     }, error = function(ex) {
[17:28:02.667]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:02.667]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:02.667]                 ...future.rng), started = ...future.startTime, 
[17:28:02.667]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:02.667]             version = "1.8"), class = "FutureResult")
[17:28:02.667]     }, finally = {
[17:28:02.667]         if (!identical(...future.workdir, getwd())) 
[17:28:02.667]             setwd(...future.workdir)
[17:28:02.667]         {
[17:28:02.667]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:02.667]                 ...future.oldOptions$nwarnings <- NULL
[17:28:02.667]             }
[17:28:02.667]             base::options(...future.oldOptions)
[17:28:02.667]             if (.Platform$OS.type == "windows") {
[17:28:02.667]                 old_names <- names(...future.oldEnvVars)
[17:28:02.667]                 envs <- base::Sys.getenv()
[17:28:02.667]                 names <- names(envs)
[17:28:02.667]                 common <- intersect(names, old_names)
[17:28:02.667]                 added <- setdiff(names, old_names)
[17:28:02.667]                 removed <- setdiff(old_names, names)
[17:28:02.667]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:02.667]                   envs[common]]
[17:28:02.667]                 NAMES <- toupper(changed)
[17:28:02.667]                 args <- list()
[17:28:02.667]                 for (kk in seq_along(NAMES)) {
[17:28:02.667]                   name <- changed[[kk]]
[17:28:02.667]                   NAME <- NAMES[[kk]]
[17:28:02.667]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:02.667]                     next
[17:28:02.667]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:02.667]                 }
[17:28:02.667]                 NAMES <- toupper(added)
[17:28:02.667]                 for (kk in seq_along(NAMES)) {
[17:28:02.667]                   name <- added[[kk]]
[17:28:02.667]                   NAME <- NAMES[[kk]]
[17:28:02.667]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:02.667]                     next
[17:28:02.667]                   args[[name]] <- ""
[17:28:02.667]                 }
[17:28:02.667]                 NAMES <- toupper(removed)
[17:28:02.667]                 for (kk in seq_along(NAMES)) {
[17:28:02.667]                   name <- removed[[kk]]
[17:28:02.667]                   NAME <- NAMES[[kk]]
[17:28:02.667]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:02.667]                     next
[17:28:02.667]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:02.667]                 }
[17:28:02.667]                 if (length(args) > 0) 
[17:28:02.667]                   base::do.call(base::Sys.setenv, args = args)
[17:28:02.667]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:02.667]             }
[17:28:02.667]             else {
[17:28:02.667]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:02.667]             }
[17:28:02.667]             {
[17:28:02.667]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:02.667]                   0L) {
[17:28:02.667]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:02.667]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:02.667]                   base::options(opts)
[17:28:02.667]                 }
[17:28:02.667]                 {
[17:28:02.667]                   {
[17:28:02.667]                     base::options(mc.cores = ...future.mc.cores.old)
[17:28:02.667]                     NULL
[17:28:02.667]                   }
[17:28:02.667]                   options(future.plan = NULL)
[17:28:02.667]                   if (is.na(NA_character_)) 
[17:28:02.667]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:02.667]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:02.667]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:02.667]                     .init = FALSE)
[17:28:02.667]                 }
[17:28:02.667]             }
[17:28:02.667]         }
[17:28:02.667]     })
[17:28:02.667]     if (TRUE) {
[17:28:02.667]         base::sink(type = "output", split = FALSE)
[17:28:02.667]         if (TRUE) {
[17:28:02.667]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:02.667]         }
[17:28:02.667]         else {
[17:28:02.667]             ...future.result["stdout"] <- base::list(NULL)
[17:28:02.667]         }
[17:28:02.667]         base::close(...future.stdout)
[17:28:02.667]         ...future.stdout <- NULL
[17:28:02.667]     }
[17:28:02.667]     ...future.result$conditions <- ...future.conditions
[17:28:02.667]     ...future.result$finished <- base::Sys.time()
[17:28:02.667]     ...future.result
[17:28:02.667] }
[17:28:02.676] Exporting 1 global objects (334 bytes) to cluster node #1 ...
[17:28:02.676] Exporting 'x' (31 bytes) to cluster node #1 ...
[17:28:02.677] Exporting 'x' (31 bytes) to cluster node #1 ... DONE
[17:28:02.677] Exporting 1 global objects (334 bytes) to cluster node #1 ... DONE
[17:28:02.678] MultisessionFuture started
[17:28:02.678] - Launch lazy future ... done
[17:28:02.678] run() for 'MultisessionFuture' ... done
[17:28:02.679] result() for ClusterFuture ...
[17:28:02.679] receiveMessageFromWorker() for ClusterFuture ...
[17:28:02.679] - Validating connection of MultisessionFuture
[17:28:02.701] - received message: FutureResult
[17:28:02.701] - Received FutureResult
[17:28:02.701] - Erased future from FutureRegistry
[17:28:02.702] result() for ClusterFuture ...
[17:28:02.702] - result already collected: FutureResult
[17:28:02.702] result() for ClusterFuture ... done
[17:28:02.703] receiveMessageFromWorker() for ClusterFuture ... done
[17:28:02.703] result() for ClusterFuture ... done
[17:28:02.703] result() for ClusterFuture ...
[17:28:02.703] - result already collected: FutureResult
[17:28:02.704] result() for ClusterFuture ... done
$a
[1] 1

Warning in getGlobalsAndPackages(expr, envir = envir, tweak = tweakExpression,  :
  R option 'future.globals.resolve' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'TRUE'
[17:28:02.704] getGlobalsAndPackages() ...
Warning in getGlobalsAndPackages(expr, envir = envir, tweak = tweakExpression,  :
  R option 'future.globals.onMissing' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'error'
[17:28:02.705] Searching for globals...
[17:28:02.709] - globals found: [6] '{', 'x', '<-', '[', '[<-', 'list'
[17:28:02.710] Searching for globals ... DONE
[17:28:02.710] Resolving globals: TRUE
[17:28:02.710] Resolving any globals that are futures ...
[17:28:02.710] - globals: [6] '{', 'x', '<-', '[', '[<-', 'list'
[17:28:02.711] Resolving any globals that are futures ... DONE
[17:28:02.711] Resolving futures part of globals (recursively) ...
[17:28:02.712] resolve() on list ...
[17:28:02.712]  recursive: 99
[17:28:02.712]  length: 1
[17:28:02.712]  elements: 'x'
[17:28:02.712]  length: 0 (resolved future 1)
[17:28:02.713] resolve() on list ... DONE
[17:28:02.713] - globals: [1] 'x'
[17:28:02.713] Resolving futures part of globals (recursively) ... DONE
[17:28:02.713] The total size of the 1 globals is 31 bytes (31 bytes)
[17:28:02.714] The total size of the 1 globals exported for future expression ('{; x["a"] <- list(1); x; }') is 31 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (31 bytes of class 'list')
[17:28:02.714] - globals: [1] 'x'
[17:28:02.714] 
[17:28:02.714] getGlobalsAndPackages() ... DONE
[17:28:02.714] run() for 'Future' ...
[17:28:02.715] - state: 'created'
[17:28:02.715] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:28:02.730] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:28:02.731] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:28:02.731]   - Field: 'node'
[17:28:02.731]   - Field: 'label'
[17:28:02.731]   - Field: 'local'
[17:28:02.732]   - Field: 'owner'
[17:28:02.732]   - Field: 'envir'
[17:28:02.732]   - Field: 'workers'
[17:28:02.732]   - Field: 'packages'
[17:28:02.732]   - Field: 'gc'
[17:28:02.733]   - Field: 'conditions'
[17:28:02.733]   - Field: 'persistent'
[17:28:02.733]   - Field: 'expr'
[17:28:02.733]   - Field: 'uuid'
[17:28:02.733]   - Field: 'seed'
[17:28:02.734]   - Field: 'version'
[17:28:02.734]   - Field: 'result'
[17:28:02.734]   - Field: 'asynchronous'
[17:28:02.734]   - Field: 'calls'
[17:28:02.734]   - Field: 'globals'
[17:28:02.734]   - Field: 'stdout'
[17:28:02.735]   - Field: 'earlySignal'
[17:28:02.735]   - Field: 'lazy'
[17:28:02.735]   - Field: 'state'
[17:28:02.735] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:28:02.736] - Launch lazy future ...
[17:28:02.736] Packages needed by the future expression (n = 0): <none>
[17:28:02.737] Packages needed by future strategies (n = 0): <none>
[17:28:02.738] {
[17:28:02.738]     {
[17:28:02.738]         {
[17:28:02.738]             ...future.startTime <- base::Sys.time()
[17:28:02.738]             {
[17:28:02.738]                 {
[17:28:02.738]                   {
[17:28:02.738]                     {
[17:28:02.738]                       base::local({
[17:28:02.738]                         has_future <- base::requireNamespace("future", 
[17:28:02.738]                           quietly = TRUE)
[17:28:02.738]                         if (has_future) {
[17:28:02.738]                           ns <- base::getNamespace("future")
[17:28:02.738]                           version <- ns[[".package"]][["version"]]
[17:28:02.738]                           if (is.null(version)) 
[17:28:02.738]                             version <- utils::packageVersion("future")
[17:28:02.738]                         }
[17:28:02.738]                         else {
[17:28:02.738]                           version <- NULL
[17:28:02.738]                         }
[17:28:02.738]                         if (!has_future || version < "1.8.0") {
[17:28:02.738]                           info <- base::c(r_version = base::gsub("R version ", 
[17:28:02.738]                             "", base::R.version$version.string), 
[17:28:02.738]                             platform = base::sprintf("%s (%s-bit)", 
[17:28:02.738]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:02.738]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:02.738]                               "release", "version")], collapse = " "), 
[17:28:02.738]                             hostname = base::Sys.info()[["nodename"]])
[17:28:02.738]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:28:02.738]                             info)
[17:28:02.738]                           info <- base::paste(info, collapse = "; ")
[17:28:02.738]                           if (!has_future) {
[17:28:02.738]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:02.738]                               info)
[17:28:02.738]                           }
[17:28:02.738]                           else {
[17:28:02.738]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:02.738]                               info, version)
[17:28:02.738]                           }
[17:28:02.738]                           base::stop(msg)
[17:28:02.738]                         }
[17:28:02.738]                       })
[17:28:02.738]                     }
[17:28:02.738]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:28:02.738]                     base::options(mc.cores = 1L)
[17:28:02.738]                   }
[17:28:02.738]                   ...future.strategy.old <- future::plan("list")
[17:28:02.738]                   options(future.plan = NULL)
[17:28:02.738]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:02.738]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:02.738]                 }
[17:28:02.738]                 ...future.workdir <- getwd()
[17:28:02.738]             }
[17:28:02.738]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:02.738]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:02.738]         }
[17:28:02.738]         base::options(future.startup.script = FALSE, future.globals.onMissing = "error", 
[17:28:02.738]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:02.738]             future.globals.onMissing = "error", future.globals.onReference = NULL, 
[17:28:02.738]             future.globals.resolve = TRUE, future.resolve.recursive = NULL, 
[17:28:02.738]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:28:02.738]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:02.738]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:02.738]             base::names(...future.oldOptions))
[17:28:02.738]     }
[17:28:02.738]     if (FALSE) {
[17:28:02.738]     }
[17:28:02.738]     else {
[17:28:02.738]         if (TRUE) {
[17:28:02.738]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:02.738]                 open = "w")
[17:28:02.738]         }
[17:28:02.738]         else {
[17:28:02.738]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:02.738]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:02.738]         }
[17:28:02.738]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:02.738]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:02.738]             base::sink(type = "output", split = FALSE)
[17:28:02.738]             base::close(...future.stdout)
[17:28:02.738]         }, add = TRUE)
[17:28:02.738]     }
[17:28:02.738]     ...future.frame <- base::sys.nframe()
[17:28:02.738]     ...future.conditions <- base::list()
[17:28:02.738]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:02.738]     if (FALSE) {
[17:28:02.738]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:02.738]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:02.738]     }
[17:28:02.738]     ...future.result <- base::tryCatch({
[17:28:02.738]         base::withCallingHandlers({
[17:28:02.738]             ...future.value <- base::withVisible(base::local({
[17:28:02.738]                 ...future.makeSendCondition <- base::local({
[17:28:02.738]                   sendCondition <- NULL
[17:28:02.738]                   function(frame = 1L) {
[17:28:02.738]                     if (is.function(sendCondition)) 
[17:28:02.738]                       return(sendCondition)
[17:28:02.738]                     ns <- getNamespace("parallel")
[17:28:02.738]                     if (exists("sendData", mode = "function", 
[17:28:02.738]                       envir = ns)) {
[17:28:02.738]                       parallel_sendData <- get("sendData", mode = "function", 
[17:28:02.738]                         envir = ns)
[17:28:02.738]                       envir <- sys.frame(frame)
[17:28:02.738]                       master <- NULL
[17:28:02.738]                       while (!identical(envir, .GlobalEnv) && 
[17:28:02.738]                         !identical(envir, emptyenv())) {
[17:28:02.738]                         if (exists("master", mode = "list", envir = envir, 
[17:28:02.738]                           inherits = FALSE)) {
[17:28:02.738]                           master <- get("master", mode = "list", 
[17:28:02.738]                             envir = envir, inherits = FALSE)
[17:28:02.738]                           if (inherits(master, c("SOCKnode", 
[17:28:02.738]                             "SOCK0node"))) {
[17:28:02.738]                             sendCondition <<- function(cond) {
[17:28:02.738]                               data <- list(type = "VALUE", value = cond, 
[17:28:02.738]                                 success = TRUE)
[17:28:02.738]                               parallel_sendData(master, data)
[17:28:02.738]                             }
[17:28:02.738]                             return(sendCondition)
[17:28:02.738]                           }
[17:28:02.738]                         }
[17:28:02.738]                         frame <- frame + 1L
[17:28:02.738]                         envir <- sys.frame(frame)
[17:28:02.738]                       }
[17:28:02.738]                     }
[17:28:02.738]                     sendCondition <<- function(cond) NULL
[17:28:02.738]                   }
[17:28:02.738]                 })
[17:28:02.738]                 withCallingHandlers({
[17:28:02.738]                   {
[17:28:02.738]                     x["a"] <- list(1)
[17:28:02.738]                     x
[17:28:02.738]                   }
[17:28:02.738]                 }, immediateCondition = function(cond) {
[17:28:02.738]                   sendCondition <- ...future.makeSendCondition()
[17:28:02.738]                   sendCondition(cond)
[17:28:02.738]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:02.738]                   {
[17:28:02.738]                     inherits <- base::inherits
[17:28:02.738]                     invokeRestart <- base::invokeRestart
[17:28:02.738]                     is.null <- base::is.null
[17:28:02.738]                     muffled <- FALSE
[17:28:02.738]                     if (inherits(cond, "message")) {
[17:28:02.738]                       muffled <- grepl(pattern, "muffleMessage")
[17:28:02.738]                       if (muffled) 
[17:28:02.738]                         invokeRestart("muffleMessage")
[17:28:02.738]                     }
[17:28:02.738]                     else if (inherits(cond, "warning")) {
[17:28:02.738]                       muffled <- grepl(pattern, "muffleWarning")
[17:28:02.738]                       if (muffled) 
[17:28:02.738]                         invokeRestart("muffleWarning")
[17:28:02.738]                     }
[17:28:02.738]                     else if (inherits(cond, "condition")) {
[17:28:02.738]                       if (!is.null(pattern)) {
[17:28:02.738]                         computeRestarts <- base::computeRestarts
[17:28:02.738]                         grepl <- base::grepl
[17:28:02.738]                         restarts <- computeRestarts(cond)
[17:28:02.738]                         for (restart in restarts) {
[17:28:02.738]                           name <- restart$name
[17:28:02.738]                           if (is.null(name)) 
[17:28:02.738]                             next
[17:28:02.738]                           if (!grepl(pattern, name)) 
[17:28:02.738]                             next
[17:28:02.738]                           invokeRestart(restart)
[17:28:02.738]                           muffled <- TRUE
[17:28:02.738]                           break
[17:28:02.738]                         }
[17:28:02.738]                       }
[17:28:02.738]                     }
[17:28:02.738]                     invisible(muffled)
[17:28:02.738]                   }
[17:28:02.738]                   muffleCondition(cond)
[17:28:02.738]                 })
[17:28:02.738]             }))
[17:28:02.738]             future::FutureResult(value = ...future.value$value, 
[17:28:02.738]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:02.738]                   ...future.rng), globalenv = if (FALSE) 
[17:28:02.738]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:02.738]                     ...future.globalenv.names))
[17:28:02.738]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:02.738]         }, condition = base::local({
[17:28:02.738]             c <- base::c
[17:28:02.738]             inherits <- base::inherits
[17:28:02.738]             invokeRestart <- base::invokeRestart
[17:28:02.738]             length <- base::length
[17:28:02.738]             list <- base::list
[17:28:02.738]             seq.int <- base::seq.int
[17:28:02.738]             signalCondition <- base::signalCondition
[17:28:02.738]             sys.calls <- base::sys.calls
[17:28:02.738]             `[[` <- base::`[[`
[17:28:02.738]             `+` <- base::`+`
[17:28:02.738]             `<<-` <- base::`<<-`
[17:28:02.738]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:02.738]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:02.738]                   3L)]
[17:28:02.738]             }
[17:28:02.738]             function(cond) {
[17:28:02.738]                 is_error <- inherits(cond, "error")
[17:28:02.738]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:02.738]                   NULL)
[17:28:02.738]                 if (is_error) {
[17:28:02.738]                   sessionInformation <- function() {
[17:28:02.738]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:02.738]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:02.738]                       search = base::search(), system = base::Sys.info())
[17:28:02.738]                   }
[17:28:02.738]                   ...future.conditions[[length(...future.conditions) + 
[17:28:02.738]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:02.738]                     cond$call), session = sessionInformation(), 
[17:28:02.738]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:02.738]                   signalCondition(cond)
[17:28:02.738]                 }
[17:28:02.738]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:02.738]                 "immediateCondition"))) {
[17:28:02.738]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:02.738]                   ...future.conditions[[length(...future.conditions) + 
[17:28:02.738]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:02.738]                   if (TRUE && !signal) {
[17:28:02.738]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:02.738]                     {
[17:28:02.738]                       inherits <- base::inherits
[17:28:02.738]                       invokeRestart <- base::invokeRestart
[17:28:02.738]                       is.null <- base::is.null
[17:28:02.738]                       muffled <- FALSE
[17:28:02.738]                       if (inherits(cond, "message")) {
[17:28:02.738]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:02.738]                         if (muffled) 
[17:28:02.738]                           invokeRestart("muffleMessage")
[17:28:02.738]                       }
[17:28:02.738]                       else if (inherits(cond, "warning")) {
[17:28:02.738]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:02.738]                         if (muffled) 
[17:28:02.738]                           invokeRestart("muffleWarning")
[17:28:02.738]                       }
[17:28:02.738]                       else if (inherits(cond, "condition")) {
[17:28:02.738]                         if (!is.null(pattern)) {
[17:28:02.738]                           computeRestarts <- base::computeRestarts
[17:28:02.738]                           grepl <- base::grepl
[17:28:02.738]                           restarts <- computeRestarts(cond)
[17:28:02.738]                           for (restart in restarts) {
[17:28:02.738]                             name <- restart$name
[17:28:02.738]                             if (is.null(name)) 
[17:28:02.738]                               next
[17:28:02.738]                             if (!grepl(pattern, name)) 
[17:28:02.738]                               next
[17:28:02.738]                             invokeRestart(restart)
[17:28:02.738]                             muffled <- TRUE
[17:28:02.738]                             break
[17:28:02.738]                           }
[17:28:02.738]                         }
[17:28:02.738]                       }
[17:28:02.738]                       invisible(muffled)
[17:28:02.738]                     }
[17:28:02.738]                     muffleCondition(cond, pattern = "^muffle")
[17:28:02.738]                   }
[17:28:02.738]                 }
[17:28:02.738]                 else {
[17:28:02.738]                   if (TRUE) {
[17:28:02.738]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:02.738]                     {
[17:28:02.738]                       inherits <- base::inherits
[17:28:02.738]                       invokeRestart <- base::invokeRestart
[17:28:02.738]                       is.null <- base::is.null
[17:28:02.738]                       muffled <- FALSE
[17:28:02.738]                       if (inherits(cond, "message")) {
[17:28:02.738]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:02.738]                         if (muffled) 
[17:28:02.738]                           invokeRestart("muffleMessage")
[17:28:02.738]                       }
[17:28:02.738]                       else if (inherits(cond, "warning")) {
[17:28:02.738]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:02.738]                         if (muffled) 
[17:28:02.738]                           invokeRestart("muffleWarning")
[17:28:02.738]                       }
[17:28:02.738]                       else if (inherits(cond, "condition")) {
[17:28:02.738]                         if (!is.null(pattern)) {
[17:28:02.738]                           computeRestarts <- base::computeRestarts
[17:28:02.738]                           grepl <- base::grepl
[17:28:02.738]                           restarts <- computeRestarts(cond)
[17:28:02.738]                           for (restart in restarts) {
[17:28:02.738]                             name <- restart$name
[17:28:02.738]                             if (is.null(name)) 
[17:28:02.738]                               next
[17:28:02.738]                             if (!grepl(pattern, name)) 
[17:28:02.738]                               next
[17:28:02.738]                             invokeRestart(restart)
[17:28:02.738]                             muffled <- TRUE
[17:28:02.738]                             break
[17:28:02.738]                           }
[17:28:02.738]                         }
[17:28:02.738]                       }
[17:28:02.738]                       invisible(muffled)
[17:28:02.738]                     }
[17:28:02.738]                     muffleCondition(cond, pattern = "^muffle")
[17:28:02.738]                   }
[17:28:02.738]                 }
[17:28:02.738]             }
[17:28:02.738]         }))
[17:28:02.738]     }, error = function(ex) {
[17:28:02.738]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:02.738]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:02.738]                 ...future.rng), started = ...future.startTime, 
[17:28:02.738]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:02.738]             version = "1.8"), class = "FutureResult")
[17:28:02.738]     }, finally = {
[17:28:02.738]         if (!identical(...future.workdir, getwd())) 
[17:28:02.738]             setwd(...future.workdir)
[17:28:02.738]         {
[17:28:02.738]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:02.738]                 ...future.oldOptions$nwarnings <- NULL
[17:28:02.738]             }
[17:28:02.738]             base::options(...future.oldOptions)
[17:28:02.738]             if (.Platform$OS.type == "windows") {
[17:28:02.738]                 old_names <- names(...future.oldEnvVars)
[17:28:02.738]                 envs <- base::Sys.getenv()
[17:28:02.738]                 names <- names(envs)
[17:28:02.738]                 common <- intersect(names, old_names)
[17:28:02.738]                 added <- setdiff(names, old_names)
[17:28:02.738]                 removed <- setdiff(old_names, names)
[17:28:02.738]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:02.738]                   envs[common]]
[17:28:02.738]                 NAMES <- toupper(changed)
[17:28:02.738]                 args <- list()
[17:28:02.738]                 for (kk in seq_along(NAMES)) {
[17:28:02.738]                   name <- changed[[kk]]
[17:28:02.738]                   NAME <- NAMES[[kk]]
[17:28:02.738]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:02.738]                     next
[17:28:02.738]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:02.738]                 }
[17:28:02.738]                 NAMES <- toupper(added)
[17:28:02.738]                 for (kk in seq_along(NAMES)) {
[17:28:02.738]                   name <- added[[kk]]
[17:28:02.738]                   NAME <- NAMES[[kk]]
[17:28:02.738]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:02.738]                     next
[17:28:02.738]                   args[[name]] <- ""
[17:28:02.738]                 }
[17:28:02.738]                 NAMES <- toupper(removed)
[17:28:02.738]                 for (kk in seq_along(NAMES)) {
[17:28:02.738]                   name <- removed[[kk]]
[17:28:02.738]                   NAME <- NAMES[[kk]]
[17:28:02.738]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:02.738]                     next
[17:28:02.738]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:02.738]                 }
[17:28:02.738]                 if (length(args) > 0) 
[17:28:02.738]                   base::do.call(base::Sys.setenv, args = args)
[17:28:02.738]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:02.738]             }
[17:28:02.738]             else {
[17:28:02.738]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:02.738]             }
[17:28:02.738]             {
[17:28:02.738]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:02.738]                   0L) {
[17:28:02.738]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:02.738]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:02.738]                   base::options(opts)
[17:28:02.738]                 }
[17:28:02.738]                 {
[17:28:02.738]                   {
[17:28:02.738]                     base::options(mc.cores = ...future.mc.cores.old)
[17:28:02.738]                     NULL
[17:28:02.738]                   }
[17:28:02.738]                   options(future.plan = NULL)
[17:28:02.738]                   if (is.na(NA_character_)) 
[17:28:02.738]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:02.738]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:02.738]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:02.738]                     .init = FALSE)
[17:28:02.738]                 }
[17:28:02.738]             }
[17:28:02.738]         }
[17:28:02.738]     })
[17:28:02.738]     if (TRUE) {
[17:28:02.738]         base::sink(type = "output", split = FALSE)
[17:28:02.738]         if (TRUE) {
[17:28:02.738]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:02.738]         }
[17:28:02.738]         else {
[17:28:02.738]             ...future.result["stdout"] <- base::list(NULL)
[17:28:02.738]         }
[17:28:02.738]         base::close(...future.stdout)
[17:28:02.738]         ...future.stdout <- NULL
[17:28:02.738]     }
[17:28:02.738]     ...future.result$conditions <- ...future.conditions
[17:28:02.738]     ...future.result$finished <- base::Sys.time()
[17:28:02.738]     ...future.result
[17:28:02.738] }
[17:28:02.747] Exporting 1 global objects (334 bytes) to cluster node #1 ...
[17:28:02.747] Exporting 'x' (31 bytes) to cluster node #1 ...
[17:28:02.748] Exporting 'x' (31 bytes) to cluster node #1 ... DONE
[17:28:02.748] Exporting 1 global objects (334 bytes) to cluster node #1 ... DONE
[17:28:02.749] MultisessionFuture started
[17:28:02.750] - Launch lazy future ... done
[17:28:02.750] run() for 'MultisessionFuture' ... done
[17:28:02.750] result() for ClusterFuture ...
[17:28:02.751] receiveMessageFromWorker() for ClusterFuture ...
[17:28:02.751] - Validating connection of MultisessionFuture
[17:28:02.773] - received message: FutureResult
[17:28:02.774] - Received FutureResult
[17:28:02.774] - Erased future from FutureRegistry
[17:28:02.774] result() for ClusterFuture ...
[17:28:02.774] - result already collected: FutureResult
[17:28:02.775] result() for ClusterFuture ... done
[17:28:02.775] receiveMessageFromWorker() for ClusterFuture ... done
[17:28:02.775] result() for ClusterFuture ... done
[17:28:02.775] result() for ClusterFuture ...
[17:28:02.775] - result already collected: FutureResult
[17:28:02.776] result() for ClusterFuture ... done
$a
[1] 1

Warning in getGlobalsAndPackages(expr, envir = envir, tweak = tweakExpression,  :
  R option 'future.globals.resolve' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'TRUE'
[17:28:02.776] getGlobalsAndPackages() ...
Warning in getGlobalsAndPackages(expr, envir = envir, tweak = tweakExpression,  :
  R option 'future.globals.onMissing' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'error'
[17:28:02.777] Searching for globals...
[17:28:02.780] - globals found: [6] '{', 'x', '<-', '[', '[<-', 'list'
[17:28:02.780] Searching for globals ... DONE
[17:28:02.780] Resolving globals: TRUE
[17:28:02.780] Resolving any globals that are futures ...
[17:28:02.781] - globals: [6] '{', 'x', '<-', '[', '[<-', 'list'
[17:28:02.781] Resolving any globals that are futures ... DONE
[17:28:02.781] Resolving futures part of globals (recursively) ...
[17:28:02.782] resolve() on list ...
[17:28:02.782]  recursive: 99
[17:28:02.782]  length: 1
[17:28:02.782]  elements: 'x'
[17:28:02.782]  length: 0 (resolved future 1)
[17:28:02.783] resolve() on list ... DONE
[17:28:02.783] - globals: [1] 'x'
[17:28:02.783] Resolving futures part of globals (recursively) ... DONE
[17:28:02.783] The total size of the 1 globals is 31 bytes (31 bytes)
[17:28:02.784] The total size of the 1 globals exported for future expression ('{; x["a"] <- list(1); x; }') is 31 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (31 bytes of class 'list')
[17:28:02.784] - globals: [1] 'x'
[17:28:02.784] 
[17:28:02.784] getGlobalsAndPackages() ... DONE
[17:28:02.785] run() for 'Future' ...
[17:28:02.785] - state: 'created'
[17:28:02.785] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:28:02.805] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:28:02.805] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:28:02.806]   - Field: 'node'
[17:28:02.806]   - Field: 'label'
[17:28:02.806]   - Field: 'local'
[17:28:02.807]   - Field: 'owner'
[17:28:02.807]   - Field: 'envir'
[17:28:02.807]   - Field: 'workers'
[17:28:02.807]   - Field: 'packages'
[17:28:02.808]   - Field: 'gc'
[17:28:02.808]   - Field: 'conditions'
[17:28:02.808]   - Field: 'persistent'
[17:28:02.809]   - Field: 'expr'
[17:28:02.809]   - Field: 'uuid'
[17:28:02.809]   - Field: 'seed'
[17:28:02.810]   - Field: 'version'
[17:28:02.810]   - Field: 'result'
[17:28:02.810]   - Field: 'asynchronous'
[17:28:02.811]   - Field: 'calls'
[17:28:02.811]   - Field: 'globals'
[17:28:02.811]   - Field: 'stdout'
[17:28:02.812]   - Field: 'earlySignal'
[17:28:02.812]   - Field: 'lazy'
[17:28:02.812]   - Field: 'state'
[17:28:02.812] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:28:02.813] - Launch lazy future ...
[17:28:02.813] Packages needed by the future expression (n = 0): <none>
[17:28:02.814] Packages needed by future strategies (n = 0): <none>
[17:28:02.815] {
[17:28:02.815]     {
[17:28:02.815]         {
[17:28:02.815]             ...future.startTime <- base::Sys.time()
[17:28:02.815]             {
[17:28:02.815]                 {
[17:28:02.815]                   {
[17:28:02.815]                     {
[17:28:02.815]                       base::local({
[17:28:02.815]                         has_future <- base::requireNamespace("future", 
[17:28:02.815]                           quietly = TRUE)
[17:28:02.815]                         if (has_future) {
[17:28:02.815]                           ns <- base::getNamespace("future")
[17:28:02.815]                           version <- ns[[".package"]][["version"]]
[17:28:02.815]                           if (is.null(version)) 
[17:28:02.815]                             version <- utils::packageVersion("future")
[17:28:02.815]                         }
[17:28:02.815]                         else {
[17:28:02.815]                           version <- NULL
[17:28:02.815]                         }
[17:28:02.815]                         if (!has_future || version < "1.8.0") {
[17:28:02.815]                           info <- base::c(r_version = base::gsub("R version ", 
[17:28:02.815]                             "", base::R.version$version.string), 
[17:28:02.815]                             platform = base::sprintf("%s (%s-bit)", 
[17:28:02.815]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:02.815]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:02.815]                               "release", "version")], collapse = " "), 
[17:28:02.815]                             hostname = base::Sys.info()[["nodename"]])
[17:28:02.815]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:28:02.815]                             info)
[17:28:02.815]                           info <- base::paste(info, collapse = "; ")
[17:28:02.815]                           if (!has_future) {
[17:28:02.815]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:02.815]                               info)
[17:28:02.815]                           }
[17:28:02.815]                           else {
[17:28:02.815]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:02.815]                               info, version)
[17:28:02.815]                           }
[17:28:02.815]                           base::stop(msg)
[17:28:02.815]                         }
[17:28:02.815]                       })
[17:28:02.815]                     }
[17:28:02.815]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:28:02.815]                     base::options(mc.cores = 1L)
[17:28:02.815]                   }
[17:28:02.815]                   ...future.strategy.old <- future::plan("list")
[17:28:02.815]                   options(future.plan = NULL)
[17:28:02.815]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:02.815]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:02.815]                 }
[17:28:02.815]                 ...future.workdir <- getwd()
[17:28:02.815]             }
[17:28:02.815]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:02.815]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:02.815]         }
[17:28:02.815]         base::options(future.startup.script = FALSE, future.globals.onMissing = "error", 
[17:28:02.815]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:02.815]             future.globals.onMissing = "error", future.globals.onReference = NULL, 
[17:28:02.815]             future.globals.resolve = TRUE, future.resolve.recursive = NULL, 
[17:28:02.815]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:28:02.815]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:02.815]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:02.815]             base::names(...future.oldOptions))
[17:28:02.815]     }
[17:28:02.815]     if (FALSE) {
[17:28:02.815]     }
[17:28:02.815]     else {
[17:28:02.815]         if (TRUE) {
[17:28:02.815]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:02.815]                 open = "w")
[17:28:02.815]         }
[17:28:02.815]         else {
[17:28:02.815]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:02.815]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:02.815]         }
[17:28:02.815]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:02.815]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:02.815]             base::sink(type = "output", split = FALSE)
[17:28:02.815]             base::close(...future.stdout)
[17:28:02.815]         }, add = TRUE)
[17:28:02.815]     }
[17:28:02.815]     ...future.frame <- base::sys.nframe()
[17:28:02.815]     ...future.conditions <- base::list()
[17:28:02.815]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:02.815]     if (FALSE) {
[17:28:02.815]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:02.815]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:02.815]     }
[17:28:02.815]     ...future.result <- base::tryCatch({
[17:28:02.815]         base::withCallingHandlers({
[17:28:02.815]             ...future.value <- base::withVisible(base::local({
[17:28:02.815]                 ...future.makeSendCondition <- base::local({
[17:28:02.815]                   sendCondition <- NULL
[17:28:02.815]                   function(frame = 1L) {
[17:28:02.815]                     if (is.function(sendCondition)) 
[17:28:02.815]                       return(sendCondition)
[17:28:02.815]                     ns <- getNamespace("parallel")
[17:28:02.815]                     if (exists("sendData", mode = "function", 
[17:28:02.815]                       envir = ns)) {
[17:28:02.815]                       parallel_sendData <- get("sendData", mode = "function", 
[17:28:02.815]                         envir = ns)
[17:28:02.815]                       envir <- sys.frame(frame)
[17:28:02.815]                       master <- NULL
[17:28:02.815]                       while (!identical(envir, .GlobalEnv) && 
[17:28:02.815]                         !identical(envir, emptyenv())) {
[17:28:02.815]                         if (exists("master", mode = "list", envir = envir, 
[17:28:02.815]                           inherits = FALSE)) {
[17:28:02.815]                           master <- get("master", mode = "list", 
[17:28:02.815]                             envir = envir, inherits = FALSE)
[17:28:02.815]                           if (inherits(master, c("SOCKnode", 
[17:28:02.815]                             "SOCK0node"))) {
[17:28:02.815]                             sendCondition <<- function(cond) {
[17:28:02.815]                               data <- list(type = "VALUE", value = cond, 
[17:28:02.815]                                 success = TRUE)
[17:28:02.815]                               parallel_sendData(master, data)
[17:28:02.815]                             }
[17:28:02.815]                             return(sendCondition)
[17:28:02.815]                           }
[17:28:02.815]                         }
[17:28:02.815]                         frame <- frame + 1L
[17:28:02.815]                         envir <- sys.frame(frame)
[17:28:02.815]                       }
[17:28:02.815]                     }
[17:28:02.815]                     sendCondition <<- function(cond) NULL
[17:28:02.815]                   }
[17:28:02.815]                 })
[17:28:02.815]                 withCallingHandlers({
[17:28:02.815]                   {
[17:28:02.815]                     x["a"] <- list(1)
[17:28:02.815]                     x
[17:28:02.815]                   }
[17:28:02.815]                 }, immediateCondition = function(cond) {
[17:28:02.815]                   sendCondition <- ...future.makeSendCondition()
[17:28:02.815]                   sendCondition(cond)
[17:28:02.815]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:02.815]                   {
[17:28:02.815]                     inherits <- base::inherits
[17:28:02.815]                     invokeRestart <- base::invokeRestart
[17:28:02.815]                     is.null <- base::is.null
[17:28:02.815]                     muffled <- FALSE
[17:28:02.815]                     if (inherits(cond, "message")) {
[17:28:02.815]                       muffled <- grepl(pattern, "muffleMessage")
[17:28:02.815]                       if (muffled) 
[17:28:02.815]                         invokeRestart("muffleMessage")
[17:28:02.815]                     }
[17:28:02.815]                     else if (inherits(cond, "warning")) {
[17:28:02.815]                       muffled <- grepl(pattern, "muffleWarning")
[17:28:02.815]                       if (muffled) 
[17:28:02.815]                         invokeRestart("muffleWarning")
[17:28:02.815]                     }
[17:28:02.815]                     else if (inherits(cond, "condition")) {
[17:28:02.815]                       if (!is.null(pattern)) {
[17:28:02.815]                         computeRestarts <- base::computeRestarts
[17:28:02.815]                         grepl <- base::grepl
[17:28:02.815]                         restarts <- computeRestarts(cond)
[17:28:02.815]                         for (restart in restarts) {
[17:28:02.815]                           name <- restart$name
[17:28:02.815]                           if (is.null(name)) 
[17:28:02.815]                             next
[17:28:02.815]                           if (!grepl(pattern, name)) 
[17:28:02.815]                             next
[17:28:02.815]                           invokeRestart(restart)
[17:28:02.815]                           muffled <- TRUE
[17:28:02.815]                           break
[17:28:02.815]                         }
[17:28:02.815]                       }
[17:28:02.815]                     }
[17:28:02.815]                     invisible(muffled)
[17:28:02.815]                   }
[17:28:02.815]                   muffleCondition(cond)
[17:28:02.815]                 })
[17:28:02.815]             }))
[17:28:02.815]             future::FutureResult(value = ...future.value$value, 
[17:28:02.815]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:02.815]                   ...future.rng), globalenv = if (FALSE) 
[17:28:02.815]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:02.815]                     ...future.globalenv.names))
[17:28:02.815]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:02.815]         }, condition = base::local({
[17:28:02.815]             c <- base::c
[17:28:02.815]             inherits <- base::inherits
[17:28:02.815]             invokeRestart <- base::invokeRestart
[17:28:02.815]             length <- base::length
[17:28:02.815]             list <- base::list
[17:28:02.815]             seq.int <- base::seq.int
[17:28:02.815]             signalCondition <- base::signalCondition
[17:28:02.815]             sys.calls <- base::sys.calls
[17:28:02.815]             `[[` <- base::`[[`
[17:28:02.815]             `+` <- base::`+`
[17:28:02.815]             `<<-` <- base::`<<-`
[17:28:02.815]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:02.815]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:02.815]                   3L)]
[17:28:02.815]             }
[17:28:02.815]             function(cond) {
[17:28:02.815]                 is_error <- inherits(cond, "error")
[17:28:02.815]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:02.815]                   NULL)
[17:28:02.815]                 if (is_error) {
[17:28:02.815]                   sessionInformation <- function() {
[17:28:02.815]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:02.815]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:02.815]                       search = base::search(), system = base::Sys.info())
[17:28:02.815]                   }
[17:28:02.815]                   ...future.conditions[[length(...future.conditions) + 
[17:28:02.815]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:02.815]                     cond$call), session = sessionInformation(), 
[17:28:02.815]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:02.815]                   signalCondition(cond)
[17:28:02.815]                 }
[17:28:02.815]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:02.815]                 "immediateCondition"))) {
[17:28:02.815]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:02.815]                   ...future.conditions[[length(...future.conditions) + 
[17:28:02.815]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:02.815]                   if (TRUE && !signal) {
[17:28:02.815]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:02.815]                     {
[17:28:02.815]                       inherits <- base::inherits
[17:28:02.815]                       invokeRestart <- base::invokeRestart
[17:28:02.815]                       is.null <- base::is.null
[17:28:02.815]                       muffled <- FALSE
[17:28:02.815]                       if (inherits(cond, "message")) {
[17:28:02.815]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:02.815]                         if (muffled) 
[17:28:02.815]                           invokeRestart("muffleMessage")
[17:28:02.815]                       }
[17:28:02.815]                       else if (inherits(cond, "warning")) {
[17:28:02.815]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:02.815]                         if (muffled) 
[17:28:02.815]                           invokeRestart("muffleWarning")
[17:28:02.815]                       }
[17:28:02.815]                       else if (inherits(cond, "condition")) {
[17:28:02.815]                         if (!is.null(pattern)) {
[17:28:02.815]                           computeRestarts <- base::computeRestarts
[17:28:02.815]                           grepl <- base::grepl
[17:28:02.815]                           restarts <- computeRestarts(cond)
[17:28:02.815]                           for (restart in restarts) {
[17:28:02.815]                             name <- restart$name
[17:28:02.815]                             if (is.null(name)) 
[17:28:02.815]                               next
[17:28:02.815]                             if (!grepl(pattern, name)) 
[17:28:02.815]                               next
[17:28:02.815]                             invokeRestart(restart)
[17:28:02.815]                             muffled <- TRUE
[17:28:02.815]                             break
[17:28:02.815]                           }
[17:28:02.815]                         }
[17:28:02.815]                       }
[17:28:02.815]                       invisible(muffled)
[17:28:02.815]                     }
[17:28:02.815]                     muffleCondition(cond, pattern = "^muffle")
[17:28:02.815]                   }
[17:28:02.815]                 }
[17:28:02.815]                 else {
[17:28:02.815]                   if (TRUE) {
[17:28:02.815]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:02.815]                     {
[17:28:02.815]                       inherits <- base::inherits
[17:28:02.815]                       invokeRestart <- base::invokeRestart
[17:28:02.815]                       is.null <- base::is.null
[17:28:02.815]                       muffled <- FALSE
[17:28:02.815]                       if (inherits(cond, "message")) {
[17:28:02.815]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:02.815]                         if (muffled) 
[17:28:02.815]                           invokeRestart("muffleMessage")
[17:28:02.815]                       }
[17:28:02.815]                       else if (inherits(cond, "warning")) {
[17:28:02.815]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:02.815]                         if (muffled) 
[17:28:02.815]                           invokeRestart("muffleWarning")
[17:28:02.815]                       }
[17:28:02.815]                       else if (inherits(cond, "condition")) {
[17:28:02.815]                         if (!is.null(pattern)) {
[17:28:02.815]                           computeRestarts <- base::computeRestarts
[17:28:02.815]                           grepl <- base::grepl
[17:28:02.815]                           restarts <- computeRestarts(cond)
[17:28:02.815]                           for (restart in restarts) {
[17:28:02.815]                             name <- restart$name
[17:28:02.815]                             if (is.null(name)) 
[17:28:02.815]                               next
[17:28:02.815]                             if (!grepl(pattern, name)) 
[17:28:02.815]                               next
[17:28:02.815]                             invokeRestart(restart)
[17:28:02.815]                             muffled <- TRUE
[17:28:02.815]                             break
[17:28:02.815]                           }
[17:28:02.815]                         }
[17:28:02.815]                       }
[17:28:02.815]                       invisible(muffled)
[17:28:02.815]                     }
[17:28:02.815]                     muffleCondition(cond, pattern = "^muffle")
[17:28:02.815]                   }
[17:28:02.815]                 }
[17:28:02.815]             }
[17:28:02.815]         }))
[17:28:02.815]     }, error = function(ex) {
[17:28:02.815]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:02.815]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:02.815]                 ...future.rng), started = ...future.startTime, 
[17:28:02.815]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:02.815]             version = "1.8"), class = "FutureResult")
[17:28:02.815]     }, finally = {
[17:28:02.815]         if (!identical(...future.workdir, getwd())) 
[17:28:02.815]             setwd(...future.workdir)
[17:28:02.815]         {
[17:28:02.815]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:02.815]                 ...future.oldOptions$nwarnings <- NULL
[17:28:02.815]             }
[17:28:02.815]             base::options(...future.oldOptions)
[17:28:02.815]             if (.Platform$OS.type == "windows") {
[17:28:02.815]                 old_names <- names(...future.oldEnvVars)
[17:28:02.815]                 envs <- base::Sys.getenv()
[17:28:02.815]                 names <- names(envs)
[17:28:02.815]                 common <- intersect(names, old_names)
[17:28:02.815]                 added <- setdiff(names, old_names)
[17:28:02.815]                 removed <- setdiff(old_names, names)
[17:28:02.815]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:02.815]                   envs[common]]
[17:28:02.815]                 NAMES <- toupper(changed)
[17:28:02.815]                 args <- list()
[17:28:02.815]                 for (kk in seq_along(NAMES)) {
[17:28:02.815]                   name <- changed[[kk]]
[17:28:02.815]                   NAME <- NAMES[[kk]]
[17:28:02.815]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:02.815]                     next
[17:28:02.815]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:02.815]                 }
[17:28:02.815]                 NAMES <- toupper(added)
[17:28:02.815]                 for (kk in seq_along(NAMES)) {
[17:28:02.815]                   name <- added[[kk]]
[17:28:02.815]                   NAME <- NAMES[[kk]]
[17:28:02.815]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:02.815]                     next
[17:28:02.815]                   args[[name]] <- ""
[17:28:02.815]                 }
[17:28:02.815]                 NAMES <- toupper(removed)
[17:28:02.815]                 for (kk in seq_along(NAMES)) {
[17:28:02.815]                   name <- removed[[kk]]
[17:28:02.815]                   NAME <- NAMES[[kk]]
[17:28:02.815]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:02.815]                     next
[17:28:02.815]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:02.815]                 }
[17:28:02.815]                 if (length(args) > 0) 
[17:28:02.815]                   base::do.call(base::Sys.setenv, args = args)
[17:28:02.815]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:02.815]             }
[17:28:02.815]             else {
[17:28:02.815]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:02.815]             }
[17:28:02.815]             {
[17:28:02.815]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:02.815]                   0L) {
[17:28:02.815]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:02.815]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:02.815]                   base::options(opts)
[17:28:02.815]                 }
[17:28:02.815]                 {
[17:28:02.815]                   {
[17:28:02.815]                     base::options(mc.cores = ...future.mc.cores.old)
[17:28:02.815]                     NULL
[17:28:02.815]                   }
[17:28:02.815]                   options(future.plan = NULL)
[17:28:02.815]                   if (is.na(NA_character_)) 
[17:28:02.815]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:02.815]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:02.815]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:02.815]                     .init = FALSE)
[17:28:02.815]                 }
[17:28:02.815]             }
[17:28:02.815]         }
[17:28:02.815]     })
[17:28:02.815]     if (TRUE) {
[17:28:02.815]         base::sink(type = "output", split = FALSE)
[17:28:02.815]         if (TRUE) {
[17:28:02.815]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:02.815]         }
[17:28:02.815]         else {
[17:28:02.815]             ...future.result["stdout"] <- base::list(NULL)
[17:28:02.815]         }
[17:28:02.815]         base::close(...future.stdout)
[17:28:02.815]         ...future.stdout <- NULL
[17:28:02.815]     }
[17:28:02.815]     ...future.result$conditions <- ...future.conditions
[17:28:02.815]     ...future.result$finished <- base::Sys.time()
[17:28:02.815]     ...future.result
[17:28:02.815] }
[17:28:02.824] Exporting 1 global objects (334 bytes) to cluster node #1 ...
[17:28:02.824] Exporting 'x' (31 bytes) to cluster node #1 ...
[17:28:02.825] Exporting 'x' (31 bytes) to cluster node #1 ... DONE
[17:28:02.825] Exporting 1 global objects (334 bytes) to cluster node #1 ... DONE
[17:28:02.826] MultisessionFuture started
[17:28:02.826] - Launch lazy future ... done
[17:28:02.827] run() for 'MultisessionFuture' ... done
[17:28:02.827] result() for ClusterFuture ...
[17:28:02.827] receiveMessageFromWorker() for ClusterFuture ...
[17:28:02.828] - Validating connection of MultisessionFuture
[17:28:02.851] - received message: FutureResult
[17:28:02.852] - Received FutureResult
[17:28:02.852] - Erased future from FutureRegistry
[17:28:02.852] result() for ClusterFuture ...
[17:28:02.852] - result already collected: FutureResult
[17:28:02.853] result() for ClusterFuture ... done
[17:28:02.853] receiveMessageFromWorker() for ClusterFuture ... done
[17:28:02.853] result() for ClusterFuture ... done
[17:28:02.853] result() for ClusterFuture ...
[17:28:02.853] - result already collected: FutureResult
[17:28:02.854] result() for ClusterFuture ... done
$a
[1] 1

Warning in getGlobalsAndPackages(expr, envir = envir, tweak = tweakExpression,  :
  R option 'future.globals.resolve' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'TRUE'
[17:28:02.854] getGlobalsAndPackages() ...
Warning in getGlobalsAndPackages(expr, envir = envir, tweak = tweakExpression,  :
  R option 'future.globals.onMissing' may only be used for troubleshooting. It must not be used in production since it changes how futures are evaluated and there is a great risk that the results cannot be reproduced elsewhere: 'error'
[17:28:02.855] Searching for globals...
[17:28:02.859] - globals found: [7] '{', 'x', '<-', '[', 'name', '[<-', 'list'
[17:28:02.859] Searching for globals ... DONE
[17:28:02.859] Resolving globals: TRUE
[17:28:02.859] Resolving any globals that are futures ...
[17:28:02.859] - globals: [7] '{', 'x', '<-', '[', 'name', '[<-', 'list'
[17:28:02.860] Resolving any globals that are futures ... DONE
[17:28:02.860] Resolving futures part of globals (recursively) ...
[17:28:02.861] resolve() on list ...
[17:28:02.861]  recursive: 99
[17:28:02.861]  length: 2
[17:28:02.861]  elements: 'x', 'name'
[17:28:02.862]  length: 1 (resolved future 1)
[17:28:02.862]  length: 0 (resolved future 2)
[17:28:02.862] resolve() on list ... DONE
[17:28:02.862] - globals: [2] 'x', 'name'
[17:28:02.862] Resolving futures part of globals (recursively) ... DONE
[17:28:02.863] The total size of the 2 globals is 71 bytes (71 bytes)
[17:28:02.863] The total size of the 2 globals exported for future expression ('{; x[name] <- list(1); x; }') is 71 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are two globals: 'name' (40 bytes of class 'character') and 'x' (31 bytes of class 'list')
[17:28:02.864] - globals: [2] 'x', 'name'
[17:28:02.864] 
[17:28:02.864] getGlobalsAndPackages() ... DONE
[17:28:02.864] run() for 'Future' ...
[17:28:02.865] - state: 'created'
[17:28:02.865] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[17:28:02.882] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[17:28:02.882] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[17:28:02.883]   - Field: 'node'
[17:28:02.883]   - Field: 'label'
[17:28:02.883]   - Field: 'local'
[17:28:02.883]   - Field: 'owner'
[17:28:02.884]   - Field: 'envir'
[17:28:02.884]   - Field: 'workers'
[17:28:02.884]   - Field: 'packages'
[17:28:02.884]   - Field: 'gc'
[17:28:02.884]   - Field: 'conditions'
[17:28:02.885]   - Field: 'persistent'
[17:28:02.885]   - Field: 'expr'
[17:28:02.885]   - Field: 'uuid'
[17:28:02.885]   - Field: 'seed'
[17:28:02.885]   - Field: 'version'
[17:28:02.886]   - Field: 'result'
[17:28:02.886]   - Field: 'asynchronous'
[17:28:02.886]   - Field: 'calls'
[17:28:02.886]   - Field: 'globals'
[17:28:02.886]   - Field: 'stdout'
[17:28:02.886]   - Field: 'earlySignal'
[17:28:02.887]   - Field: 'lazy'
[17:28:02.887]   - Field: 'state'
[17:28:02.887] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[17:28:02.887] - Launch lazy future ...
[17:28:02.888] Packages needed by the future expression (n = 0): <none>
[17:28:02.888] Packages needed by future strategies (n = 0): <none>
[17:28:02.889] {
[17:28:02.889]     {
[17:28:02.889]         {
[17:28:02.889]             ...future.startTime <- base::Sys.time()
[17:28:02.889]             {
[17:28:02.889]                 {
[17:28:02.889]                   {
[17:28:02.889]                     {
[17:28:02.889]                       base::local({
[17:28:02.889]                         has_future <- base::requireNamespace("future", 
[17:28:02.889]                           quietly = TRUE)
[17:28:02.889]                         if (has_future) {
[17:28:02.889]                           ns <- base::getNamespace("future")
[17:28:02.889]                           version <- ns[[".package"]][["version"]]
[17:28:02.889]                           if (is.null(version)) 
[17:28:02.889]                             version <- utils::packageVersion("future")
[17:28:02.889]                         }
[17:28:02.889]                         else {
[17:28:02.889]                           version <- NULL
[17:28:02.889]                         }
[17:28:02.889]                         if (!has_future || version < "1.8.0") {
[17:28:02.889]                           info <- base::c(r_version = base::gsub("R version ", 
[17:28:02.889]                             "", base::R.version$version.string), 
[17:28:02.889]                             platform = base::sprintf("%s (%s-bit)", 
[17:28:02.889]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[17:28:02.889]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[17:28:02.889]                               "release", "version")], collapse = " "), 
[17:28:02.889]                             hostname = base::Sys.info()[["nodename"]])
[17:28:02.889]                           info <- base::sprintf("%s: %s", base::names(info), 
[17:28:02.889]                             info)
[17:28:02.889]                           info <- base::paste(info, collapse = "; ")
[17:28:02.889]                           if (!has_future) {
[17:28:02.889]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[17:28:02.889]                               info)
[17:28:02.889]                           }
[17:28:02.889]                           else {
[17:28:02.889]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[17:28:02.889]                               info, version)
[17:28:02.889]                           }
[17:28:02.889]                           base::stop(msg)
[17:28:02.889]                         }
[17:28:02.889]                       })
[17:28:02.889]                     }
[17:28:02.889]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[17:28:02.889]                     base::options(mc.cores = 1L)
[17:28:02.889]                   }
[17:28:02.889]                   ...future.strategy.old <- future::plan("list")
[17:28:02.889]                   options(future.plan = NULL)
[17:28:02.889]                   Sys.unsetenv("R_FUTURE_PLAN")
[17:28:02.889]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[17:28:02.889]                 }
[17:28:02.889]                 ...future.workdir <- getwd()
[17:28:02.889]             }
[17:28:02.889]             ...future.oldOptions <- base::as.list(base::.Options)
[17:28:02.889]             ...future.oldEnvVars <- base::Sys.getenv()
[17:28:02.889]         }
[17:28:02.889]         base::options(future.startup.script = FALSE, future.globals.onMissing = "error", 
[17:28:02.889]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[17:28:02.889]             future.globals.onMissing = "error", future.globals.onReference = NULL, 
[17:28:02.889]             future.globals.resolve = TRUE, future.resolve.recursive = NULL, 
[17:28:02.889]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[17:28:02.889]             future.stdout.windows.reencode = NULL, width = 80L)
[17:28:02.889]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[17:28:02.889]             base::names(...future.oldOptions))
[17:28:02.889]     }
[17:28:02.889]     if (FALSE) {
[17:28:02.889]     }
[17:28:02.889]     else {
[17:28:02.889]         if (TRUE) {
[17:28:02.889]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[17:28:02.889]                 open = "w")
[17:28:02.889]         }
[17:28:02.889]         else {
[17:28:02.889]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[17:28:02.889]                 windows = "NUL", "/dev/null"), open = "w")
[17:28:02.889]         }
[17:28:02.889]         base::sink(...future.stdout, type = "output", split = FALSE)
[17:28:02.889]         base::on.exit(if (!base::is.null(...future.stdout)) {
[17:28:02.889]             base::sink(type = "output", split = FALSE)
[17:28:02.889]             base::close(...future.stdout)
[17:28:02.889]         }, add = TRUE)
[17:28:02.889]     }
[17:28:02.889]     ...future.frame <- base::sys.nframe()
[17:28:02.889]     ...future.conditions <- base::list()
[17:28:02.889]     ...future.rng <- base::globalenv()$.Random.seed
[17:28:02.889]     if (FALSE) {
[17:28:02.889]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[17:28:02.889]             "...future.value", "...future.globalenv.names", ".Random.seed")
[17:28:02.889]     }
[17:28:02.889]     ...future.result <- base::tryCatch({
[17:28:02.889]         base::withCallingHandlers({
[17:28:02.889]             ...future.value <- base::withVisible(base::local({
[17:28:02.889]                 ...future.makeSendCondition <- base::local({
[17:28:02.889]                   sendCondition <- NULL
[17:28:02.889]                   function(frame = 1L) {
[17:28:02.889]                     if (is.function(sendCondition)) 
[17:28:02.889]                       return(sendCondition)
[17:28:02.889]                     ns <- getNamespace("parallel")
[17:28:02.889]                     if (exists("sendData", mode = "function", 
[17:28:02.889]                       envir = ns)) {
[17:28:02.889]                       parallel_sendData <- get("sendData", mode = "function", 
[17:28:02.889]                         envir = ns)
[17:28:02.889]                       envir <- sys.frame(frame)
[17:28:02.889]                       master <- NULL
[17:28:02.889]                       while (!identical(envir, .GlobalEnv) && 
[17:28:02.889]                         !identical(envir, emptyenv())) {
[17:28:02.889]                         if (exists("master", mode = "list", envir = envir, 
[17:28:02.889]                           inherits = FALSE)) {
[17:28:02.889]                           master <- get("master", mode = "list", 
[17:28:02.889]                             envir = envir, inherits = FALSE)
[17:28:02.889]                           if (inherits(master, c("SOCKnode", 
[17:28:02.889]                             "SOCK0node"))) {
[17:28:02.889]                             sendCondition <<- function(cond) {
[17:28:02.889]                               data <- list(type = "VALUE", value = cond, 
[17:28:02.889]                                 success = TRUE)
[17:28:02.889]                               parallel_sendData(master, data)
[17:28:02.889]                             }
[17:28:02.889]                             return(sendCondition)
[17:28:02.889]                           }
[17:28:02.889]                         }
[17:28:02.889]                         frame <- frame + 1L
[17:28:02.889]                         envir <- sys.frame(frame)
[17:28:02.889]                       }
[17:28:02.889]                     }
[17:28:02.889]                     sendCondition <<- function(cond) NULL
[17:28:02.889]                   }
[17:28:02.889]                 })
[17:28:02.889]                 withCallingHandlers({
[17:28:02.889]                   {
[17:28:02.889]                     x[name] <- list(1)
[17:28:02.889]                     x
[17:28:02.889]                   }
[17:28:02.889]                 }, immediateCondition = function(cond) {
[17:28:02.889]                   sendCondition <- ...future.makeSendCondition()
[17:28:02.889]                   sendCondition(cond)
[17:28:02.889]                   muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:02.889]                   {
[17:28:02.889]                     inherits <- base::inherits
[17:28:02.889]                     invokeRestart <- base::invokeRestart
[17:28:02.889]                     is.null <- base::is.null
[17:28:02.889]                     muffled <- FALSE
[17:28:02.889]                     if (inherits(cond, "message")) {
[17:28:02.889]                       muffled <- grepl(pattern, "muffleMessage")
[17:28:02.889]                       if (muffled) 
[17:28:02.889]                         invokeRestart("muffleMessage")
[17:28:02.889]                     }
[17:28:02.889]                     else if (inherits(cond, "warning")) {
[17:28:02.889]                       muffled <- grepl(pattern, "muffleWarning")
[17:28:02.889]                       if (muffled) 
[17:28:02.889]                         invokeRestart("muffleWarning")
[17:28:02.889]                     }
[17:28:02.889]                     else if (inherits(cond, "condition")) {
[17:28:02.889]                       if (!is.null(pattern)) {
[17:28:02.889]                         computeRestarts <- base::computeRestarts
[17:28:02.889]                         grepl <- base::grepl
[17:28:02.889]                         restarts <- computeRestarts(cond)
[17:28:02.889]                         for (restart in restarts) {
[17:28:02.889]                           name <- restart$name
[17:28:02.889]                           if (is.null(name)) 
[17:28:02.889]                             next
[17:28:02.889]                           if (!grepl(pattern, name)) 
[17:28:02.889]                             next
[17:28:02.889]                           invokeRestart(restart)
[17:28:02.889]                           muffled <- TRUE
[17:28:02.889]                           break
[17:28:02.889]                         }
[17:28:02.889]                       }
[17:28:02.889]                     }
[17:28:02.889]                     invisible(muffled)
[17:28:02.889]                   }
[17:28:02.889]                   muffleCondition(cond)
[17:28:02.889]                 })
[17:28:02.889]             }))
[17:28:02.889]             future::FutureResult(value = ...future.value$value, 
[17:28:02.889]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:02.889]                   ...future.rng), globalenv = if (FALSE) 
[17:28:02.889]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[17:28:02.889]                     ...future.globalenv.names))
[17:28:02.889]                 else NULL, started = ...future.startTime, version = "1.8")
[17:28:02.889]         }, condition = base::local({
[17:28:02.889]             c <- base::c
[17:28:02.889]             inherits <- base::inherits
[17:28:02.889]             invokeRestart <- base::invokeRestart
[17:28:02.889]             length <- base::length
[17:28:02.889]             list <- base::list
[17:28:02.889]             seq.int <- base::seq.int
[17:28:02.889]             signalCondition <- base::signalCondition
[17:28:02.889]             sys.calls <- base::sys.calls
[17:28:02.889]             `[[` <- base::`[[`
[17:28:02.889]             `+` <- base::`+`
[17:28:02.889]             `<<-` <- base::`<<-`
[17:28:02.889]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[17:28:02.889]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[17:28:02.889]                   3L)]
[17:28:02.889]             }
[17:28:02.889]             function(cond) {
[17:28:02.889]                 is_error <- inherits(cond, "error")
[17:28:02.889]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[17:28:02.889]                   NULL)
[17:28:02.889]                 if (is_error) {
[17:28:02.889]                   sessionInformation <- function() {
[17:28:02.889]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[17:28:02.889]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[17:28:02.889]                       search = base::search(), system = base::Sys.info())
[17:28:02.889]                   }
[17:28:02.889]                   ...future.conditions[[length(...future.conditions) + 
[17:28:02.889]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[17:28:02.889]                     cond$call), session = sessionInformation(), 
[17:28:02.889]                     timestamp = base::Sys.time(), signaled = 0L)
[17:28:02.889]                   signalCondition(cond)
[17:28:02.889]                 }
[17:28:02.889]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[17:28:02.889]                 "immediateCondition"))) {
[17:28:02.889]                   signal <- TRUE && inherits(cond, "immediateCondition")
[17:28:02.889]                   ...future.conditions[[length(...future.conditions) + 
[17:28:02.889]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[17:28:02.889]                   if (TRUE && !signal) {
[17:28:02.889]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:02.889]                     {
[17:28:02.889]                       inherits <- base::inherits
[17:28:02.889]                       invokeRestart <- base::invokeRestart
[17:28:02.889]                       is.null <- base::is.null
[17:28:02.889]                       muffled <- FALSE
[17:28:02.889]                       if (inherits(cond, "message")) {
[17:28:02.889]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:02.889]                         if (muffled) 
[17:28:02.889]                           invokeRestart("muffleMessage")
[17:28:02.889]                       }
[17:28:02.889]                       else if (inherits(cond, "warning")) {
[17:28:02.889]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:02.889]                         if (muffled) 
[17:28:02.889]                           invokeRestart("muffleWarning")
[17:28:02.889]                       }
[17:28:02.889]                       else if (inherits(cond, "condition")) {
[17:28:02.889]                         if (!is.null(pattern)) {
[17:28:02.889]                           computeRestarts <- base::computeRestarts
[17:28:02.889]                           grepl <- base::grepl
[17:28:02.889]                           restarts <- computeRestarts(cond)
[17:28:02.889]                           for (restart in restarts) {
[17:28:02.889]                             name <- restart$name
[17:28:02.889]                             if (is.null(name)) 
[17:28:02.889]                               next
[17:28:02.889]                             if (!grepl(pattern, name)) 
[17:28:02.889]                               next
[17:28:02.889]                             invokeRestart(restart)
[17:28:02.889]                             muffled <- TRUE
[17:28:02.889]                             break
[17:28:02.889]                           }
[17:28:02.889]                         }
[17:28:02.889]                       }
[17:28:02.889]                       invisible(muffled)
[17:28:02.889]                     }
[17:28:02.889]                     muffleCondition(cond, pattern = "^muffle")
[17:28:02.889]                   }
[17:28:02.889]                 }
[17:28:02.889]                 else {
[17:28:02.889]                   if (TRUE) {
[17:28:02.889]                     muffleCondition <- function (cond, pattern = "^muffle") 
[17:28:02.889]                     {
[17:28:02.889]                       inherits <- base::inherits
[17:28:02.889]                       invokeRestart <- base::invokeRestart
[17:28:02.889]                       is.null <- base::is.null
[17:28:02.889]                       muffled <- FALSE
[17:28:02.889]                       if (inherits(cond, "message")) {
[17:28:02.889]                         muffled <- grepl(pattern, "muffleMessage")
[17:28:02.889]                         if (muffled) 
[17:28:02.889]                           invokeRestart("muffleMessage")
[17:28:02.889]                       }
[17:28:02.889]                       else if (inherits(cond, "warning")) {
[17:28:02.889]                         muffled <- grepl(pattern, "muffleWarning")
[17:28:02.889]                         if (muffled) 
[17:28:02.889]                           invokeRestart("muffleWarning")
[17:28:02.889]                       }
[17:28:02.889]                       else if (inherits(cond, "condition")) {
[17:28:02.889]                         if (!is.null(pattern)) {
[17:28:02.889]                           computeRestarts <- base::computeRestarts
[17:28:02.889]                           grepl <- base::grepl
[17:28:02.889]                           restarts <- computeRestarts(cond)
[17:28:02.889]                           for (restart in restarts) {
[17:28:02.889]                             name <- restart$name
[17:28:02.889]                             if (is.null(name)) 
[17:28:02.889]                               next
[17:28:02.889]                             if (!grepl(pattern, name)) 
[17:28:02.889]                               next
[17:28:02.889]                             invokeRestart(restart)
[17:28:02.889]                             muffled <- TRUE
[17:28:02.889]                             break
[17:28:02.889]                           }
[17:28:02.889]                         }
[17:28:02.889]                       }
[17:28:02.889]                       invisible(muffled)
[17:28:02.889]                     }
[17:28:02.889]                     muffleCondition(cond, pattern = "^muffle")
[17:28:02.889]                   }
[17:28:02.889]                 }
[17:28:02.889]             }
[17:28:02.889]         }))
[17:28:02.889]     }, error = function(ex) {
[17:28:02.889]         base::structure(base::list(value = NULL, visible = NULL, 
[17:28:02.889]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[17:28:02.889]                 ...future.rng), started = ...future.startTime, 
[17:28:02.889]             finished = Sys.time(), session_uuid = NA_character_, 
[17:28:02.889]             version = "1.8"), class = "FutureResult")
[17:28:02.889]     }, finally = {
[17:28:02.889]         if (!identical(...future.workdir, getwd())) 
[17:28:02.889]             setwd(...future.workdir)
[17:28:02.889]         {
[17:28:02.889]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[17:28:02.889]                 ...future.oldOptions$nwarnings <- NULL
[17:28:02.889]             }
[17:28:02.889]             base::options(...future.oldOptions)
[17:28:02.889]             if (.Platform$OS.type == "windows") {
[17:28:02.889]                 old_names <- names(...future.oldEnvVars)
[17:28:02.889]                 envs <- base::Sys.getenv()
[17:28:02.889]                 names <- names(envs)
[17:28:02.889]                 common <- intersect(names, old_names)
[17:28:02.889]                 added <- setdiff(names, old_names)
[17:28:02.889]                 removed <- setdiff(old_names, names)
[17:28:02.889]                 changed <- common[...future.oldEnvVars[common] != 
[17:28:02.889]                   envs[common]]
[17:28:02.889]                 NAMES <- toupper(changed)
[17:28:02.889]                 args <- list()
[17:28:02.889]                 for (kk in seq_along(NAMES)) {
[17:28:02.889]                   name <- changed[[kk]]
[17:28:02.889]                   NAME <- NAMES[[kk]]
[17:28:02.889]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:02.889]                     next
[17:28:02.889]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:02.889]                 }
[17:28:02.889]                 NAMES <- toupper(added)
[17:28:02.889]                 for (kk in seq_along(NAMES)) {
[17:28:02.889]                   name <- added[[kk]]
[17:28:02.889]                   NAME <- NAMES[[kk]]
[17:28:02.889]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:02.889]                     next
[17:28:02.889]                   args[[name]] <- ""
[17:28:02.889]                 }
[17:28:02.889]                 NAMES <- toupper(removed)
[17:28:02.889]                 for (kk in seq_along(NAMES)) {
[17:28:02.889]                   name <- removed[[kk]]
[17:28:02.889]                   NAME <- NAMES[[kk]]
[17:28:02.889]                   if (name != NAME && is.element(NAME, old_names)) 
[17:28:02.889]                     next
[17:28:02.889]                   args[[name]] <- ...future.oldEnvVars[[name]]
[17:28:02.889]                 }
[17:28:02.889]                 if (length(args) > 0) 
[17:28:02.889]                   base::do.call(base::Sys.setenv, args = args)
[17:28:02.889]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[17:28:02.889]             }
[17:28:02.889]             else {
[17:28:02.889]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[17:28:02.889]             }
[17:28:02.889]             {
[17:28:02.889]                 if (base::length(...future.futureOptionsAdded) > 
[17:28:02.889]                   0L) {
[17:28:02.889]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[17:28:02.889]                   base::names(opts) <- ...future.futureOptionsAdded
[17:28:02.889]                   base::options(opts)
[17:28:02.889]                 }
[17:28:02.889]                 {
[17:28:02.889]                   {
[17:28:02.889]                     base::options(mc.cores = ...future.mc.cores.old)
[17:28:02.889]                     NULL
[17:28:02.889]                   }
[17:28:02.889]                   options(future.plan = NULL)
[17:28:02.889]                   if (is.na(NA_character_)) 
[17:28:02.889]                     Sys.unsetenv("R_FUTURE_PLAN")
[17:28:02.889]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[17:28:02.889]                   future::plan(...future.strategy.old, .cleanup = FALSE, 
[17:28:02.889]                     .init = FALSE)
[17:28:02.889]                 }
[17:28:02.889]             }
[17:28:02.889]         }
[17:28:02.889]     })
[17:28:02.889]     if (TRUE) {
[17:28:02.889]         base::sink(type = "output", split = FALSE)
[17:28:02.889]         if (TRUE) {
[17:28:02.889]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[17:28:02.889]         }
[17:28:02.889]         else {
[17:28:02.889]             ...future.result["stdout"] <- base::list(NULL)
[17:28:02.889]         }
[17:28:02.889]         base::close(...future.stdout)
[17:28:02.889]         ...future.stdout <- NULL
[17:28:02.889]     }
[17:28:02.889]     ...future.result$conditions <- ...future.conditions
[17:28:02.889]     ...future.result$finished <- base::Sys.time()
[17:28:02.889]     ...future.result
[17:28:02.889] }
[17:28:02.894] Exporting 2 global objects (379 bytes) to cluster node #1 ...
[17:28:02.895] Exporting 'x' (31 bytes) to cluster node #1 ...
[17:28:02.895] Exporting 'x' (31 bytes) to cluster node #1 ... DONE
[17:28:02.895] Exporting 'name' (40 bytes) to cluster node #1 ...
[17:28:02.896] Exporting 'name' (40 bytes) to cluster node #1 ... DONE
[17:28:02.896] Exporting 2 global objects (379 bytes) to cluster node #1 ... DONE
[17:28:02.897] MultisessionFuture started
[17:28:02.897] - Launch lazy future ... done
[17:28:02.897] run() for 'MultisessionFuture' ... done
[17:28:02.897] result() for ClusterFuture ...
[17:28:02.897] receiveMessageFromWorker() for ClusterFuture ...
[17:28:02.898] - Validating connection of MultisessionFuture
[17:28:02.914] - received message: FutureResult
[17:28:02.915] - Received FutureResult
[17:28:02.915] - Erased future from FutureRegistry
[17:28:02.915] result() for ClusterFuture ...
[17:28:02.915] - result already collected: FutureResult
[17:28:02.915] result() for ClusterFuture ... done
[17:28:02.915] receiveMessageFromWorker() for ClusterFuture ... done
[17:28:02.916] result() for ClusterFuture ... done
[17:28:02.916] result() for ClusterFuture ...
[17:28:02.916] - result already collected: FutureResult
[17:28:02.916] result() for ClusterFuture ... done
$a
[1] 1

Testing with 2 cores ... DONE
> 
> message("*** Globals - subassignments w/ x$a <- value ... DONE")
*** Globals - subassignments w/ x$a <- value ... DONE
> 
> message("*** Globals - subassignments ... DONE")
*** Globals - subassignments ... DONE
> 
> source("incl/end.R")
[17:28:02.918] plan(): Setting new future strategy stack:
[17:28:02.918] List of future strategies:
[17:28:02.918] 1. FutureStrategy:
[17:28:02.918]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[17:28:02.918]    - tweaked: FALSE
[17:28:02.918]    - call: future::plan(oplan)
[17:28:02.926] plan(): nbrOfWorkers() = 1
Failed to undo environment variables:
 - Expected environment variables: [n=205] '!ExitCode', 'ALLUSERSPROFILE', 'APPDATA', 'BIBINPUTS', 'BINDIR', 'BSTINPUTS', 'COMMONPROGRAMFILES', 'COMPUTERNAME', 'COMSPEC', 'CURL_CA_BUNDLE', 'CYGWIN', 'CommonProgramFiles(x86)', 'CommonProgramW6432', 'DriverData', 'HOME', 'HOMEDRIVE', 'HOMEPATH', 'JAGS_ROOT', 'JAVA_HOME', 'LANGUAGE', 'LC_COLLATE', 'LC_MONETARY', 'LC_TIME', 'LOCALAPPDATA', 'LOGONSERVER', 'LS_HOME', 'LS_LICENSE_PATH', 'MAKE', 'MAKEFLAGS', 'MAKELEVEL', 'MFLAGS', 'MSMPI_BENCHMARKS', 'MSMPI_BIN', 'MSYS2_ENV_CONV_EXCL', 'NUMBER_OF_PROCESSORS', 'OCL', 'OMP_THREAD_LIMIT', 'OS', 'PATH', 'PATHEXT', 'PROCESSOR_ARCHITECTURE', 'PROCESSOR_IDENTIFIER', 'PROCESSOR_LEVEL', 'PROCESSOR_REVISION', 'PROGRAMFILES', 'PROMPT', 'PSModulePath', 'PUBLIC', 'PWD', 'ProgramData', 'ProgramFiles(x86)', 'ProgramW6432', 'RTOOLS43_HOME', 'RTOOLS44_HOME', 'R_ARCH', 'R_BROWSER', 'R_BZIPCMD', 'R_CMD', 'R_COMPILED_BY', 'R_CRAN_WEB', 'R_CUSTOM_TOOLS_PATH', 'R_CUSTOM_TOOLS_SOFT', 'R_DOC_DIR', 'R_ENVIRON_USER', 'R_GSCMD', 'R_GZIPCMD', 'R_HOME', 'R_INCLUDE_DIR', 'R_INSTALL_TAR', 'R_LIBS', 'R_LIBS_SITE', 'R_LIBS_USER', 'R_MAX_NUM_DLLS', 'R_OSTYPE', 'R_PAPERSIZE', 'R_PAPERSIZE_USER', 'R_PARALLELLY_MAKENODEPSOCK_AUTOKILL', 'R_PARALLELLY_MAKENODEPSOCK_CONNECTTIMEOUT', 'R_PARALLELLY_MAKENODEPSOCK_RSCRIPT_LABEL', 'R_PARALLELLY_MAKENODEPSOCK_SESSIONINFO_PKGS', 'R_PARALLELLY_MAKENODEPSOCK_TIMEOUT', 'R_PARALLELLY_RANDOM_PORTS', 'R_PARALLEL_PORT', 'R_RD4PDF', 'R_RTOOLS44_PATH', 'R_SCRIPT_LEGACY', 'R_SHARE_DIR', 'R_TESTS', 'R_UNZIPCMD', 'R_USER', 'R_VERSION', 'R_ZIPCMD', 'SED', 'SHLVL', 'SYSTEMDRIVE', 'SYSTEMROOT', 'TAR', 'TAR_OPTIONS', 'TEMP', 'TERM', 'TEXINPUTS', 'TMP', 'TMPDIR', 'USERDOMAIN', 'USERDOMAIN_ROAMINGPROFILE', 'USERNAME', 'USERPROFILE', 'WINDIR', '_', '_R_CHECK_AUTOCONF_', '_R_CHECK_BOGUS_RETURN_', '_R_CHECK_BROWSER_NONINTERACTIVE_', '_R_CHECK_BUILD_VIGNETTES_SEPARATELY_', '_R_CHECK_CODETOOLS_PROFILE_', '_R_CHECK_CODE_ASSIGN_TO_GLOBALENV_', '_R_CHECK_CODE_ATTACH_', '_R_CHECK_CODE_CLASS_IS_STRING_', '_R_CHECK_CODE_DATA_INTO_GLOBALENV_', '_R_CHECK_CODE_USAGE_VIA_NAMESPACES_', '_R_CHECK_CODE_USAGE_WITHOUT_LOADING_', '_R_CHECK_CODE_USAGE_WITH_ONLY_BASE_ATTACHED_', '_R_CHECK_CODOC_VARIABLES_IN_USAGES_', '_R_CHECK_COMPACT_DATA2_', '_R_CHECK_COMPILATION_FLAGS_', '_R_CHECK_CONNECTIONS_LEFT_OPEN_', '_R_CHECK_CRAN_INCOMING_', '_R_CHECK_CRAN_INCOMING_CHECK_FILE_URIS_', '_R_CHECK_CRAN_INCOMING_CHECK_URLS_IN_PARALLEL_', '_R_CHECK_CRAN_INCOMING_NOTE_GNU_MAKE_', '_R_CHECK_CRAN_INCOMING_REMOTE_', '_R_CHECK_CRAN_INCOMING_USE_ASPELL_', '_R_CHECK_DATALIST_', '_R_CHECK_DEPRECATED_DEFUNCT_', '_R_CHECK_DOC_SIZES2_', '_R_CHECK_DOT_FIRSTLIB_', '_R_CHECK_DOT_INTERNAL_', '_R_CHECK_EXAMPLE_TIMING_THRESHOLD_', '_R_CHECK_EXECUTABLES_', '_R_CHECK_EXECUTABLES_EXCLUSIONS_', '_R_CHECK_FF_CALLS_', '_R_CHECK_FF_DUP_', '_R_CHECK_FORCE_SUGGESTS_', '_R_CHECK_FUTURE_FILE_TIMESTAMPS_', '_R_CHECK_FUTURE_FILE_TIMESTAMPS_LEEWAY_', '_R_CHECK_HAVE_MYSQL_', '_R_CHECK_HAVE_ODBC_', '_R_CHECK_HAVE_PERL_', '_R_CHECK_HAVE_POSTGRES_', '_R_CHECK_INSTALL_DEPENDS_', '_R_CHECK_INTERNALS2_', '_R_CHECK_LENGTH_1_CONDITION_', '_R_CHECK_LICENSE_', '_R_CHECK_LIMIT_CORES_', '_R_CHECK_MATRIX_DATA_', '_R_CHECK_MBCS_CONVERSION_FAILURE_', '_R_CHECK_NATIVE_ROUTINE_REGISTRATION_', '_R_CHECK_NEWS_IN_PLAIN_TEXT_', '_R_CHECK_NO_RECOMMENDED_', '_R_CHECK_NO_STOP_ON_TEST_ERROR_', '_R_CHECK_ORPHANED_', '_R_CHECK_OVERWRITE_REGISTERED_S3_METHODS_', '_R_CHECK_PACKAGES_USED_IGNORE_UNUSED_IMPORTS_', '_R_CHECK_PACKAGES_USED_IN_TESTS_USE_SUBDIRS_', '_R_CHECK_PACKAGE_DATASETS_SUPPRESS_NOTES_', '_R_CHECK_PACKAGE_NAME_', '_R_CHECK_PKG_SIZES_', '_R_CHECK_PKG_SIZES_THRESHOLD_', '_R_CHECK_PRAGMAS_', '_R_CHECK_RD_EXAMPLES_T_AND_F_', '_R_CHECK_RD_LINE_WIDTHS_', '_R_CHECK_RD_MATH_RENDERING_', '_R_CHECK_RD_NOTE_LOST_BRACES_', '_R_CHECK_RD_VALIDATE_RD2HTML_', '_R_CHECK_REPLACING_IMPORTS_', '_R_CHECK_R_DEPENDS_', '_R_CHECK_S3_METHODS_SHOW_POSSIBLE_ISSUES_', '_R_CHECK_SCREEN_DEVICE_', '_R_CHECK_SERIALIZATION_', '_R_CHECK_SHLIB_OPENMP_FLAGS_', '_R_CHECK_SRC_MINUS_W_IMPLICIT_', '_R_CHECK_SUBDIRS_NOCASE_', '_R_CHECK_SUGGESTS_ONLY_', '_R_CHECK_SYSTEM_CLOCK_', '_R_CHECK_TESTS_NLINES_', '_R_CHECK_TEST_TIMING_', '_R_CHECK_TIMINGS_', '_R_CHECK_TOPLEVEL_FILES_', '_R_CHECK_UNDOC_USE_ALL_NAMES_', '_R_CHECK_UNSAFE_CALLS_', '_R_CHECK_URLS_SHOW_301_STATUS_', '_R_CHECK_VC_DIRS_', '_R_CHECK_VIGNETTES_NLINES_', '_R_CHECK_VIGNETTES_SKIP_RUN_MAYBE_', '_R_CHECK_VIGNETTE_TIMING_', '_R_CHECK_VIGNETTE_TITLES_', '_R_CHECK_WINDOWS_DEVICE_', '_R_CHECK_XREFS_NOTE_MISSING_PACKAGE_ANCHORS_', '_R_CHECK_XREFS_USE_ALIASES_FROM_CRAN_', '_R_CLASS_MATRIX_ARRAY_', '_R_DEPRECATED_IS_R_', '_R_S3_METHOD_LOOKUP_BASEENV_AFTER_GLOBALENV_', '_R_SHLIB_BUILD_OBJECTS_SYMBOL_TABLES_', '__R_CHECK_DOC_FILES_NOTE_IF_ALL_SPECIAL__', 'maj.version', 'nextArg--timingsnextArg--install'
 - Environment variables still there: [n=0] 
 - Environment variables missing: [n=1] 'MAKEFLAGS'
Differences environment variable by environment variable:
List of 3
 $ name    : chr "MAKEFLAGS"
 $ expected: 'Dlist' chr ""
 $ actual  : 'Dlist' chr NA
> 
> proc.time()
   user  system elapsed 
   1.79    0.17    3.18