R Under development (unstable) (2023-12-20 r85713 ucrt) -- "Unsuffered Consequences"
Copyright (C) 2023 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")
[01:28:04.062] plan(): Setting new future strategy stack:
[01:28:04.063] List of future strategies:
[01:28:04.063] 1. sequential:
[01:28:04.063]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:04.063]    - tweaked: FALSE
[01:28:04.063]    - call: future::plan("sequential")
[01:28:04.086] 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') ...
[01:28:04.191] plan(): Setting new future strategy stack:
[01:28:04.191] List of future strategies:
[01:28:04.191] 1. sequential:
[01:28:04.191]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:04.191]    - tweaked: FALSE
[01:28:04.191]    - call: plan(strategy)
[01:28:04.210] plan(): nbrOfWorkers() = 1
Warning: 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'
[01:28:04.211] getGlobalsAndPackages() ...
Warning: 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'
[01:28:04.212] Searching for globals...
[01:28:04.222] - globals found: [5] '{', 'x', '<-', '$', '$<-'
[01:28:04.222] Searching for globals ... DONE
[01:28:04.222] Resolving globals: TRUE
[01:28:04.222] Resolving any globals that are futures ...
[01:28:04.223] - globals: [5] '{', 'x', '<-', '$', '$<-'
[01:28:04.223] Resolving any globals that are futures ... DONE
[01:28:04.224] Resolving futures part of globals (recursively) ...
[01:28:04.225] resolve() on list ...
[01:28:04.225]  recursive: 99
[01:28:04.225]  length: 1
[01:28:04.226]  elements: 'x'
[01:28:04.226]  length: 0 (resolved future 1)
[01:28:04.226] resolve() on list ... DONE
[01:28:04.226] - globals: [1] 'x'
[01:28:04.226] Resolving futures part of globals (recursively) ... DONE
[01:28:04.227] The total size of the 1 globals is 0 bytes (0 bytes)
[01:28:04.228] The total size of the 1 globals exported for future expression ('{; x$a <- 1; x; }') is 0 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (0 bytes of class 'list')
[01:28:04.228] - globals: [1] 'x'
[01:28:04.228] 
[01:28:04.228] getGlobalsAndPackages() ... DONE
[01:28:04.229] run() for 'Future' ...
[01:28:04.229] - state: 'created'
[01:28:04.230] - Future backend: 'FutureStrategy', 'sequential', 'uniprocess', 'future', 'function'
[01:28:04.230] - Future class: 'SequentialFuture', 'UniprocessFuture', 'Future', 'environment'
[01:28:04.230] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ...
[01:28:04.230]   - Field: 'label'
[01:28:04.231]   - Field: 'local'
[01:28:04.231]   - Field: 'owner'
[01:28:04.231]   - Field: 'envir'
[01:28:04.231]   - Field: 'packages'
[01:28:04.231]   - Field: 'gc'
[01:28:04.232]   - Field: 'conditions'
[01:28:04.232]   - Field: 'expr'
[01:28:04.232]   - Field: 'uuid'
[01:28:04.232]   - Field: 'seed'
[01:28:04.232]   - Field: 'version'
[01:28:04.232]   - Field: 'result'
[01:28:04.233]   - Field: 'asynchronous'
[01:28:04.233]   - Field: 'calls'
[01:28:04.233]   - Field: 'globals'
[01:28:04.233]   - Field: 'stdout'
[01:28:04.233]   - Field: 'earlySignal'
[01:28:04.234]   - Field: 'lazy'
[01:28:04.234]   - Field: 'state'
[01:28:04.234] - Copy elements of temporary 'SequentialFuture' to final 'Future' object ... done
[01:28:04.234] - Launch lazy future ...
[01:28:04.235] Packages needed by the future expression (n = 0): <none>
[01:28:04.235] Packages needed by future strategies (n = 0): <none>
[01:28:04.236] {
[01:28:04.236]     {
[01:28:04.236]         {
[01:28:04.236]             ...future.startTime <- base::Sys.time()
[01:28:04.236]             {
[01:28:04.236]                 {
[01:28:04.236]                   {
[01:28:04.236]                     base::local({
[01:28:04.236]                       has_future <- base::requireNamespace("future", 
[01:28:04.236]                         quietly = TRUE)
[01:28:04.236]                       if (has_future) {
[01:28:04.236]                         ns <- base::getNamespace("future")
[01:28:04.236]                         version <- ns[[".package"]][["version"]]
[01:28:04.236]                         if (is.null(version)) 
[01:28:04.236]                           version <- utils::packageVersion("future")
[01:28:04.236]                       }
[01:28:04.236]                       else {
[01:28:04.236]                         version <- NULL
[01:28:04.236]                       }
[01:28:04.236]                       if (!has_future || version < "1.8.0") {
[01:28:04.236]                         info <- base::c(r_version = base::gsub("R version ", 
[01:28:04.236]                           "", base::R.version$version.string), 
[01:28:04.236]                           platform = base::sprintf("%s (%s-bit)", 
[01:28:04.236]                             base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:04.236]                           os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:04.236]                             "release", "version")], collapse = " "), 
[01:28:04.236]                           hostname = base::Sys.info()[["nodename"]])
[01:28:04.236]                         info <- base::sprintf("%s: %s", base::names(info), 
[01:28:04.236]                           info)
[01:28:04.236]                         info <- base::paste(info, collapse = "; ")
[01:28:04.236]                         if (!has_future) {
[01:28:04.236]                           msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:04.236]                             info)
[01:28:04.236]                         }
[01:28:04.236]                         else {
[01:28:04.236]                           msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:04.236]                             info, version)
[01:28:04.236]                         }
[01:28:04.236]                         base::stop(msg)
[01:28:04.236]                       }
[01:28:04.236]                     })
[01:28:04.236]                   }
[01:28:04.236]                   options(future.plan = NULL)
[01:28:04.236]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:04.236]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:04.236]                 }
[01:28:04.236]                 ...future.workdir <- getwd()
[01:28:04.236]             }
[01:28:04.236]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:04.236]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:04.236]         }
[01:28:04.236]         base::options(future.startup.script = FALSE, future.globals.onMissing = "error", 
[01:28:04.236]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:28:04.236]             future.globals.onMissing = "error", future.globals.onReference = NULL, 
[01:28:04.236]             future.globals.resolve = TRUE, future.resolve.recursive = NULL, 
[01:28:04.236]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:04.236]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:04.236]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:04.236]             base::names(...future.oldOptions))
[01:28:04.236]     }
[01:28:04.236]     if (FALSE) {
[01:28:04.236]     }
[01:28:04.236]     else {
[01:28:04.236]         if (TRUE) {
[01:28:04.236]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:04.236]                 open = "w")
[01:28:04.236]         }
[01:28:04.236]         else {
[01:28:04.236]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:04.236]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:04.236]         }
[01:28:04.236]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:04.236]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:04.236]             base::sink(type = "output", split = FALSE)
[01:28:04.236]             base::close(...future.stdout)
[01:28:04.236]         }, add = TRUE)
[01:28:04.236]     }
[01:28:04.236]     ...future.frame <- base::sys.nframe()
[01:28:04.236]     ...future.conditions <- base::list()
[01:28:04.236]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:04.236]     if (FALSE) {
[01:28:04.236]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:04.236]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:04.236]     }
[01:28:04.236]     ...future.result <- base::tryCatch({
[01:28:04.236]         base::withCallingHandlers({
[01:28:04.236]             ...future.value <- base::withVisible(base::local({
[01:28:04.236]                 x$a <- 1
[01:28:04.236]                 x
[01:28:04.236]             }))
[01:28:04.236]             future::FutureResult(value = ...future.value$value, 
[01:28:04.236]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:04.236]                   ...future.rng), globalenv = if (FALSE) 
[01:28:04.236]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:04.236]                     ...future.globalenv.names))
[01:28:04.236]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:04.236]         }, condition = base::local({
[01:28:04.236]             c <- base::c
[01:28:04.236]             inherits <- base::inherits
[01:28:04.236]             invokeRestart <- base::invokeRestart
[01:28:04.236]             length <- base::length
[01:28:04.236]             list <- base::list
[01:28:04.236]             seq.int <- base::seq.int
[01:28:04.236]             signalCondition <- base::signalCondition
[01:28:04.236]             sys.calls <- base::sys.calls
[01:28:04.236]             `[[` <- base::`[[`
[01:28:04.236]             `+` <- base::`+`
[01:28:04.236]             `<<-` <- base::`<<-`
[01:28:04.236]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:04.236]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:04.236]                   3L)]
[01:28:04.236]             }
[01:28:04.236]             function(cond) {
[01:28:04.236]                 is_error <- inherits(cond, "error")
[01:28:04.236]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:04.236]                   NULL)
[01:28:04.236]                 if (is_error) {
[01:28:04.236]                   sessionInformation <- function() {
[01:28:04.236]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:04.236]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:04.236]                       search = base::search(), system = base::Sys.info())
[01:28:04.236]                   }
[01:28:04.236]                   ...future.conditions[[length(...future.conditions) + 
[01:28:04.236]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:04.236]                     cond$call), session = sessionInformation(), 
[01:28:04.236]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:04.236]                   signalCondition(cond)
[01:28:04.236]                 }
[01:28:04.236]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:04.236]                 "immediateCondition"))) {
[01:28:04.236]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:04.236]                   ...future.conditions[[length(...future.conditions) + 
[01:28:04.236]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:04.236]                   if (TRUE && !signal) {
[01:28:04.236]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:04.236]                     {
[01:28:04.236]                       inherits <- base::inherits
[01:28:04.236]                       invokeRestart <- base::invokeRestart
[01:28:04.236]                       is.null <- base::is.null
[01:28:04.236]                       muffled <- FALSE
[01:28:04.236]                       if (inherits(cond, "message")) {
[01:28:04.236]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:04.236]                         if (muffled) 
[01:28:04.236]                           invokeRestart("muffleMessage")
[01:28:04.236]                       }
[01:28:04.236]                       else if (inherits(cond, "warning")) {
[01:28:04.236]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:04.236]                         if (muffled) 
[01:28:04.236]                           invokeRestart("muffleWarning")
[01:28:04.236]                       }
[01:28:04.236]                       else if (inherits(cond, "condition")) {
[01:28:04.236]                         if (!is.null(pattern)) {
[01:28:04.236]                           computeRestarts <- base::computeRestarts
[01:28:04.236]                           grepl <- base::grepl
[01:28:04.236]                           restarts <- computeRestarts(cond)
[01:28:04.236]                           for (restart in restarts) {
[01:28:04.236]                             name <- restart$name
[01:28:04.236]                             if (is.null(name)) 
[01:28:04.236]                               next
[01:28:04.236]                             if (!grepl(pattern, name)) 
[01:28:04.236]                               next
[01:28:04.236]                             invokeRestart(restart)
[01:28:04.236]                             muffled <- TRUE
[01:28:04.236]                             break
[01:28:04.236]                           }
[01:28:04.236]                         }
[01:28:04.236]                       }
[01:28:04.236]                       invisible(muffled)
[01:28:04.236]                     }
[01:28:04.236]                     muffleCondition(cond, pattern = "^muffle")
[01:28:04.236]                   }
[01:28:04.236]                 }
[01:28:04.236]                 else {
[01:28:04.236]                   if (TRUE) {
[01:28:04.236]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:04.236]                     {
[01:28:04.236]                       inherits <- base::inherits
[01:28:04.236]                       invokeRestart <- base::invokeRestart
[01:28:04.236]                       is.null <- base::is.null
[01:28:04.236]                       muffled <- FALSE
[01:28:04.236]                       if (inherits(cond, "message")) {
[01:28:04.236]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:04.236]                         if (muffled) 
[01:28:04.236]                           invokeRestart("muffleMessage")
[01:28:04.236]                       }
[01:28:04.236]                       else if (inherits(cond, "warning")) {
[01:28:04.236]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:04.236]                         if (muffled) 
[01:28:04.236]                           invokeRestart("muffleWarning")
[01:28:04.236]                       }
[01:28:04.236]                       else if (inherits(cond, "condition")) {
[01:28:04.236]                         if (!is.null(pattern)) {
[01:28:04.236]                           computeRestarts <- base::computeRestarts
[01:28:04.236]                           grepl <- base::grepl
[01:28:04.236]                           restarts <- computeRestarts(cond)
[01:28:04.236]                           for (restart in restarts) {
[01:28:04.236]                             name <- restart$name
[01:28:04.236]                             if (is.null(name)) 
[01:28:04.236]                               next
[01:28:04.236]                             if (!grepl(pattern, name)) 
[01:28:04.236]                               next
[01:28:04.236]                             invokeRestart(restart)
[01:28:04.236]                             muffled <- TRUE
[01:28:04.236]                             break
[01:28:04.236]                           }
[01:28:04.236]                         }
[01:28:04.236]                       }
[01:28:04.236]                       invisible(muffled)
[01:28:04.236]                     }
[01:28:04.236]                     muffleCondition(cond, pattern = "^muffle")
[01:28:04.236]                   }
[01:28:04.236]                 }
[01:28:04.236]             }
[01:28:04.236]         }))
[01:28:04.236]     }, error = function(ex) {
[01:28:04.236]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:04.236]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:04.236]                 ...future.rng), started = ...future.startTime, 
[01:28:04.236]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:04.236]             version = "1.8"), class = "FutureResult")
[01:28:04.236]     }, finally = {
[01:28:04.236]         if (!identical(...future.workdir, getwd())) 
[01:28:04.236]             setwd(...future.workdir)
[01:28:04.236]         {
[01:28:04.236]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:04.236]                 ...future.oldOptions$nwarnings <- NULL
[01:28:04.236]             }
[01:28:04.236]             base::options(...future.oldOptions)
[01:28:04.236]             if (.Platform$OS.type == "windows") {
[01:28:04.236]                 old_names <- names(...future.oldEnvVars)
[01:28:04.236]                 envs <- base::Sys.getenv()
[01:28:04.236]                 names <- names(envs)
[01:28:04.236]                 common <- intersect(names, old_names)
[01:28:04.236]                 added <- setdiff(names, old_names)
[01:28:04.236]                 removed <- setdiff(old_names, names)
[01:28:04.236]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:04.236]                   envs[common]]
[01:28:04.236]                 NAMES <- toupper(changed)
[01:28:04.236]                 args <- list()
[01:28:04.236]                 for (kk in seq_along(NAMES)) {
[01:28:04.236]                   name <- changed[[kk]]
[01:28:04.236]                   NAME <- NAMES[[kk]]
[01:28:04.236]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:04.236]                     next
[01:28:04.236]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:04.236]                 }
[01:28:04.236]                 NAMES <- toupper(added)
[01:28:04.236]                 for (kk in seq_along(NAMES)) {
[01:28:04.236]                   name <- added[[kk]]
[01:28:04.236]                   NAME <- NAMES[[kk]]
[01:28:04.236]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:04.236]                     next
[01:28:04.236]                   args[[name]] <- ""
[01:28:04.236]                 }
[01:28:04.236]                 NAMES <- toupper(removed)
[01:28:04.236]                 for (kk in seq_along(NAMES)) {
[01:28:04.236]                   name <- removed[[kk]]
[01:28:04.236]                   NAME <- NAMES[[kk]]
[01:28:04.236]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:04.236]                     next
[01:28:04.236]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:04.236]                 }
[01:28:04.236]                 if (length(args) > 0) 
[01:28:04.236]                   base::do.call(base::Sys.setenv, args = args)
[01:28:04.236]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:04.236]             }
[01:28:04.236]             else {
[01:28:04.236]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:04.236]             }
[01:28:04.236]             {
[01:28:04.236]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:04.236]                   0L) {
[01:28:04.236]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:04.236]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:04.236]                   base::options(opts)
[01:28:04.236]                 }
[01:28:04.236]                 {
[01:28:04.236]                   {
[01:28:04.236]                     NULL
[01:28:04.236]                     RNGkind("Mersenne-Twister")
[01:28:04.236]                     base::rm(list = ".Random.seed", envir = base::globalenv(), 
[01:28:04.236]                       inherits = FALSE)
[01:28:04.236]                   }
[01:28:04.236]                   options(future.plan = NULL)
[01:28:04.236]                   if (is.na(NA_character_)) 
[01:28:04.236]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:04.236]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:04.236]                   future::plan(list(function (..., envir = parent.frame()) 
[01:28:04.236]                   {
[01:28:04.236]                     future <- SequentialFuture(..., envir = envir)
[01:28:04.236]                     if (!future$lazy) 
[01:28:04.236]                       future <- run(future)
[01:28:04.236]                     invisible(future)
[01:28:04.236]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:04.236]                 }
[01:28:04.236]             }
[01:28:04.236]         }
[01:28:04.236]     })
[01:28:04.236]     if (TRUE) {
[01:28:04.236]         base::sink(type = "output", split = FALSE)
[01:28:04.236]         if (TRUE) {
[01:28:04.236]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:04.236]         }
[01:28:04.236]         else {
[01:28:04.236]             ...future.result["stdout"] <- base::list(NULL)
[01:28:04.236]         }
[01:28:04.236]         base::close(...future.stdout)
[01:28:04.236]         ...future.stdout <- NULL
[01:28:04.236]     }
[01:28:04.236]     ...future.result$conditions <- ...future.conditions
[01:28:04.236]     ...future.result$finished <- base::Sys.time()
[01:28:04.236]     ...future.result
[01:28:04.236] }
[01:28:04.241] assign_globals() ...
[01:28:04.241] List of 1
[01:28:04.241]  $ x: list()
[01:28:04.241]  - attr(*, "where")=List of 1
[01:28:04.241]   ..$ x:<environment: R_EmptyEnv> 
[01:28:04.241]  - attr(*, "class")= chr [1:3] "FutureGlobals" "Globals" "list"
[01:28:04.241]  - attr(*, "resolved")= logi TRUE
[01:28:04.241]  - attr(*, "total_size")= num 0
[01:28:04.241]  - attr(*, "already-done")= logi TRUE
[01:28:04.247] - copied 'x' to environment
[01:28:04.247] assign_globals() ... done
[01:28:04.247] plan(): Setting new future strategy stack:
[01:28:04.248] List of future strategies:
[01:28:04.248] 1. sequential:
[01:28:04.248]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:04.248]    - tweaked: FALSE
[01:28:04.248]    - call: NULL
[01:28:04.248] plan(): nbrOfWorkers() = 1
[01:28:04.250] plan(): Setting new future strategy stack:
[01:28:04.251] List of future strategies:
[01:28:04.251] 1. sequential:
[01:28:04.251]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:04.251]    - tweaked: FALSE
[01:28:04.251]    - call: plan(strategy)
[01:28:04.251] plan(): nbrOfWorkers() = 1
[01:28:04.252] SequentialFuture started (and completed)
[01:28:04.252] - Launch lazy future ... done
[01:28:04.253] run() for 'SequentialFuture' ... done
$a
[1] 1

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

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

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

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

