@@ -28,6 +28,7 @@ jobs:
           - {os: ubuntu-latest,  r: 'oldrel-1' }
           - {os: ubuntu-latest,  r: 'oldrel-2' }
           - {os: ubuntu-latest,  r: '4.0'      , testme_exclude: 'mpi' }
+          - {os: ubuntu-latest,  r: '3.6'      , testme_exclude: 'mpi' }
 
           - {os: ubuntu-latest,  r: 'release'  , strict: true, label: 'strict' }
 
@@ -50,11 +51,12 @@ jobs:
       _R_COMPARE_LANG_OBJECTS: eqonly
       ## R CMD check
       _R_CHECK_CRAN_INCOMING_: false
+      _R_CHECK_CODOC_FUNCTIONS_MISSING_FROM_USAGES_: true
       _R_CHECK_MATRIX_DATA_: true
       _R_CHECK_SUGGESTS_ONLY_: true
       _R_CHECK_THINGS_IN_TEMP_DIR_: true
       _R_CHECK_TESTS_NLINES_: 300
-      RCMDCHECK_ERROR_ON: error
+      RCMDCHECK_ERROR_ON: note
       NOT_CRAN: true
       R_TESTME_EXCLUDE_NAME: ${{ matrix.config.testme_exclude }}
       ## Specific to futures
 