$a
[1] 1

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

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

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

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

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

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

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

Testing with 1 cores ... DONE
Testing with 2 cores ...
availableCores(): 2
- plan('multisession') ...
[01:28:04.602] plan(): Setting new future strategy stack:
[01:28:04.602] List of future strategies:
[01:28:04.602] 1. multisession:
[01:28:04.602]    - args: function (..., workers = availableCores(), lazy = FALSE, rscript_libs = .libPaths(), envir = parent.frame())
[01:28:04.602]    - tweaked: FALSE
[01:28:04.602]    - call: plan(strategy)
[01:28:04.603] plan(): plan_init() of 'multisession', 'cluster', 'multiprocess', 'future', 'function' ...
[01:28:04.603] multisession:
[01:28:04.603] - args: function (..., workers = availableCores(), lazy = FALSE, rscript_libs = .libPaths(), envir = parent.frame())
[01:28:04.603] - tweaked: FALSE
[01:28:04.603] - call: plan(strategy)
Warning: 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'
[01:28:04.609] getGlobalsAndPackages() ...
Warning: 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'
[01:28:04.610] Not searching for globals
[01:28:04.610] - globals: [0] <none>
[01:28:04.610] getGlobalsAndPackages() ... DONE
[01:28:04.611] [local output] makeClusterPSOCK() ...
[01:28:04.708] [local output] Workers: [n = 2] 'localhost', 'localhost'
[01:28:04.715] [local output] Base port: 22671
[01:28:04.715] [local output] Getting setup options for 2 cluster nodes ...
[01:28:04.716] [local output]  - Node 1 of 2 ...
[01:28:04.717] [local output] localMachine=TRUE => revtunnel=FALSE

[01:28:04.719] Testing if worker's PID can be inferred: '"D:/RCompile/recent/R/bin/x64/Rscript" -e "try(suppressWarnings(cat(Sys.getpid(),file=\"D:/temp/RtmpaqTpKX/worker.rank=1.parallelly.parent=13884.363c21c87372.pid\")), silent = TRUE)" -e "file.exists(\"D:/temp/RtmpaqTpKX/worker.rank=1.parallelly.parent=13884.363c21c87372.pid\")"'
[01:28:04.948] - Possible to infer worker's PID: TRUE
[01:28:04.950] [local output] Rscript port: 22671

[01:28:04.951] [local output]  - Node 2 of 2 ...
[01:28:04.952] [local output] localMachine=TRUE => revtunnel=FALSE

[01:28:04.953] [local output] Rscript port: 22671

[01:28:04.954] [local output] Getting setup options for 2 cluster nodes ... done
[01:28:04.954] [local output]  - Parallel setup requested for some PSOCK nodes
[01:28:04.956] [local output] Setting up PSOCK nodes in parallel
[01:28:04.956] List of 36
[01:28:04.956]  $ worker          : chr "localhost"
[01:28:04.956]   ..- attr(*, "localhost")= logi TRUE
[01:28:04.956]  $ master          : chr "localhost"
[01:28:04.956]  $ port            : int 22671
[01:28:04.956]  $ connectTimeout  : num 120
[01:28:04.956]  $ timeout         : num 120
[01:28:04.956]  $ rscript         : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\""
[01:28:04.956]  $ homogeneous     : logi TRUE
[01:28:04.956]  $ rscript_args    : chr "--default-packages=datasets,utils,grDevices,graphics,stats,methods -e \"#label=globals,subassignment.R:13884:CR"| __truncated__
[01:28:04.956]  $ rscript_envs    : NULL
[01:28:04.956]  $ rscript_libs    : chr [1:2] "D:/temp/RtmpCIb4qz/RLIBS_32fc52ae7b47" "D:/RCompile/recent/R/library"
[01:28:04.956]  $ rscript_startup : NULL
[01:28:04.956]  $ rscript_sh      : chr "cmd"
[01:28:04.956]  $ default_packages: chr [1:6] "datasets" "utils" "grDevices" "graphics" ...
[01:28:04.956]  $ methods         : logi TRUE
[01:28:04.956]  $ socketOptions   : chr "no-delay"
[01:28:04.956]  $ useXDR          : logi FALSE
[01:28:04.956]  $ outfile         : chr "/dev/null"
[01:28:04.956]  $ renice          : int NA
[01:28:04.956]  $ rshcmd          : NULL
[01:28:04.956]  $ user            : chr(0) 
[01:28:04.956]  $ revtunnel       : logi FALSE
[01:28:04.956]  $ rshlogfile      : NULL
[01:28:04.956]  $ rshopts         : chr(0) 
[01:28:04.956]  $ rank            : int 1
[01:28:04.956]  $ manual          : logi FALSE
[01:28:04.956]  $ dryrun          : logi FALSE
[01:28:04.956]  $ quiet           : logi FALSE
[01:28:04.956]  $ setup_strategy  : chr "parallel"
[01:28:04.956]  $ local_cmd       : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "| __truncated__
[01:28:04.956]  $ pidfile         : chr "D:/temp/RtmpaqTpKX/worker.rank=1.parallelly.parent=13884.363c21c87372.pid"
[01:28:04.956]  $ rshcmd_label    : NULL
[01:28:04.956]  $ rsh_call        : NULL
[01:28:04.956]  $ cmd             : chr "\"D:/RCompile/recent/R/bin/x64/Rscript\" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "| __truncated__
[01:28:04.956]  $ localMachine    : logi TRUE
[01:28:04.956]  $ make_fcn        :function (worker = getOption2("parallelly.localhost.hostname", "localhost"), 
[01:28:04.956]     master = NULL, port, connectTimeout = getOption2("parallelly.makeNodePSOCK.connectTimeout", 
[01:28:04.956]         2 * 60), timeout = getOption2("parallelly.makeNodePSOCK.timeout", 
[01:28:04.956]         30 * 24 * 60 * 60), rscript = NULL, homogeneous = NULL, rscript_args = NULL, 
[01:28:04.956]     rscript_envs = NULL, rscript_libs = NULL, rscript_startup = NULL, rscript_sh = c("auto", 
[01:28:04.956]         "cmd", "sh"), default_packages = c("datasets", "utils", "grDevices", 
[01:28:04.956]         "graphics", "stats", if (methods) "methods"), methods = TRUE, socketOptions = getOption2("parallelly.makeNodePSOCK.socketOptions", 
[01:28:04.956]         "no-delay"), useXDR = getOption2("parallelly.makeNodePSOCK.useXDR", 
[01:28:04.956]         FALSE), outfile = "/dev/null", renice = NA_integer_, rshcmd = getOption2("parallelly.makeNodePSOCK.rshcmd", 
[01:28:04.956]         NULL), user = NULL, revtunnel = NA, rshlogfile = NULL, rshopts = getOption2("parallelly.makeNodePSOCK.rshopts", 
[01:28:04.956]         NULL), rank = 1L, manual = FALSE, dryrun = FALSE, quiet = FALSE, 
[01:28:04.956]     setup_strategy = getOption2("parallelly.makeNodePSOCK.setup_strategy", 
[01:28:04.956]         "parallel"), action = c("launch", "options"), verbose = FALSE)  
[01:28:04.956]  $ arguments       :List of 28
[01:28:04.956]   ..$ worker          : chr "localhost"
[01:28:04.956]   ..$ master          : NULL
[01:28:04.956]   ..$ port            : int 22671
[01:28:04.956]   ..$ connectTimeout  : num 120
[01:28:04.956]   ..$ timeout         : num 120
[01:28:04.956]   ..$ rscript         : NULL
[01:28:04.956]   ..$ homogeneous     : NULL
[01:28:04.956]   ..$ rscript_args    : NULL
[01:28:04.956]   ..$ rscript_envs    : NULL
[01:28:04.956]   ..$ rscript_libs    : chr [1:2] "D:/temp/RtmpCIb4qz/RLIBS_32fc52ae7b47" "D:/RCompile/recent/R/library"
[01:28:04.956]   ..$ rscript_startup : NULL
[01:28:04.956]   ..$ rscript_sh      : chr [1:3] "auto" "cmd" "sh"
[01:28:04.956]   ..$ default_packages: chr [1:6] "datasets" "utils" "grDevices" "graphics" ...
[01:28:04.956]   ..$ methods         : logi TRUE
[01:28:04.956]   ..$ socketOptions   : chr "no-delay"
[01:28:04.956]   ..$ useXDR          : logi FALSE
[01:28:04.956]   ..$ outfile         : chr "/dev/null"
[01:28:04.956]   ..$ renice          : int NA
[01:28:04.956]   ..$ rshcmd          : NULL
[01:28:04.956]   ..$ user            : NULL
[01:28:04.956]   ..$ revtunnel       : logi NA
[01:28:04.956]   ..$ rshlogfile      : NULL
[01:28:04.956]   ..$ rshopts         : NULL
[01:28:04.956]   ..$ rank            : int 1
[01:28:04.956]   ..$ manual          : logi FALSE
[01:28:04.956]   ..$ dryrun          : logi FALSE
[01:28:04.956]   ..$ quiet           : logi FALSE
[01:28:04.956]   ..$ setup_strategy  : chr "parallel"
[01:28:04.956]  - attr(*, "class")= chr [1:2] "makeNodePSOCKOptions" "makeNodeOptions"
[01:28:04.983] [local output] System call to launch all workers:
[01:28:04.983] [local output] "D:/RCompile/recent/R/bin/x64/Rscript" --default-packages=datasets,utils,grDevices,graphics,stats,methods -e "#label=globals,subassignment.R:13884:CRANWIN3:CRAN" -e "try(suppressWarnings(cat(Sys.getpid(),file=\"D:/temp/RtmpaqTpKX/worker.rank=1.parallelly.parent=13884.363c21c87372.pid\")), silent = TRUE)" -e "options(socketOptions = \"no-delay\")" -e ".libPaths(c(\"D:/temp/RtmpCIb4qz/RLIBS_32fc52ae7b47\",\"D:/RCompile/recent/R/library\"))" -e "workRSOCK <- tryCatch(parallel:::.workRSOCK, error=function(e) parallel:::.slaveRSOCK); workRSOCK()" MASTER=localhost PORT=22671 OUT=/dev/null TIMEOUT=120 XDR=FALSE SETUPTIMEOUT=120 SETUPSTRATEGY=parallel
[01:28:04.983] [local output] Starting PSOCK main server
[01:28:04.989] [local output] Workers launched
[01:28:04.990] [local output] Waiting for workers to connect back
[01:28:04.990]  - [local output] 0 workers out of 2 ready
[01:28:05.164]  - [local output] 0 workers out of 2 ready
[01:28:05.165]  - [local output] 1 workers out of 2 ready
[01:28:05.167]  - [local output] 1 workers out of 2 ready
[01:28:05.168]  - [local output] 2 workers out of 2 ready
[01:28:05.168] [local output] Launching of workers completed
[01:28:05.168] [local output] Collecting session information from workers
[01:28:05.169] [local output]  - Worker #1 of 2
[01:28:05.170] [local output]  - Worker #2 of 2
[01:28:05.170] [local output] makeClusterPSOCK() ... done
[01:28:05.183] Packages needed by the future expression (n = 0): <none>
[01:28:05.184] Packages needed by future strategies (n = 0): <none>
[01:28:05.184] {
[01:28:05.184]     {
[01:28:05.184]         {
[01:28:05.184]             ...future.startTime <- base::Sys.time()
[01:28:05.184]             {
[01:28:05.184]                 {
[01:28:05.184]                   {
[01:28:05.184]                     {
[01:28:05.184]                       base::local({
[01:28:05.184]                         has_future <- base::requireNamespace("future", 
[01:28:05.184]                           quietly = TRUE)
[01:28:05.184]                         if (has_future) {
[01:28:05.184]                           ns <- base::getNamespace("future")
[01:28:05.184]                           version <- ns[[".package"]][["version"]]
[01:28:05.184]                           if (is.null(version)) 
[01:28:05.184]                             version <- utils::packageVersion("future")
[01:28:05.184]                         }
[01:28:05.184]                         else {
[01:28:05.184]                           version <- NULL
[01:28:05.184]                         }
[01:28:05.184]                         if (!has_future || version < "1.8.0") {
[01:28:05.184]                           info <- base::c(r_version = base::gsub("R version ", 
[01:28:05.184]                             "", base::R.version$version.string), 
[01:28:05.184]                             platform = base::sprintf("%s (%s-bit)", 
[01:28:05.184]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:05.184]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:05.184]                               "release", "version")], collapse = " "), 
[01:28:05.184]                             hostname = base::Sys.info()[["nodename"]])
[01:28:05.184]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:28:05.184]                             info)
[01:28:05.184]                           info <- base::paste(info, collapse = "; ")
[01:28:05.184]                           if (!has_future) {
[01:28:05.184]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:05.184]                               info)
[01:28:05.184]                           }
[01:28:05.184]                           else {
[01:28:05.184]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:05.184]                               info, version)
[01:28:05.184]                           }
[01:28:05.184]                           base::stop(msg)
[01:28:05.184]                         }
[01:28:05.184]                       })
[01:28:05.184]                     }
[01:28:05.184]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:28:05.184]                     base::options(mc.cores = 1L)
[01:28:05.184]                   }
[01:28:05.184]                   options(future.plan = NULL)
[01:28:05.184]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:05.184]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:05.184]                 }
[01:28:05.184]                 ...future.workdir <- getwd()
[01:28:05.184]             }
[01:28:05.184]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:05.184]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:05.184]         }
[01:28:05.184]         base::options(future.startup.script = FALSE, future.globals.onMissing = "error", 
[01:28:05.184]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:28:05.184]             future.globals.onMissing = "error", future.globals.onReference = NULL, 
[01:28:05.184]             future.globals.resolve = TRUE, future.resolve.recursive = NULL, 
[01:28:05.184]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:05.184]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:05.184]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:05.184]             base::names(...future.oldOptions))
[01:28:05.184]     }
[01:28:05.184]     if (FALSE) {
[01:28:05.184]     }
[01:28:05.184]     else {
[01:28:05.184]         if (TRUE) {
[01:28:05.184]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:05.184]                 open = "w")
[01:28:05.184]         }
[01:28:05.184]         else {
[01:28:05.184]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:05.184]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:05.184]         }
[01:28:05.184]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:05.184]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:05.184]             base::sink(type = "output", split = FALSE)
[01:28:05.184]             base::close(...future.stdout)
[01:28:05.184]         }, add = TRUE)
[01:28:05.184]     }
[01:28:05.184]     ...future.frame <- base::sys.nframe()
[01:28:05.184]     ...future.conditions <- base::list()
[01:28:05.184]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:05.184]     if (FALSE) {
[01:28:05.184]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:05.184]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:05.184]     }
[01:28:05.184]     ...future.result <- base::tryCatch({
[01:28:05.184]         base::withCallingHandlers({
[01:28:05.184]             ...future.value <- base::withVisible(base::local({
[01:28:05.184]                 ...future.makeSendCondition <- base::local({
[01:28:05.184]                   sendCondition <- NULL
[01:28:05.184]                   function(frame = 1L) {
[01:28:05.184]                     if (is.function(sendCondition)) 
[01:28:05.184]                       return(sendCondition)
[01:28:05.184]                     ns <- getNamespace("parallel")
[01:28:05.184]                     if (exists("sendData", mode = "function", 
[01:28:05.184]                       envir = ns)) {
[01:28:05.184]                       parallel_sendData <- get("sendData", mode = "function", 
[01:28:05.184]                         envir = ns)
[01:28:05.184]                       envir <- sys.frame(frame)
[01:28:05.184]                       master <- NULL
[01:28:05.184]                       while (!identical(envir, .GlobalEnv) && 
[01:28:05.184]                         !identical(envir, emptyenv())) {
[01:28:05.184]                         if (exists("master", mode = "list", envir = envir, 
[01:28:05.184]                           inherits = FALSE)) {
[01:28:05.184]                           master <- get("master", mode = "list", 
[01:28:05.184]                             envir = envir, inherits = FALSE)
[01:28:05.184]                           if (inherits(master, c("SOCKnode", 
[01:28:05.184]                             "SOCK0node"))) {
[01:28:05.184]                             sendCondition <<- function(cond) {
[01:28:05.184]                               data <- list(type = "VALUE", value = cond, 
[01:28:05.184]                                 success = TRUE)
[01:28:05.184]                               parallel_sendData(master, data)
[01:28:05.184]                             }
[01:28:05.184]                             return(sendCondition)
[01:28:05.184]                           }
[01:28:05.184]                         }
[01:28:05.184]                         frame <- frame + 1L
[01:28:05.184]                         envir <- sys.frame(frame)
[01:28:05.184]                       }
[01:28:05.184]                     }
[01:28:05.184]                     sendCondition <<- function(cond) NULL
[01:28:05.184]                   }
[01:28:05.184]                 })
[01:28:05.184]                 withCallingHandlers({
[01:28:05.184]                   NA
[01:28:05.184]                 }, immediateCondition = function(cond) {
[01:28:05.184]                   sendCondition <- ...future.makeSendCondition()
[01:28:05.184]                   sendCondition(cond)
[01:28:05.184]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:05.184]                   {
[01:28:05.184]                     inherits <- base::inherits
[01:28:05.184]                     invokeRestart <- base::invokeRestart
[01:28:05.184]                     is.null <- base::is.null
[01:28:05.184]                     muffled <- FALSE
[01:28:05.184]                     if (inherits(cond, "message")) {
[01:28:05.184]                       muffled <- grepl(pattern, "muffleMessage")
[01:28:05.184]                       if (muffled) 
[01:28:05.184]                         invokeRestart("muffleMessage")
[01:28:05.184]                     }
[01:28:05.184]                     else if (inherits(cond, "warning")) {
[01:28:05.184]                       muffled <- grepl(pattern, "muffleWarning")
[01:28:05.184]                       if (muffled) 
[01:28:05.184]                         invokeRestart("muffleWarning")
[01:28:05.184]                     }
[01:28:05.184]                     else if (inherits(cond, "condition")) {
[01:28:05.184]                       if (!is.null(pattern)) {
[01:28:05.184]                         computeRestarts <- base::computeRestarts
[01:28:05.184]                         grepl <- base::grepl
[01:28:05.184]                         restarts <- computeRestarts(cond)
[01:28:05.184]                         for (restart in restarts) {
[01:28:05.184]                           name <- restart$name
[01:28:05.184]                           if (is.null(name)) 
[01:28:05.184]                             next
[01:28:05.184]                           if (!grepl(pattern, name)) 
[01:28:05.184]                             next
[01:28:05.184]                           invokeRestart(restart)
[01:28:05.184]                           muffled <- TRUE
[01:28:05.184]                           break
[01:28:05.184]                         }
[01:28:05.184]                       }
[01:28:05.184]                     }
[01:28:05.184]                     invisible(muffled)
[01:28:05.184]                   }
[01:28:05.184]                   muffleCondition(cond)
[01:28:05.184]                 })
[01:28:05.184]             }))
[01:28:05.184]             future::FutureResult(value = ...future.value$value, 
[01:28:05.184]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:05.184]                   ...future.rng), globalenv = if (FALSE) 
[01:28:05.184]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:05.184]                     ...future.globalenv.names))
[01:28:05.184]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:05.184]         }, condition = base::local({
[01:28:05.184]             c <- base::c
[01:28:05.184]             inherits <- base::inherits
[01:28:05.184]             invokeRestart <- base::invokeRestart
[01:28:05.184]             length <- base::length
[01:28:05.184]             list <- base::list
[01:28:05.184]             seq.int <- base::seq.int
[01:28:05.184]             signalCondition <- base::signalCondition
[01:28:05.184]             sys.calls <- base::sys.calls
[01:28:05.184]             `[[` <- base::`[[`
[01:28:05.184]             `+` <- base::`+`
[01:28:05.184]             `<<-` <- base::`<<-`
[01:28:05.184]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:05.184]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:05.184]                   3L)]
[01:28:05.184]             }
[01:28:05.184]             function(cond) {
[01:28:05.184]                 is_error <- inherits(cond, "error")
[01:28:05.184]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:05.184]                   NULL)
[01:28:05.184]                 if (is_error) {
[01:28:05.184]                   sessionInformation <- function() {
[01:28:05.184]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:05.184]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:05.184]                       search = base::search(), system = base::Sys.info())
[01:28:05.184]                   }
[01:28:05.184]                   ...future.conditions[[length(...future.conditions) + 
[01:28:05.184]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:05.184]                     cond$call), session = sessionInformation(), 
[01:28:05.184]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:05.184]                   signalCondition(cond)
[01:28:05.184]                 }
[01:28:05.184]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:05.184]                 "immediateCondition"))) {
[01:28:05.184]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:05.184]                   ...future.conditions[[length(...future.conditions) + 
[01:28:05.184]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:05.184]                   if (TRUE && !signal) {
[01:28:05.184]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:05.184]                     {
[01:28:05.184]                       inherits <- base::inherits
[01:28:05.184]                       invokeRestart <- base::invokeRestart
[01:28:05.184]                       is.null <- base::is.null
[01:28:05.184]                       muffled <- FALSE
[01:28:05.184]                       if (inherits(cond, "message")) {
[01:28:05.184]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:05.184]                         if (muffled) 
[01:28:05.184]                           invokeRestart("muffleMessage")
[01:28:05.184]                       }
[01:28:05.184]                       else if (inherits(cond, "warning")) {
[01:28:05.184]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:05.184]                         if (muffled) 
[01:28:05.184]                           invokeRestart("muffleWarning")
[01:28:05.184]                       }
[01:28:05.184]                       else if (inherits(cond, "condition")) {
[01:28:05.184]                         if (!is.null(pattern)) {
[01:28:05.184]                           computeRestarts <- base::computeRestarts
[01:28:05.184]                           grepl <- base::grepl
[01:28:05.184]                           restarts <- computeRestarts(cond)
[01:28:05.184]                           for (restart in restarts) {
[01:28:05.184]                             name <- restart$name
[01:28:05.184]                             if (is.null(name)) 
[01:28:05.184]                               next
[01:28:05.184]                             if (!grepl(pattern, name)) 
[01:28:05.184]                               next
[01:28:05.184]                             invokeRestart(restart)
[01:28:05.184]                             muffled <- TRUE
[01:28:05.184]                             break
[01:28:05.184]                           }
[01:28:05.184]                         }
[01:28:05.184]                       }
[01:28:05.184]                       invisible(muffled)
[01:28:05.184]                     }
[01:28:05.184]                     muffleCondition(cond, pattern = "^muffle")
[01:28:05.184]                   }
[01:28:05.184]                 }
[01:28:05.184]                 else {
[01:28:05.184]                   if (TRUE) {
[01:28:05.184]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:05.184]                     {
[01:28:05.184]                       inherits <- base::inherits
[01:28:05.184]                       invokeRestart <- base::invokeRestart
[01:28:05.184]                       is.null <- base::is.null
[01:28:05.184]                       muffled <- FALSE
[01:28:05.184]                       if (inherits(cond, "message")) {
[01:28:05.184]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:05.184]                         if (muffled) 
[01:28:05.184]                           invokeRestart("muffleMessage")
[01:28:05.184]                       }
[01:28:05.184]                       else if (inherits(cond, "warning")) {
[01:28:05.184]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:05.184]                         if (muffled) 
[01:28:05.184]                           invokeRestart("muffleWarning")
[01:28:05.184]                       }
[01:28:05.184]                       else if (inherits(cond, "condition")) {
[01:28:05.184]                         if (!is.null(pattern)) {
[01:28:05.184]                           computeRestarts <- base::computeRestarts
[01:28:05.184]                           grepl <- base::grepl
[01:28:05.184]                           restarts <- computeRestarts(cond)
[01:28:05.184]                           for (restart in restarts) {
[01:28:05.184]                             name <- restart$name
[01:28:05.184]                             if (is.null(name)) 
[01:28:05.184]                               next
[01:28:05.184]                             if (!grepl(pattern, name)) 
[01:28:05.184]                               next
[01:28:05.184]                             invokeRestart(restart)
[01:28:05.184]                             muffled <- TRUE
[01:28:05.184]                             break
[01:28:05.184]                           }
[01:28:05.184]                         }
[01:28:05.184]                       }
[01:28:05.184]                       invisible(muffled)
[01:28:05.184]                     }
[01:28:05.184]                     muffleCondition(cond, pattern = "^muffle")
[01:28:05.184]                   }
[01:28:05.184]                 }
[01:28:05.184]             }
[01:28:05.184]         }))
[01:28:05.184]     }, error = function(ex) {
[01:28:05.184]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:05.184]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:05.184]                 ...future.rng), started = ...future.startTime, 
[01:28:05.184]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:05.184]             version = "1.8"), class = "FutureResult")
[01:28:05.184]     }, finally = {
[01:28:05.184]         if (!identical(...future.workdir, getwd())) 
[01:28:05.184]             setwd(...future.workdir)
[01:28:05.184]         {
[01:28:05.184]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:05.184]                 ...future.oldOptions$nwarnings <- NULL
[01:28:05.184]             }
[01:28:05.184]             base::options(...future.oldOptions)
[01:28:05.184]             if (.Platform$OS.type == "windows") {
[01:28:05.184]                 old_names <- names(...future.oldEnvVars)
[01:28:05.184]                 envs <- base::Sys.getenv()
[01:28:05.184]                 names <- names(envs)
[01:28:05.184]                 common <- intersect(names, old_names)
[01:28:05.184]                 added <- setdiff(names, old_names)
[01:28:05.184]                 removed <- setdiff(old_names, names)
[01:28:05.184]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:05.184]                   envs[common]]
[01:28:05.184]                 NAMES <- toupper(changed)
[01:28:05.184]                 args <- list()
[01:28:05.184]                 for (kk in seq_along(NAMES)) {
[01:28:05.184]                   name <- changed[[kk]]
[01:28:05.184]                   NAME <- NAMES[[kk]]
[01:28:05.184]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:05.184]                     next
[01:28:05.184]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:05.184]                 }
[01:28:05.184]                 NAMES <- toupper(added)
[01:28:05.184]                 for (kk in seq_along(NAMES)) {
[01:28:05.184]                   name <- added[[kk]]
[01:28:05.184]                   NAME <- NAMES[[kk]]
[01:28:05.184]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:05.184]                     next
[01:28:05.184]                   args[[name]] <- ""
[01:28:05.184]                 }
[01:28:05.184]                 NAMES <- toupper(removed)
[01:28:05.184]                 for (kk in seq_along(NAMES)) {
[01:28:05.184]                   name <- removed[[kk]]
[01:28:05.184]                   NAME <- NAMES[[kk]]
[01:28:05.184]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:05.184]                     next
[01:28:05.184]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:05.184]                 }
[01:28:05.184]                 if (length(args) > 0) 
[01:28:05.184]                   base::do.call(base::Sys.setenv, args = args)
[01:28:05.184]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:05.184]             }
[01:28:05.184]             else {
[01:28:05.184]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:05.184]             }
[01:28:05.184]             {
[01:28:05.184]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:05.184]                   0L) {
[01:28:05.184]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:05.184]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:05.184]                   base::options(opts)
[01:28:05.184]                 }
[01:28:05.184]                 {
[01:28:05.184]                   {
[01:28:05.184]                     base::options(mc.cores = ...future.mc.cores.old)
[01:28:05.184]                     NULL
[01:28:05.184]                   }
[01:28:05.184]                   options(future.plan = NULL)
[01:28:05.184]                   if (is.na(NA_character_)) 
[01:28:05.184]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:05.184]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:05.184]                   future::plan(list(function (..., workers = availableCores(), 
[01:28:05.184]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:28:05.184]                     envir = parent.frame()) 
[01:28:05.184]                   {
[01:28:05.184]                     if (is.function(workers)) 
[01:28:05.184]                       workers <- workers()
[01:28:05.184]                     workers <- structure(as.integer(workers), 
[01:28:05.184]                       class = class(workers))
[01:28:05.184]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:28:05.184]                       workers >= 1)
[01:28:05.184]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:28:05.184]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:28:05.184]                     }
[01:28:05.184]                     future <- MultisessionFuture(..., workers = workers, 
[01:28:05.184]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:28:05.184]                       envir = envir)
[01:28:05.184]                     if (!future$lazy) 
[01:28:05.184]                       future <- run(future)
[01:28:05.184]                     invisible(future)
[01:28:05.184]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:05.184]                 }
[01:28:05.184]             }
[01:28:05.184]         }
[01:28:05.184]     })
[01:28:05.184]     if (TRUE) {
[01:28:05.184]         base::sink(type = "output", split = FALSE)
[01:28:05.184]         if (TRUE) {
[01:28:05.184]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:05.184]         }
[01:28:05.184]         else {
[01:28:05.184]             ...future.result["stdout"] <- base::list(NULL)
[01:28:05.184]         }
[01:28:05.184]         base::close(...future.stdout)
[01:28:05.184]         ...future.stdout <- NULL
[01:28:05.184]     }
[01:28:05.184]     ...future.result$conditions <- ...future.conditions
[01:28:05.184]     ...future.result$finished <- base::Sys.time()
[01:28:05.184]     ...future.result
[01:28:05.184] }
[01:28:05.265] MultisessionFuture started
[01:28:05.265] result() for ClusterFuture ...
[01:28:05.266] receiveMessageFromWorker() for ClusterFuture ...
[01:28:05.266] - Validating connection of MultisessionFuture
[01:28:05.323] - received message: FutureResult
[01:28:05.323] - Received FutureResult
[01:28:05.327] - Erased future from FutureRegistry
[01:28:05.327] result() for ClusterFuture ...
[01:28:05.327] - result already collected: FutureResult
[01:28:05.328] result() for ClusterFuture ... done
[01:28:05.328] receiveMessageFromWorker() for ClusterFuture ... done
[01:28:05.328] result() for ClusterFuture ... done
[01:28:05.328] result() for ClusterFuture ...
[01:28:05.328] - result already collected: FutureResult
[01:28:05.329] result() for ClusterFuture ... done
[01:28:05.329] plan(): plan_init() of 'multisession', 'cluster', 'multiprocess', 'future', 'function' ... DONE
[01:28:05.332] plan(): nbrOfWorkers() = 2
Warning: 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'
[01:28:05.332] getGlobalsAndPackages() ...
Warning: 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'
[01:28:05.332] Searching for globals...
[01:28:05.336] - globals found: [5] '{', 'x', '<-', '$', '$<-'
[01:28:05.336] Searching for globals ... DONE
[01:28:05.336] Resolving globals: TRUE
[01:28:05.336] Resolving any globals that are futures ...
[01:28:05.336] - globals: [5] '{', 'x', '<-', '$', '$<-'
[01:28:05.337] Resolving any globals that are futures ... DONE
[01:28:05.337] Resolving futures part of globals (recursively) ...
[01:28:05.338] resolve() on list ...
[01:28:05.338]  recursive: 99
[01:28:05.338]  length: 1
[01:28:05.339]  elements: 'x'
[01:28:05.339]  length: 0 (resolved future 1)
[01:28:05.339] resolve() on list ... DONE
[01:28:05.339] - globals: [1] 'x'
[01:28:05.340] Resolving futures part of globals (recursively) ... DONE
[01:28:05.340] The total size of the 1 globals is 0 bytes (0 bytes)
[01:28:05.341] The total size of the 1 globals exported for future expression ('{; x$a <- 1; x; }') is 0 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There is one global: 'x' (0 bytes of class 'list')
[01:28:05.341] - globals: [1] 'x'
[01:28:05.341] 
[01:28:05.341] getGlobalsAndPackages() ... DONE
[01:28:05.342] run() for 'Future' ...
[01:28:05.342] - state: 'created'
[01:28:05.342] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:28:05.357] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:28:05.358] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:28:05.358]   - Field: 'node'
[01:28:05.358]   - Field: 'label'
[01:28:05.358]   - Field: 'local'
[01:28:05.358]   - Field: 'owner'
[01:28:05.359]   - Field: 'envir'
[01:28:05.359]   - Field: 'workers'
[01:28:05.359]   - Field: 'packages'
[01:28:05.359]   - Field: 'gc'
[01:28:05.359]   - Field: 'conditions'
[01:28:05.360]   - Field: 'persistent'
[01:28:05.360]   - Field: 'expr'
[01:28:05.360]   - Field: 'uuid'
[01:28:05.360]   - Field: 'seed'
[01:28:05.360]   - Field: 'version'
[01:28:05.361]   - Field: 'result'
[01:28:05.361]   - Field: 'asynchronous'
[01:28:05.361]   - Field: 'calls'
[01:28:05.361]   - Field: 'globals'
[01:28:05.361]   - Field: 'stdout'
[01:28:05.362]   - Field: 'earlySignal'
[01:28:05.362]   - Field: 'lazy'
[01:28:05.362]   - Field: 'state'
[01:28:05.362] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:28:05.362] - Launch lazy future ...
[01:28:05.363] Packages needed by the future expression (n = 0): <none>
[01:28:05.363] Packages needed by future strategies (n = 0): <none>
[01:28:05.364] {
[01:28:05.364]     {
[01:28:05.364]         {
[01:28:05.364]             ...future.startTime <- base::Sys.time()
[01:28:05.364]             {
[01:28:05.364]                 {
[01:28:05.364]                   {
[01:28:05.364]                     {
[01:28:05.364]                       base::local({
[01:28:05.364]                         has_future <- base::requireNamespace("future", 
[01:28:05.364]                           quietly = TRUE)
[01:28:05.364]                         if (has_future) {
[01:28:05.364]                           ns <- base::getNamespace("future")
[01:28:05.364]                           version <- ns[[".package"]][["version"]]
[01:28:05.364]                           if (is.null(version)) 
[01:28:05.364]                             version <- utils::packageVersion("future")
[01:28:05.364]                         }
[01:28:05.364]                         else {
[01:28:05.364]                           version <- NULL
[01:28:05.364]                         }
[01:28:05.364]                         if (!has_future || version < "1.8.0") {
[01:28:05.364]                           info <- base::c(r_version = base::gsub("R version ", 
[01:28:05.364]                             "", base::R.version$version.string), 
[01:28:05.364]                             platform = base::sprintf("%s (%s-bit)", 
[01:28:05.364]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:05.364]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:05.364]                               "release", "version")], collapse = " "), 
[01:28:05.364]                             hostname = base::Sys.info()[["nodename"]])
[01:28:05.364]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:28:05.364]                             info)
[01:28:05.364]                           info <- base::paste(info, collapse = "; ")
[01:28:05.364]                           if (!has_future) {
[01:28:05.364]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:05.364]                               info)
[01:28:05.364]                           }
[01:28:05.364]                           else {
[01:28:05.364]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:05.364]                               info, version)
[01:28:05.364]                           }
[01:28:05.364]                           base::stop(msg)
[01:28:05.364]                         }
[01:28:05.364]                       })
[01:28:05.364]                     }
[01:28:05.364]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:28:05.364]                     base::options(mc.cores = 1L)
[01:28:05.364]                   }
[01:28:05.364]                   options(future.plan = NULL)
[01:28:05.364]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:05.364]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:05.364]                 }
[01:28:05.364]                 ...future.workdir <- getwd()
[01:28:05.364]             }
[01:28:05.364]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:05.364]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:05.364]         }
[01:28:05.364]         base::options(future.startup.script = FALSE, future.globals.onMissing = "error", 
[01:28:05.364]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:28:05.364]             future.globals.onMissing = "error", future.globals.onReference = NULL, 
[01:28:05.364]             future.globals.resolve = TRUE, future.resolve.recursive = NULL, 
[01:28:05.364]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:05.364]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:05.364]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:05.364]             base::names(...future.oldOptions))
[01:28:05.364]     }
[01:28:05.364]     if (FALSE) {
[01:28:05.364]     }
[01:28:05.364]     else {
[01:28:05.364]         if (TRUE) {
[01:28:05.364]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:05.364]                 open = "w")
[01:28:05.364]         }
[01:28:05.364]         else {
[01:28:05.364]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:05.364]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:05.364]         }
[01:28:05.364]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:05.364]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:05.364]             base::sink(type = "output", split = FALSE)
[01:28:05.364]             base::close(...future.stdout)
[01:28:05.364]         }, add = TRUE)
[01:28:05.364]     }
[01:28:05.364]     ...future.frame <- base::sys.nframe()
[01:28:05.364]     ...future.conditions <- base::list()
[01:28:05.364]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:05.364]     if (FALSE) {
[01:28:05.364]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:05.364]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:05.364]     }
[01:28:05.364]     ...future.result <- base::tryCatch({
[01:28:05.364]         base::withCallingHandlers({
[01:28:05.364]             ...future.value <- base::withVisible(base::local({
[01:28:05.364]                 ...future.makeSendCondition <- base::local({
[01:28:05.364]                   sendCondition <- NULL
[01:28:05.364]                   function(frame = 1L) {
[01:28:05.364]                     if (is.function(sendCondition)) 
[01:28:05.364]                       return(sendCondition)
[01:28:05.364]                     ns <- getNamespace("parallel")
[01:28:05.364]                     if (exists("sendData", mode = "function", 
[01:28:05.364]                       envir = ns)) {
[01:28:05.364]                       parallel_sendData <- get("sendData", mode = "function", 
[01:28:05.364]                         envir = ns)
[01:28:05.364]                       envir <- sys.frame(frame)
[01:28:05.364]                       master <- NULL
[01:28:05.364]                       while (!identical(envir, .GlobalEnv) && 
[01:28:05.364]                         !identical(envir, emptyenv())) {
[01:28:05.364]                         if (exists("master", mode = "list", envir = envir, 
[01:28:05.364]                           inherits = FALSE)) {
[01:28:05.364]                           master <- get("master", mode = "list", 
[01:28:05.364]                             envir = envir, inherits = FALSE)
[01:28:05.364]                           if (inherits(master, c("SOCKnode", 
[01:28:05.364]                             "SOCK0node"))) {
[01:28:05.364]                             sendCondition <<- function(cond) {
[01:28:05.364]                               data <- list(type = "VALUE", value = cond, 
[01:28:05.364]                                 success = TRUE)
[01:28:05.364]                               parallel_sendData(master, data)
[01:28:05.364]                             }
[01:28:05.364]                             return(sendCondition)
[01:28:05.364]                           }
[01:28:05.364]                         }
[01:28:05.364]                         frame <- frame + 1L
[01:28:05.364]                         envir <- sys.frame(frame)
[01:28:05.364]                       }
[01:28:05.364]                     }
[01:28:05.364]                     sendCondition <<- function(cond) NULL
[01:28:05.364]                   }
[01:28:05.364]                 })
[01:28:05.364]                 withCallingHandlers({
[01:28:05.364]                   {
[01:28:05.364]                     x$a <- 1
[01:28:05.364]                     x
[01:28:05.364]                   }
[01:28:05.364]                 }, immediateCondition = function(cond) {
[01:28:05.364]                   sendCondition <- ...future.makeSendCondition()
[01:28:05.364]                   sendCondition(cond)
[01:28:05.364]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:05.364]                   {
[01:28:05.364]                     inherits <- base::inherits
[01:28:05.364]                     invokeRestart <- base::invokeRestart
[01:28:05.364]                     is.null <- base::is.null
[01:28:05.364]                     muffled <- FALSE
[01:28:05.364]                     if (inherits(cond, "message")) {
[01:28:05.364]                       muffled <- grepl(pattern, "muffleMessage")
[01:28:05.364]                       if (muffled) 
[01:28:05.364]                         invokeRestart("muffleMessage")
[01:28:05.364]                     }
[01:28:05.364]                     else if (inherits(cond, "warning")) {
[01:28:05.364]                       muffled <- grepl(pattern, "muffleWarning")
[01:28:05.364]                       if (muffled) 
[01:28:05.364]                         invokeRestart("muffleWarning")
[01:28:05.364]                     }
[01:28:05.364]                     else if (inherits(cond, "condition")) {
[01:28:05.364]                       if (!is.null(pattern)) {
[01:28:05.364]                         computeRestarts <- base::computeRestarts
[01:28:05.364]                         grepl <- base::grepl
[01:28:05.364]                         restarts <- computeRestarts(cond)
[01:28:05.364]                         for (restart in restarts) {
[01:28:05.364]                           name <- restart$name
[01:28:05.364]                           if (is.null(name)) 
[01:28:05.364]                             next
[01:28:05.364]                           if (!grepl(pattern, name)) 
[01:28:05.364]                             next
[01:28:05.364]                           invokeRestart(restart)
[01:28:05.364]                           muffled <- TRUE
[01:28:05.364]                           break
[01:28:05.364]                         }
[01:28:05.364]                       }
[01:28:05.364]                     }
[01:28:05.364]                     invisible(muffled)
[01:28:05.364]                   }
[01:28:05.364]                   muffleCondition(cond)
[01:28:05.364]                 })
[01:28:05.364]             }))
[01:28:05.364]             future::FutureResult(value = ...future.value$value, 
[01:28:05.364]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:05.364]                   ...future.rng), globalenv = if (FALSE) 
[01:28:05.364]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:05.364]                     ...future.globalenv.names))
[01:28:05.364]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:05.364]         }, condition = base::local({
[01:28:05.364]             c <- base::c
[01:28:05.364]             inherits <- base::inherits
[01:28:05.364]             invokeRestart <- base::invokeRestart
[01:28:05.364]             length <- base::length
[01:28:05.364]             list <- base::list
[01:28:05.364]             seq.int <- base::seq.int
[01:28:05.364]             signalCondition <- base::signalCondition
[01:28:05.364]             sys.calls <- base::sys.calls
[01:28:05.364]             `[[` <- base::`[[`
[01:28:05.364]             `+` <- base::`+`
[01:28:05.364]             `<<-` <- base::`<<-`
[01:28:05.364]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:05.364]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:05.364]                   3L)]
[01:28:05.364]             }
[01:28:05.364]             function(cond) {
[01:28:05.364]                 is_error <- inherits(cond, "error")
[01:28:05.364]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:05.364]                   NULL)
[01:28:05.364]                 if (is_error) {
[01:28:05.364]                   sessionInformation <- function() {
[01:28:05.364]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:05.364]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:05.364]                       search = base::search(), system = base::Sys.info())
[01:28:05.364]                   }
[01:28:05.364]                   ...future.conditions[[length(...future.conditions) + 
[01:28:05.364]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:05.364]                     cond$call), session = sessionInformation(), 
[01:28:05.364]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:05.364]                   signalCondition(cond)
[01:28:05.364]                 }
[01:28:05.364]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:05.364]                 "immediateCondition"))) {
[01:28:05.364]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:05.364]                   ...future.conditions[[length(...future.conditions) + 
[01:28:05.364]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:05.364]                   if (TRUE && !signal) {
[01:28:05.364]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:05.364]                     {
[01:28:05.364]                       inherits <- base::inherits
[01:28:05.364]                       invokeRestart <- base::invokeRestart
[01:28:05.364]                       is.null <- base::is.null
[01:28:05.364]                       muffled <- FALSE
[01:28:05.364]                       if (inherits(cond, "message")) {
[01:28:05.364]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:05.364]                         if (muffled) 
[01:28:05.364]                           invokeRestart("muffleMessage")
[01:28:05.364]                       }
[01:28:05.364]                       else if (inherits(cond, "warning")) {
[01:28:05.364]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:05.364]                         if (muffled) 
[01:28:05.364]                           invokeRestart("muffleWarning")
[01:28:05.364]                       }
[01:28:05.364]                       else if (inherits(cond, "condition")) {
[01:28:05.364]                         if (!is.null(pattern)) {
[01:28:05.364]                           computeRestarts <- base::computeRestarts
[01:28:05.364]                           grepl <- base::grepl
[01:28:05.364]                           restarts <- computeRestarts(cond)
[01:28:05.364]                           for (restart in restarts) {
[01:28:05.364]                             name <- restart$name
[01:28:05.364]                             if (is.null(name)) 
[01:28:05.364]                               next
[01:28:05.364]                             if (!grepl(pattern, name)) 
[01:28:05.364]                               next
[01:28:05.364]                             invokeRestart(restart)
[01:28:05.364]                             muffled <- TRUE
[01:28:05.364]                             break
[01:28:05.364]                           }
[01:28:05.364]                         }
[01:28:05.364]                       }
[01:28:05.364]                       invisible(muffled)
[01:28:05.364]                     }
[01:28:05.364]                     muffleCondition(cond, pattern = "^muffle")
[01:28:05.364]                   }
[01:28:05.364]                 }
[01:28:05.364]                 else {
[01:28:05.364]                   if (TRUE) {
[01:28:05.364]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:05.364]                     {
[01:28:05.364]                       inherits <- base::inherits
[01:28:05.364]                       invokeRestart <- base::invokeRestart
[01:28:05.364]                       is.null <- base::is.null
[01:28:05.364]                       muffled <- FALSE
[01:28:05.364]                       if (inherits(cond, "message")) {
[01:28:05.364]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:05.364]                         if (muffled) 
[01:28:05.364]                           invokeRestart("muffleMessage")
[01:28:05.364]                       }
[01:28:05.364]                       else if (inherits(cond, "warning")) {
[01:28:05.364]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:05.364]                         if (muffled) 
[01:28:05.364]                           invokeRestart("muffleWarning")
[01:28:05.364]                       }
[01:28:05.364]                       else if (inherits(cond, "condition")) {
[01:28:05.364]                         if (!is.null(pattern)) {
[01:28:05.364]                           computeRestarts <- base::computeRestarts
[01:28:05.364]                           grepl <- base::grepl
[01:28:05.364]                           restarts <- computeRestarts(cond)
[01:28:05.364]                           for (restart in restarts) {
[01:28:05.364]                             name <- restart$name
[01:28:05.364]                             if (is.null(name)) 
[01:28:05.364]                               next
[01:28:05.364]                             if (!grepl(pattern, name)) 
[01:28:05.364]                               next
[01:28:05.364]                             invokeRestart(restart)
[01:28:05.364]                             muffled <- TRUE
[01:28:05.364]                             break
[01:28:05.364]                           }
[01:28:05.364]                         }
[01:28:05.364]                       }
[01:28:05.364]                       invisible(muffled)
[01:28:05.364]                     }
[01:28:05.364]                     muffleCondition(cond, pattern = "^muffle")
[01:28:05.364]                   }
[01:28:05.364]                 }
[01:28:05.364]             }
[01:28:05.364]         }))
[01:28:05.364]     }, error = function(ex) {
[01:28:05.364]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:05.364]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:05.364]                 ...future.rng), started = ...future.startTime, 
[01:28:05.364]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:05.364]             version = "1.8"), class = "FutureResult")
[01:28:05.364]     }, finally = {
[01:28:05.364]         if (!identical(...future.workdir, getwd())) 
[01:28:05.364]             setwd(...future.workdir)
[01:28:05.364]         {
[01:28:05.364]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:05.364]                 ...future.oldOptions$nwarnings <- NULL
[01:28:05.364]             }
[01:28:05.364]             base::options(...future.oldOptions)
[01:28:05.364]             if (.Platform$OS.type == "windows") {
[01:28:05.364]                 old_names <- names(...future.oldEnvVars)
[01:28:05.364]                 envs <- base::Sys.getenv()
[01:28:05.364]                 names <- names(envs)
[01:28:05.364]                 common <- intersect(names, old_names)
[01:28:05.364]                 added <- setdiff(names, old_names)
[01:28:05.364]                 removed <- setdiff(old_names, names)
[01:28:05.364]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:05.364]                   envs[common]]
[01:28:05.364]                 NAMES <- toupper(changed)
[01:28:05.364]                 args <- list()
[01:28:05.364]                 for (kk in seq_along(NAMES)) {
[01:28:05.364]                   name <- changed[[kk]]
[01:28:05.364]                   NAME <- NAMES[[kk]]
[01:28:05.364]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:05.364]                     next
[01:28:05.364]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:05.364]                 }
[01:28:05.364]                 NAMES <- toupper(added)
[01:28:05.364]                 for (kk in seq_along(NAMES)) {
[01:28:05.364]                   name <- added[[kk]]
[01:28:05.364]                   NAME <- NAMES[[kk]]
[01:28:05.364]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:05.364]                     next
[01:28:05.364]                   args[[name]] <- ""
[01:28:05.364]                 }
[01:28:05.364]                 NAMES <- toupper(removed)
[01:28:05.364]                 for (kk in seq_along(NAMES)) {
[01:28:05.364]                   name <- removed[[kk]]
[01:28:05.364]                   NAME <- NAMES[[kk]]
[01:28:05.364]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:05.364]                     next
[01:28:05.364]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:05.364]                 }
[01:28:05.364]                 if (length(args) > 0) 
[01:28:05.364]                   base::do.call(base::Sys.setenv, args = args)
[01:28:05.364]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:05.364]             }
[01:28:05.364]             else {
[01:28:05.364]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:05.364]             }
[01:28:05.364]             {
[01:28:05.364]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:05.364]                   0L) {
[01:28:05.364]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:05.364]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:05.364]                   base::options(opts)
[01:28:05.364]                 }
[01:28:05.364]                 {
[01:28:05.364]                   {
[01:28:05.364]                     base::options(mc.cores = ...future.mc.cores.old)
[01:28:05.364]                     NULL
[01:28:05.364]                   }
[01:28:05.364]                   options(future.plan = NULL)
[01:28:05.364]                   if (is.na(NA_character_)) 
[01:28:05.364]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:05.364]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:05.364]                   future::plan(list(function (..., workers = availableCores(), 
[01:28:05.364]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:28:05.364]                     envir = parent.frame()) 
[01:28:05.364]                   {
[01:28:05.364]                     if (is.function(workers)) 
[01:28:05.364]                       workers <- workers()
[01:28:05.364]                     workers <- structure(as.integer(workers), 
[01:28:05.364]                       class = class(workers))
[01:28:05.364]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:28:05.364]                       workers >= 1)
[01:28:05.364]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:28:05.364]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:28:05.364]                     }
[01:28:05.364]                     future <- MultisessionFuture(..., workers = workers, 
[01:28:05.364]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:28:05.364]                       envir = envir)
[01:28:05.364]                     if (!future$lazy) 
[01:28:05.364]                       future <- run(future)
[01:28:05.364]                     invisible(future)
[01:28:05.364]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:05.364]                 }
[01:28:05.364]             }
[01:28:05.364]         }
[01:28:05.364]     })
[01:28:05.364]     if (TRUE) {
[01:28:05.364]         base::sink(type = "output", split = FALSE)
[01:28:05.364]         if (TRUE) {
[01:28:05.364]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:05.364]         }
[01:28:05.364]         else {
[01:28:05.364]             ...future.result["stdout"] <- base::list(NULL)
[01:28:05.364]         }
[01:28:05.364]         base::close(...future.stdout)
[01:28:05.364]         ...future.stdout <- NULL
[01:28:05.364]     }
[01:28:05.364]     ...future.result$conditions <- ...future.conditions
[01:28:05.364]     ...future.result$finished <- base::Sys.time()
[01:28:05.364]     ...future.result
[01:28:05.364] }
[01:28:05.370] Exporting 1 global objects (0 bytes) to cluster node #1 ...
[01:28:05.370] Exporting 'x' (0 bytes) to cluster node #1 ...
[01:28:05.371] Exporting 'x' (0 bytes) to cluster node #1 ... DONE
[01:28:05.371] Exporting 1 global objects (0 bytes) to cluster node #1 ... DONE
[01:28:05.372] MultisessionFuture started
[01:28:05.372] - Launch lazy future ... done
[01:28:05.373] run() for 'MultisessionFuture' ... done
[01:28:05.373] result() for ClusterFuture ...
[01:28:05.373] receiveMessageFromWorker() for ClusterFuture ...
[01:28:05.373] - Validating connection of MultisessionFuture
[01:28:05.389] - received message: FutureResult
[01:28:05.389] - Received FutureResult
[01:28:05.390] - Erased future from FutureRegistry
[01:28:05.390] result() for ClusterFuture ...
[01:28:05.390] - result already collected: FutureResult
[01:28:05.390] result() for ClusterFuture ... done
[01:28:05.390] receiveMessageFromWorker() for ClusterFuture ... done
[01:28:05.391] result() for ClusterFuture ... done
[01:28:05.391] result() for ClusterFuture ...
[01:28:05.391] - result already collected: FutureResult
[01:28:05.391] result() for ClusterFuture ... done
$a
[1] 1

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

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

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

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