@@ -9,3 +9,4 @@ docs/
 revdep/data.sqlite
 revdep/checks/*
 revdep/library/*
+.osgrep
@@ -1,5 +1,5 @@
 Package: future
-Version: 1.76.0
+Version: 1.80.0
 Title: Unified Parallel and Distributed Processing in R for Everyone
 Depends:
     R (>= 3.2.0)
 
@@ -1,3 +1,50 @@
+# Version 1.80.0 [2026-10-15]
+
+## Significant Changes
+
+ * Memory use on parallel workers has gone down significantly in some
+   cases. A side effect is also significantly faster processing in
+   those cases. This improvement has an immediate effect on several
+   **future.apply** functions: `future_lapply()`, `future_sapply()`,
+   `future_apply()`, `future_tapply()`, `future_by()`,
+   `future_Filter()`, `future_eapply()`, `future_mapply()`, and
+   `future_Map()`.
+
+## Bug Fixes
+
+ * `cluster` and `multisession` futures could leave a stray, unclosed
+   worker connection behind if a worker was relaunched. This would
+   eventually result in warnings on "closing unused connection" when
+   the garbage collector ran.
+
+ * Explicitly specifying globals as a character vector via attributes
+   `add` or `ignore` would be ignored silently, e.g. `globals =
+   structure(c("a", "b"), add = "c")`.
+
+ * A future that uses a global `...` together with a global
+   `...future.FUN()` function, which is what **future.apply** uses,
+   could fail with "cycles in parent chains are not allowed". In R (<
+   4.5.0), it ended up in an infinite loop. This bug was introduced in
+   **future** 1.40.0 (2025-04-10).
+
+ * A sequential future that uses a global `...` together with a global
+   `...future.FUN()` function, which is what **future.apply** uses,
+   could permanently change the parent of the function's environment,
+   if that environment inherits from the global environment. This bug
+   was introduced in **future** 1.40.0 (2025-04-10).
+
+ * `makeClusterFuture(globals = ...)` would result in an future
+   evaluation error.
+
+ * Futures failed on R (< 4.0.0). This bug was introduced in **future**
+   1.68.0 (2025-11-17).
+
+ * Globals identified automatically (the default) could carry extra,
+   unneeded load that was exported to the parallel workers. This could
+   result in significant overhead in both total memory use and total
+   processing time.
+
+
 # Version 1.76.0 [2026-09-24]
 
 ## New Features
 
@@ -9,9 +9,9 @@
 #'  switch to use the ones from the \pkg{parallelly} package. Thank you!_
 #'
 #' * [parallelly::availableCores()]
-#    Used by: ale (1), BatchGetSymbols (2), codalm (1), cft (1), deseats (3),
+#    Used by: ale (2), BatchGetSymbols (2), codalm (1), cft (1), deseats (3),
 #             elevatr (1), heterogen, PINstimation (1), powRICLPM (1),
-#             readsdr (1), recforest (3), sigminer (2), skpr (1), smoots (3),
+#             readsdr (1), recforest (3), skpr (1), smoots (3),
 #             TriDimRegression (1), uci (1)
 #             [2025-12-22, 2026-01-31, 2026-04-04]
 #' * [parallelly::availableWorkers()]
 
@@ -407,6 +407,20 @@ stopWorkers.ClusterFutureBackend <- function(backend, interrupt = TRUE, ...) {
 
   ## Stop workers
   mdebugf_push("Stop cluster workers ...")
+
+  ## SANITY CHECK: Assert that the backend's worker list is in sync with
+  ## the memoized cluster that clusterRegistry holds.
+  ## See also https://github.com/futureverse/future/issues/820 and
+  ## https://github.com/futureverse/future/issues/830.
+  workers <- backend[["workers"]]
+  registered <- clusterRegistry$getCluster(debug = debug)
+  if (!is.null(registered) && !identical(workers, registered)) {
+    warning(FutureWarning(sprintf(
+      "Detected the workers of %s to be out of sync with the memoized cluster. This leaves stray, unclosed connections behind that will triggers a 'closing unused connection' warnings when the garbage collect runs",
+      class(backend)[1]
+    )))
+  }
+
   clusterRegistry$stopCluster(debug = debug)
   env <- environment(ClusterFutureBackend)
   env[["last"]] <- NULL
@@ -1231,6 +1245,7 @@ requestNode <- local({
 
         workers[[node_idx]] <- node2
         backend[["workers"]] <- workers
+        clusterRegistry$setCluster(workers)
         node <- node2
 
         if (debug) {
@@ -1609,6 +1624,7 @@ handleInterruptedFuture <- local({
 
         ## Update backend
         backend[["workers"]] <- workers
+        clusterRegistry$setCluster(workers)
 
         node <- NULL
 
@@ -1743,6 +1759,10 @@ clusterRegistry <- local({
     cluster
   } ## startCluster()
 
+  setCluster <- function(cl) {
+    cluster <<- cl
+  }
+
   stopCluster <- function(debug = FALSE) {
     if (debug) {
       mdebug_push("Stopping existing cluster ...")
@@ -1800,6 +1820,7 @@ clusterRegistry <- local({
   list(
       getCluster = getCluster,
     startCluster = startCluster,
+      setCluster = setCluster,
      stopCluster = stopCluster
   )
 }) ## clusterRegistry()
@@ -12,7 +12,6 @@
 #'
 #' @keywords internal
 #' @rdname FutureBackend-class
-#" @importFrom parallelly supportsMulticore
 #' @export
 MultisessionFutureBackend <- function(workers = availableCores(constraints = "connections-16"), rscript_libs = .libPaths(), interrupts = TRUE, gc = FALSE, earlySignal = FALSE, ...) {
   debug <- isTRUE(getOption("future.debug"))
@@ -23,18 +22,14 @@ MultisessionFutureBackend <- function(workers = availableCores(constraints = "co
     on.exit(mdebugf_pop())
   }
 
-  default_workers <- missing(workers)
   if (is.function(workers)) workers <- workers()
   stop_if_not(is.numeric(workers))
   workers <- structure(as.integer(workers), class = setdiff(class(workers), c("integer", "numeric")))
   stop_if_not(length(workers) == 1, is.finite(workers), workers >= 1)
 
   ## Fall back to sequential futures if only a single additional R process
   ## can be spawned off, i.e. then use the current main R process.
-  ## Sequential futures best reflect how multicore futures handle globals.
   if (workers == 1L && !inherits(workers, "AsIs")) {
-    ## AD HOC: Make sure plan(multicore) also produces a warning, if needed
-    if (default_workers) supportsMulticore(warn = TRUE)
     ## covr: skip=1
     return(SequentialFutureBackend(...))
   }
 
@@ -548,6 +548,10 @@ assertOwner <- local({
 
 #' Run a future
 #'
+#' @usage
+#' run(future, ...)
+#' \method{run}{Future}(future, ...)
+#'
 #' @param future A \link{Future}.
 #' @param \ldots Not used.
 #'
@@ -581,7 +585,7 @@ run.Future <- function(future, ...) {
   ## Be conservative for now; don't allow lazy futures created in another R
   ## session to be launched. This will hopefully change later, but we won't
   ## open this door until we understand the ramifications. /HB 2020-12-21
-  if (isTRUE(getOption("future.lazy.assertOwner"))) {
+  if (isTRUE(getOption("future.lazy.assertOwner", TRUE))) {
     assertOwner(future)
   }
 
 
@@ -53,28 +53,6 @@ FutureRegistry <- local({
       on.exit(mdebugf_pop())
     }
 
-    futuresDB <- db[[where]]
-    drop <- integer(0L)
-
-    on.exit({
-      ## Clean out collected futures
-      if (length(drop) > 0) {
-        if (debug) {
-          mdebug_push("Remove collected futures ...")
-          mdebugf("Indices of futures to drop: [n=%d] %s", length(drop), commaq(drop))
-        }
-        futuresDB <- futuresDB[-drop]
-        db[[where]] <<- futuresDB
-        if (debug) mdebug_pop()
-      } else {
-        if (debug) mdebug("Indices of futures to drop: [n=0] <none>")
-      }
-    }, add = TRUE)
-
-    if (debug) {
-      on.exit(mdebugf_pop(), add = TRUE)
-    }
-
     for (ii in seq_along(futures)) {
       future <- futures[[ii]]
 
@@ -118,31 +96,10 @@ FutureRegistry <- local({
 
         ## (b) Make sure future is removed from registry, unless
         ##     already done via above value() call.
-        idx <- indexOf(futuresDB, future = future)
+        idx <- indexOf(db[[where]], future = future)
         if (!is.na(idx)) {
-          drop <- c(drop, idx)
-
-          ## Update backend
-          backend <- future[["backend"]]
-          if (!is.null(backend)) {
-            ## Update counters
-            counters <- backend[["counters"]]
-            counters["finished"] <- counters["finished"] + 1L
-            backend[["counters"]] <- counters
-            
-            ## Update total runtime 
-            result <- future[["result"]]
-            if (inherits(result, "FutureResult")) {
-              times <- result[c("finished", "started")]
-              if (length(times) == 2L) {
-                dt <- times[["finished"]] - times[["started"]]
-                runtime <- backend[["runtime"]]
-                runtime <- runtime + dt
-                backend[["runtime"]] <- runtime
-              }
-            }
-          }
-        } ## if (!is.na(idx))
+          FutureRegistry(where, action = "remove", future = future, earlySignal = FALSE, debug = debug)
+        }
 
         ## (c) Collect only the first resolved future?
         if (firstOnly) {
@@ -235,11 +192,14 @@ FutureRegistry <- local({
       }
     } else if (action == "collect-first") {
       collectValues(where, futures = futures, firstOnly = TRUE, debug = debug)
+      futures <- db[[where]]
     } else if (action == "collect-all") {
       collectValues(where, futures = futures, firstOnly = FALSE, debug = debug)
+      futures <- db[[where]]
       earlySignal <- FALSE ## Avoid second round of result collection
     } else if (action == "reset") {
-      db[[where]] <<- list()
+      futures <- list()
+      db[[where]] <<- futures
       if (debug) mdebug("Erased registry")
     } else if (action == "list") {
       if (debug) mdebug("Listing all futures")
@@ -263,6 +223,7 @@ FutureRegistry <- local({
         ## Collect values, which will trigger signaling during
         ## calls to resolved().
         collectValues(where, futures = futures[idxs], firstOnly = FALSE)
+        futures <- db[[where]]
       }
       if (debug) mdebugf("Early signaling of %d future candidates ... done", length(futures))
     }
 
@@ -1,19 +1,28 @@
-#' Cancel a future
+#' Cancel one or more futures
 #'
 #' Cancels futures, with the option to interrupt running ones.
+#' `cancel()` is vectorized, i.e. accepts a collection of futures
+#' to be canceled.
 #'
-#' @param x A Future.
+#' @param x A [Future], a list, an environment, or a list environment
+#' (\link[listenv:listenv]{listenv}). Lists and environments may hold
+#' a mix of futures and non-future elements, and may be nested, e.g.
+#' a list of lists of futures; every future found, at any depth, is
+#' canceled.
 #'
 #' @param interrupt If TRUE, running futures are interrupted, if the
 #' future backend supports it.
 #'
 #' @param \ldots All arguments used by the S3 methods.
 #'
 #' @return
-#' `cancel()` returns (invisibly) the canceled [Future]s after
-#' flagging them as "canceled" and possibly interrupting them as well.
+#' `cancel()` returns (invisibly) `x` after canceling every [Future]
+#' therein, that is, after flagging each one as "canceled" and
+#' possibly interrupting it as well.
 #'
-#' Canceling a lazy or a finished future has no effect.
+#' Canceling a lazy or a finished future has no effect. Elements of
+#' `x` that are neither futures nor collections of futures are left
+#' untouched.
 #'
 #' @examplesIf (interactive() || .Platform[["OS.type"]] != "windows")
 #' ## Set up two parallel workers
@@ -30,7 +39,7 @@
 #' ## Wait until at least one of the futures is resolved
 #' while (!any(resolved(fs))) Sys.sleep(0.1)
 #' 
-#' ## Cancel the future that is not yet resolved
+#' ## Cancel futures that are not yet resolved
 #' r <- resolved(fs)
 #' cancel(fs[!r])
 #'