$a
[1] 1

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

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

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

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

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

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

Warning: 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'
[01:28:05.979] getGlobalsAndPackages() ...
Warning: 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'
[01:28:05.980] Searching for globals...
[01:28:05.982] - globals found: [7] '{', 'x', '<-', '[', 'name', '[<-', 'list'
[01:28:05.983] Searching for globals ... DONE
[01:28:05.983] Resolving globals: TRUE
[01:28:05.983] Resolving any globals that are futures ...
[01:28:05.983] - globals: [7] '{', 'x', '<-', '[', 'name', '[<-', 'list'
[01:28:05.983] Resolving any globals that are futures ... DONE
[01:28:05.984] Resolving futures part of globals (recursively) ...
[01:28:05.984] resolve() on list ...
[01:28:05.984]  recursive: 99
[01:28:05.984]  length: 2
[01:28:05.985]  elements: 'x', 'name'
[01:28:05.985]  length: 1 (resolved future 1)
[01:28:05.985]  length: 0 (resolved future 2)
[01:28:05.985] resolve() on list ... DONE
[01:28:05.985] - globals: [2] 'x', 'name'
[01:28:05.985] Resolving futures part of globals (recursively) ... DONE
[01:28:05.986] The total size of the 2 globals is 112 bytes (112 bytes)
[01:28:05.986] The total size of the 2 globals exported for future expression ('{; x[name] <- list(1); x; }') is 112 bytes.. This exceeds the maximum allowed size of 500.00 MiB (option 'future.globals.maxSize'). There are two globals: 'name' (112 bytes of class 'character') and 'x' (0 bytes of class 'list')
[01:28:05.986] - globals: [2] 'x', 'name'
[01:28:05.987] 
[01:28:05.987] getGlobalsAndPackages() ... DONE
[01:28:05.987] run() for 'Future' ...
[01:28:05.987] - state: 'created'
[01:28:05.988] - Future backend: 'FutureStrategy', 'multisession', 'cluster', 'multiprocess', 'future', 'function'
[01:28:06.002] - Future class: 'MultisessionFuture', 'ClusterFuture', 'MultiprocessFuture', 'Future', 'environment'
[01:28:06.002] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ...
[01:28:06.002]   - Field: 'node'
[01:28:06.002]   - Field: 'label'
[01:28:06.002]   - Field: 'local'
[01:28:06.003]   - Field: 'owner'
[01:28:06.003]   - Field: 'envir'
[01:28:06.003]   - Field: 'workers'
[01:28:06.003]   - Field: 'packages'
[01:28:06.003]   - Field: 'gc'
[01:28:06.004]   - Field: 'conditions'
[01:28:06.004]   - Field: 'persistent'
[01:28:06.004]   - Field: 'expr'
[01:28:06.004]   - Field: 'uuid'
[01:28:06.004]   - Field: 'seed'
[01:28:06.004]   - Field: 'version'
[01:28:06.005]   - Field: 'result'
[01:28:06.005]   - Field: 'asynchronous'
[01:28:06.005]   - Field: 'calls'
[01:28:06.005]   - Field: 'globals'
[01:28:06.005]   - Field: 'stdout'
[01:28:06.005]   - Field: 'earlySignal'
[01:28:06.006]   - Field: 'lazy'
[01:28:06.006]   - Field: 'state'
[01:28:06.006] - Copy elements of temporary 'MultisessionFuture' to final 'Future' object ... done
[01:28:06.006] - Launch lazy future ...
[01:28:06.007] Packages needed by the future expression (n = 0): <none>
[01:28:06.007] Packages needed by future strategies (n = 0): <none>
[01:28:06.007] {
[01:28:06.007]     {
[01:28:06.007]         {
[01:28:06.007]             ...future.startTime <- base::Sys.time()
[01:28:06.007]             {
[01:28:06.007]                 {
[01:28:06.007]                   {
[01:28:06.007]                     {
[01:28:06.007]                       base::local({
[01:28:06.007]                         has_future <- base::requireNamespace("future", 
[01:28:06.007]                           quietly = TRUE)
[01:28:06.007]                         if (has_future) {
[01:28:06.007]                           ns <- base::getNamespace("future")
[01:28:06.007]                           version <- ns[[".package"]][["version"]]
[01:28:06.007]                           if (is.null(version)) 
[01:28:06.007]                             version <- utils::packageVersion("future")
[01:28:06.007]                         }
[01:28:06.007]                         else {
[01:28:06.007]                           version <- NULL
[01:28:06.007]                         }
[01:28:06.007]                         if (!has_future || version < "1.8.0") {
[01:28:06.007]                           info <- base::c(r_version = base::gsub("R version ", 
[01:28:06.007]                             "", base::R.version$version.string), 
[01:28:06.007]                             platform = base::sprintf("%s (%s-bit)", 
[01:28:06.007]                               base::R.version$platform, 8 * base::.Machine$sizeof.pointer), 
[01:28:06.007]                             os = base::paste(base::Sys.info()[base::c("sysname", 
[01:28:06.007]                               "release", "version")], collapse = " "), 
[01:28:06.007]                             hostname = base::Sys.info()[["nodename"]])
[01:28:06.007]                           info <- base::sprintf("%s: %s", base::names(info), 
[01:28:06.007]                             info)
[01:28:06.007]                           info <- base::paste(info, collapse = "; ")
[01:28:06.007]                           if (!has_future) {
[01:28:06.007]                             msg <- base::sprintf("Package 'future' is not installed on worker (%s)", 
[01:28:06.007]                               info)
[01:28:06.007]                           }
[01:28:06.007]                           else {
[01:28:06.007]                             msg <- base::sprintf("Package 'future' on worker (%s) must be of version >= 1.8.0: %s", 
[01:28:06.007]                               info, version)
[01:28:06.007]                           }
[01:28:06.007]                           base::stop(msg)
[01:28:06.007]                         }
[01:28:06.007]                       })
[01:28:06.007]                     }
[01:28:06.007]                     ...future.mc.cores.old <- base::getOption("mc.cores")
[01:28:06.007]                     base::options(mc.cores = 1L)
[01:28:06.007]                   }
[01:28:06.007]                   options(future.plan = NULL)
[01:28:06.007]                   Sys.unsetenv("R_FUTURE_PLAN")
[01:28:06.007]                   future::plan("default", .cleanup = FALSE, .init = FALSE)
[01:28:06.007]                 }
[01:28:06.007]                 ...future.workdir <- getwd()
[01:28:06.007]             }
[01:28:06.007]             ...future.oldOptions <- base::as.list(base::.Options)
[01:28:06.007]             ...future.oldEnvVars <- base::Sys.getenv()
[01:28:06.007]         }
[01:28:06.007]         base::options(future.startup.script = FALSE, future.globals.onMissing = "error", 
[01:28:06.007]             future.globals.maxSize = NULL, future.globals.method = NULL, 
[01:28:06.007]             future.globals.onMissing = "error", future.globals.onReference = NULL, 
[01:28:06.007]             future.globals.resolve = TRUE, future.resolve.recursive = NULL, 
[01:28:06.007]             future.rng.onMisuse = NULL, future.rng.onMisuse.keepFuture = NULL, 
[01:28:06.007]             future.stdout.windows.reencode = NULL, width = 80L)
[01:28:06.007]         ...future.futureOptionsAdded <- base::setdiff(base::names(base::.Options), 
[01:28:06.007]             base::names(...future.oldOptions))
[01:28:06.007]     }
[01:28:06.007]     if (FALSE) {
[01:28:06.007]     }
[01:28:06.007]     else {
[01:28:06.007]         if (TRUE) {
[01:28:06.007]             ...future.stdout <- base::rawConnection(base::raw(0L), 
[01:28:06.007]                 open = "w")
[01:28:06.007]         }
[01:28:06.007]         else {
[01:28:06.007]             ...future.stdout <- base::file(base::switch(.Platform$OS.type, 
[01:28:06.007]                 windows = "NUL", "/dev/null"), open = "w")
[01:28:06.007]         }
[01:28:06.007]         base::sink(...future.stdout, type = "output", split = FALSE)
[01:28:06.007]         base::on.exit(if (!base::is.null(...future.stdout)) {
[01:28:06.007]             base::sink(type = "output", split = FALSE)
[01:28:06.007]             base::close(...future.stdout)
[01:28:06.007]         }, add = TRUE)
[01:28:06.007]     }
[01:28:06.007]     ...future.frame <- base::sys.nframe()
[01:28:06.007]     ...future.conditions <- base::list()
[01:28:06.007]     ...future.rng <- base::globalenv()$.Random.seed
[01:28:06.007]     if (FALSE) {
[01:28:06.007]         ...future.globalenv.names <- c(base::names(base::.GlobalEnv), 
[01:28:06.007]             "...future.value", "...future.globalenv.names", ".Random.seed")
[01:28:06.007]     }
[01:28:06.007]     ...future.result <- base::tryCatch({
[01:28:06.007]         base::withCallingHandlers({
[01:28:06.007]             ...future.value <- base::withVisible(base::local({
[01:28:06.007]                 ...future.makeSendCondition <- base::local({
[01:28:06.007]                   sendCondition <- NULL
[01:28:06.007]                   function(frame = 1L) {
[01:28:06.007]                     if (is.function(sendCondition)) 
[01:28:06.007]                       return(sendCondition)
[01:28:06.007]                     ns <- getNamespace("parallel")
[01:28:06.007]                     if (exists("sendData", mode = "function", 
[01:28:06.007]                       envir = ns)) {
[01:28:06.007]                       parallel_sendData <- get("sendData", mode = "function", 
[01:28:06.007]                         envir = ns)
[01:28:06.007]                       envir <- sys.frame(frame)
[01:28:06.007]                       master <- NULL
[01:28:06.007]                       while (!identical(envir, .GlobalEnv) && 
[01:28:06.007]                         !identical(envir, emptyenv())) {
[01:28:06.007]                         if (exists("master", mode = "list", envir = envir, 
[01:28:06.007]                           inherits = FALSE)) {
[01:28:06.007]                           master <- get("master", mode = "list", 
[01:28:06.007]                             envir = envir, inherits = FALSE)
[01:28:06.007]                           if (inherits(master, c("SOCKnode", 
[01:28:06.007]                             "SOCK0node"))) {
[01:28:06.007]                             sendCondition <<- function(cond) {
[01:28:06.007]                               data <- list(type = "VALUE", value = cond, 
[01:28:06.007]                                 success = TRUE)
[01:28:06.007]                               parallel_sendData(master, data)
[01:28:06.007]                             }
[01:28:06.007]                             return(sendCondition)
[01:28:06.007]                           }
[01:28:06.007]                         }
[01:28:06.007]                         frame <- frame + 1L
[01:28:06.007]                         envir <- sys.frame(frame)
[01:28:06.007]                       }
[01:28:06.007]                     }
[01:28:06.007]                     sendCondition <<- function(cond) NULL
[01:28:06.007]                   }
[01:28:06.007]                 })
[01:28:06.007]                 withCallingHandlers({
[01:28:06.007]                   {
[01:28:06.007]                     x[name] <- list(1)
[01:28:06.007]                     x
[01:28:06.007]                   }
[01:28:06.007]                 }, immediateCondition = function(cond) {
[01:28:06.007]                   sendCondition <- ...future.makeSendCondition()
[01:28:06.007]                   sendCondition(cond)
[01:28:06.007]                   muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:06.007]                   {
[01:28:06.007]                     inherits <- base::inherits
[01:28:06.007]                     invokeRestart <- base::invokeRestart
[01:28:06.007]                     is.null <- base::is.null
[01:28:06.007]                     muffled <- FALSE
[01:28:06.007]                     if (inherits(cond, "message")) {
[01:28:06.007]                       muffled <- grepl(pattern, "muffleMessage")
[01:28:06.007]                       if (muffled) 
[01:28:06.007]                         invokeRestart("muffleMessage")
[01:28:06.007]                     }
[01:28:06.007]                     else if (inherits(cond, "warning")) {
[01:28:06.007]                       muffled <- grepl(pattern, "muffleWarning")
[01:28:06.007]                       if (muffled) 
[01:28:06.007]                         invokeRestart("muffleWarning")
[01:28:06.007]                     }
[01:28:06.007]                     else if (inherits(cond, "condition")) {
[01:28:06.007]                       if (!is.null(pattern)) {
[01:28:06.007]                         computeRestarts <- base::computeRestarts
[01:28:06.007]                         grepl <- base::grepl
[01:28:06.007]                         restarts <- computeRestarts(cond)
[01:28:06.007]                         for (restart in restarts) {
[01:28:06.007]                           name <- restart$name
[01:28:06.007]                           if (is.null(name)) 
[01:28:06.007]                             next
[01:28:06.007]                           if (!grepl(pattern, name)) 
[01:28:06.007]                             next
[01:28:06.007]                           invokeRestart(restart)
[01:28:06.007]                           muffled <- TRUE
[01:28:06.007]                           break
[01:28:06.007]                         }
[01:28:06.007]                       }
[01:28:06.007]                     }
[01:28:06.007]                     invisible(muffled)
[01:28:06.007]                   }
[01:28:06.007]                   muffleCondition(cond)
[01:28:06.007]                 })
[01:28:06.007]             }))
[01:28:06.007]             future::FutureResult(value = ...future.value$value, 
[01:28:06.007]                 visible = ...future.value$visible, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:06.007]                   ...future.rng), globalenv = if (FALSE) 
[01:28:06.007]                   list(added = base::setdiff(base::names(base::.GlobalEnv), 
[01:28:06.007]                     ...future.globalenv.names))
[01:28:06.007]                 else NULL, started = ...future.startTime, version = "1.8")
[01:28:06.007]         }, condition = base::local({
[01:28:06.007]             c <- base::c
[01:28:06.007]             inherits <- base::inherits
[01:28:06.007]             invokeRestart <- base::invokeRestart
[01:28:06.007]             length <- base::length
[01:28:06.007]             list <- base::list
[01:28:06.007]             seq.int <- base::seq.int
[01:28:06.007]             signalCondition <- base::signalCondition
[01:28:06.007]             sys.calls <- base::sys.calls
[01:28:06.007]             `[[` <- base::`[[`
[01:28:06.007]             `+` <- base::`+`
[01:28:06.007]             `<<-` <- base::`<<-`
[01:28:06.007]             sysCalls <- function(calls = sys.calls(), from = 1L) {
[01:28:06.007]                 calls[seq.int(from = from + 12L, to = length(calls) - 
[01:28:06.007]                   3L)]
[01:28:06.007]             }
[01:28:06.007]             function(cond) {
[01:28:06.007]                 is_error <- inherits(cond, "error")
[01:28:06.007]                 ignore <- !is_error && !is.null(NULL) && inherits(cond, 
[01:28:06.007]                   NULL)
[01:28:06.007]                 if (is_error) {
[01:28:06.007]                   sessionInformation <- function() {
[01:28:06.007]                     list(r = base::R.Version(), locale = base::Sys.getlocale(), 
[01:28:06.007]                       rngkind = base::RNGkind(), namespaces = base::loadedNamespaces(), 
[01:28:06.007]                       search = base::search(), system = base::Sys.info())
[01:28:06.007]                   }
[01:28:06.007]                   ...future.conditions[[length(...future.conditions) + 
[01:28:06.007]                     1L]] <<- list(condition = cond, calls = c(sysCalls(from = ...future.frame), 
[01:28:06.007]                     cond$call), session = sessionInformation(), 
[01:28:06.007]                     timestamp = base::Sys.time(), signaled = 0L)
[01:28:06.007]                   signalCondition(cond)
[01:28:06.007]                 }
[01:28:06.007]                 else if (!ignore && TRUE && inherits(cond, c("condition", 
[01:28:06.007]                 "immediateCondition"))) {
[01:28:06.007]                   signal <- TRUE && inherits(cond, "immediateCondition")
[01:28:06.007]                   ...future.conditions[[length(...future.conditions) + 
[01:28:06.007]                     1L]] <<- list(condition = cond, signaled = base::as.integer(signal))
[01:28:06.007]                   if (TRUE && !signal) {
[01:28:06.007]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:06.007]                     {
[01:28:06.007]                       inherits <- base::inherits
[01:28:06.007]                       invokeRestart <- base::invokeRestart
[01:28:06.007]                       is.null <- base::is.null
[01:28:06.007]                       muffled <- FALSE
[01:28:06.007]                       if (inherits(cond, "message")) {
[01:28:06.007]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:06.007]                         if (muffled) 
[01:28:06.007]                           invokeRestart("muffleMessage")
[01:28:06.007]                       }
[01:28:06.007]                       else if (inherits(cond, "warning")) {
[01:28:06.007]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:06.007]                         if (muffled) 
[01:28:06.007]                           invokeRestart("muffleWarning")
[01:28:06.007]                       }
[01:28:06.007]                       else if (inherits(cond, "condition")) {
[01:28:06.007]                         if (!is.null(pattern)) {
[01:28:06.007]                           computeRestarts <- base::computeRestarts
[01:28:06.007]                           grepl <- base::grepl
[01:28:06.007]                           restarts <- computeRestarts(cond)
[01:28:06.007]                           for (restart in restarts) {
[01:28:06.007]                             name <- restart$name
[01:28:06.007]                             if (is.null(name)) 
[01:28:06.007]                               next
[01:28:06.007]                             if (!grepl(pattern, name)) 
[01:28:06.007]                               next
[01:28:06.007]                             invokeRestart(restart)
[01:28:06.007]                             muffled <- TRUE
[01:28:06.007]                             break
[01:28:06.007]                           }
[01:28:06.007]                         }
[01:28:06.007]                       }
[01:28:06.007]                       invisible(muffled)
[01:28:06.007]                     }
[01:28:06.007]                     muffleCondition(cond, pattern = "^muffle")
[01:28:06.007]                   }
[01:28:06.007]                 }
[01:28:06.007]                 else {
[01:28:06.007]                   if (TRUE) {
[01:28:06.007]                     muffleCondition <- function (cond, pattern = "^muffle") 
[01:28:06.007]                     {
[01:28:06.007]                       inherits <- base::inherits
[01:28:06.007]                       invokeRestart <- base::invokeRestart
[01:28:06.007]                       is.null <- base::is.null
[01:28:06.007]                       muffled <- FALSE
[01:28:06.007]                       if (inherits(cond, "message")) {
[01:28:06.007]                         muffled <- grepl(pattern, "muffleMessage")
[01:28:06.007]                         if (muffled) 
[01:28:06.007]                           invokeRestart("muffleMessage")
[01:28:06.007]                       }
[01:28:06.007]                       else if (inherits(cond, "warning")) {
[01:28:06.007]                         muffled <- grepl(pattern, "muffleWarning")
[01:28:06.007]                         if (muffled) 
[01:28:06.007]                           invokeRestart("muffleWarning")
[01:28:06.007]                       }
[01:28:06.007]                       else if (inherits(cond, "condition")) {
[01:28:06.007]                         if (!is.null(pattern)) {
[01:28:06.007]                           computeRestarts <- base::computeRestarts
[01:28:06.007]                           grepl <- base::grepl
[01:28:06.007]                           restarts <- computeRestarts(cond)
[01:28:06.007]                           for (restart in restarts) {
[01:28:06.007]                             name <- restart$name
[01:28:06.007]                             if (is.null(name)) 
[01:28:06.007]                               next
[01:28:06.007]                             if (!grepl(pattern, name)) 
[01:28:06.007]                               next
[01:28:06.007]                             invokeRestart(restart)
[01:28:06.007]                             muffled <- TRUE
[01:28:06.007]                             break
[01:28:06.007]                           }
[01:28:06.007]                         }
[01:28:06.007]                       }
[01:28:06.007]                       invisible(muffled)
[01:28:06.007]                     }
[01:28:06.007]                     muffleCondition(cond, pattern = "^muffle")
[01:28:06.007]                   }
[01:28:06.007]                 }
[01:28:06.007]             }
[01:28:06.007]         }))
[01:28:06.007]     }, error = function(ex) {
[01:28:06.007]         base::structure(base::list(value = NULL, visible = NULL, 
[01:28:06.007]             conditions = ...future.conditions, rng = !identical(base::globalenv()$.Random.seed, 
[01:28:06.007]                 ...future.rng), started = ...future.startTime, 
[01:28:06.007]             finished = Sys.time(), session_uuid = NA_character_, 
[01:28:06.007]             version = "1.8"), class = "FutureResult")
[01:28:06.007]     }, finally = {
[01:28:06.007]         if (!identical(...future.workdir, getwd())) 
[01:28:06.007]             setwd(...future.workdir)
[01:28:06.007]         {
[01:28:06.007]             if (identical(getOption("nwarnings"), ...future.oldOptions$nwarnings)) {
[01:28:06.007]                 ...future.oldOptions$nwarnings <- NULL
[01:28:06.007]             }
[01:28:06.007]             base::options(...future.oldOptions)
[01:28:06.007]             if (.Platform$OS.type == "windows") {
[01:28:06.007]                 old_names <- names(...future.oldEnvVars)
[01:28:06.007]                 envs <- base::Sys.getenv()
[01:28:06.007]                 names <- names(envs)
[01:28:06.007]                 common <- intersect(names, old_names)
[01:28:06.007]                 added <- setdiff(names, old_names)
[01:28:06.007]                 removed <- setdiff(old_names, names)
[01:28:06.007]                 changed <- common[...future.oldEnvVars[common] != 
[01:28:06.007]                   envs[common]]
[01:28:06.007]                 NAMES <- toupper(changed)
[01:28:06.007]                 args <- list()
[01:28:06.007]                 for (kk in seq_along(NAMES)) {
[01:28:06.007]                   name <- changed[[kk]]
[01:28:06.007]                   NAME <- NAMES[[kk]]
[01:28:06.007]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:06.007]                     next
[01:28:06.007]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:06.007]                 }
[01:28:06.007]                 NAMES <- toupper(added)
[01:28:06.007]                 for (kk in seq_along(NAMES)) {
[01:28:06.007]                   name <- added[[kk]]
[01:28:06.007]                   NAME <- NAMES[[kk]]
[01:28:06.007]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:06.007]                     next
[01:28:06.007]                   args[[name]] <- ""
[01:28:06.007]                 }
[01:28:06.007]                 NAMES <- toupper(removed)
[01:28:06.007]                 for (kk in seq_along(NAMES)) {
[01:28:06.007]                   name <- removed[[kk]]
[01:28:06.007]                   NAME <- NAMES[[kk]]
[01:28:06.007]                   if (name != NAME && is.element(NAME, old_names)) 
[01:28:06.007]                     next
[01:28:06.007]                   args[[name]] <- ...future.oldEnvVars[[name]]
[01:28:06.007]                 }
[01:28:06.007]                 if (length(args) > 0) 
[01:28:06.007]                   base::do.call(base::Sys.setenv, args = args)
[01:28:06.007]                 args <- names <- old_names <- NAMES <- envs <- common <- added <- removed <- NULL
[01:28:06.007]             }
[01:28:06.007]             else {
[01:28:06.007]                 base::do.call(base::Sys.setenv, args = base::as.list(...future.oldEnvVars))
[01:28:06.007]             }
[01:28:06.007]             {
[01:28:06.007]                 if (base::length(...future.futureOptionsAdded) > 
[01:28:06.007]                   0L) {
[01:28:06.007]                   opts <- base::vector("list", length = base::length(...future.futureOptionsAdded))
[01:28:06.007]                   base::names(opts) <- ...future.futureOptionsAdded
[01:28:06.007]                   base::options(opts)
[01:28:06.007]                 }
[01:28:06.007]                 {
[01:28:06.007]                   {
[01:28:06.007]                     base::options(mc.cores = ...future.mc.cores.old)
[01:28:06.007]                     NULL
[01:28:06.007]                   }
[01:28:06.007]                   options(future.plan = NULL)
[01:28:06.007]                   if (is.na(NA_character_)) 
[01:28:06.007]                     Sys.unsetenv("R_FUTURE_PLAN")
[01:28:06.007]                   else Sys.setenv(R_FUTURE_PLAN = NA_character_)
[01:28:06.007]                   future::plan(list(function (..., workers = availableCores(), 
[01:28:06.007]                     lazy = FALSE, rscript_libs = .libPaths(), 
[01:28:06.007]                     envir = parent.frame()) 
[01:28:06.007]                   {
[01:28:06.007]                     if (is.function(workers)) 
[01:28:06.007]                       workers <- workers()
[01:28:06.007]                     workers <- structure(as.integer(workers), 
[01:28:06.007]                       class = class(workers))
[01:28:06.007]                     stop_if_not(length(workers) == 1, is.finite(workers), 
[01:28:06.007]                       workers >= 1)
[01:28:06.007]                     if (workers == 1L && !inherits(workers, "AsIs")) {
[01:28:06.007]                       return(sequential(..., lazy = TRUE, envir = envir))
[01:28:06.007]                     }
[01:28:06.007]                     future <- MultisessionFuture(..., workers = workers, 
[01:28:06.007]                       lazy = lazy, rscript_libs = rscript_libs, 
[01:28:06.007]                       envir = envir)
[01:28:06.007]                     if (!future$lazy) 
[01:28:06.007]                       future <- run(future)
[01:28:06.007]                     invisible(future)
[01:28:06.007]                   }), .cleanup = FALSE, .init = FALSE)
[01:28:06.007]                 }
[01:28:06.007]             }
[01:28:06.007]         }
[01:28:06.007]     })
[01:28:06.007]     if (TRUE) {
[01:28:06.007]         base::sink(type = "output", split = FALSE)
[01:28:06.007]         if (TRUE) {
[01:28:06.007]             ...future.result$stdout <- base::rawToChar(base::rawConnectionValue(...future.stdout))
[01:28:06.007]         }
[01:28:06.007]         else {
[01:28:06.007]             ...future.result["stdout"] <- base::list(NULL)
[01:28:06.007]         }
[01:28:06.007]         base::close(...future.stdout)
[01:28:06.007]         ...future.stdout <- NULL
[01:28:06.007]     }
[01:28:06.007]     ...future.result$conditions <- ...future.conditions
[01:28:06.007]     ...future.result$finished <- base::Sys.time()
[01:28:06.007]     ...future.result
[01:28:06.007] }
[01:28:06.013] Exporting 2 global objects (112 bytes) to cluster node #1 ...
[01:28:06.013] Exporting 'x' (0 bytes) to cluster node #1 ...
[01:28:06.013] Exporting 'x' (0 bytes) to cluster node #1 ... DONE
[01:28:06.014] Exporting 'name' (112 bytes) to cluster node #1 ...
[01:28:06.014] Exporting 'name' (112 bytes) to cluster node #1 ... DONE
[01:28:06.014] Exporting 2 global objects (112 bytes) to cluster node #1 ... DONE
[01:28:06.015] MultisessionFuture started
[01:28:06.015] - Launch lazy future ... done
[01:28:06.015] run() for 'MultisessionFuture' ... done
[01:28:06.016] result() for ClusterFuture ...
[01:28:06.016] receiveMessageFromWorker() for ClusterFuture ...
[01:28:06.016] - Validating connection of MultisessionFuture
[01:28:06.032] - received message: FutureResult
[01:28:06.033] - Received FutureResult
[01:28:06.033] - Erased future from FutureRegistry
[01:28:06.033] result() for ClusterFuture ...
[01:28:06.033] - result already collected: FutureResult
[01:28:06.033] result() for ClusterFuture ... done
[01:28:06.033] receiveMessageFromWorker() for ClusterFuture ... done
[01:28:06.034] result() for ClusterFuture ... done
[01:28:06.034] result() for ClusterFuture ...
[01:28:06.034] - result already collected: FutureResult
[01:28:06.034] 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")
[01:28:06.035] plan(): Setting new future strategy stack:
[01:28:06.036] List of future strategies:
[01:28:06.036] 1. FutureStrategy:
[01:28:06.036]    - args: function (..., envir = parent.frame(), workers = "<NULL>")
[01:28:06.036]    - tweaked: FALSE
[01:28:06.036]    - call: future::plan(oplan)
[01:28:06.040] plan(): nbrOfWorkers() = 1
Failed to undo environment variables:
 - Expected environment variables: [n=204] '!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', '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_RTOOLS43_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_SUBDIRS_STRICT_', '_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_USE_ALIASES_FROM_CRAN_', '_R_CLASS_MATRIX_ARRAY_', '_R_INSTALL_TIME_PATCHES_', '_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.45    0.14    2.31