diff --git a/DESCRIPTION b/DESCRIPTION
index 52a7e8388..d2965f914 100644
--- a/DESCRIPTION
+++ b/DESCRIPTION
@@ -1,7 +1,7 @@
 Type: Package
 Package: mirai
 Title: Minimalist Async Evaluation Framework for R
-Version: 2.4.1.9000
+Version: 2.4.1
 Authors@R: c(
     person("Charlie", "Gao", , "charlie.gao@posit.co", role = c("aut", "cre"),
            comment = c(ORCID = "0000-0002-0750-061X")),
diff --git a/NEWS.md b/NEWS.md
index 7f93daf11..2b5fe461c 100644
--- a/NEWS.md
+++ b/NEWS.md
@@ -1,5 +1,3 @@
-# mirai (development version)
-
 # mirai 2.4.1
 
 #### New Features
diff --git a/R/mirai.R b/R/mirai.R
index 0c157603b..2b15a0460 100644
--- a/R/mirai.R
+++ b/R/mirai.R
@@ -202,9 +202,11 @@ mirai <- function(
 #'
 #' If using dispatcher, this function forces a synchronization point at
 #' dispatcher, whereby the [everywhere()] call must have been evaluated on all
-#' daemons prior to subsequent evaluations taking place. It is an error to call
-#' [everywhere()] successively without at least one [mirai()] call in between,
-#' as an ordinary mirai call is required to exit each synchronization point.
+#' daemons prior to subsequent evaluations taking place.
+#'
+#' It is an error to call [everywhere()] successively without at least one
+#' [mirai()] call in between, as an ordinary mirai call is required to exit each
+#' synchronization point.
 #'
 #' @inheritParams mirai
 #'
@@ -216,16 +218,16 @@ mirai <- function(
 #' daemons(1)
 #' # export common data by a super-assignment expression:
 #' everywhere(y <<- 3)
+#' mirai(y)[]
 #' # '...' variables are assigned to the global environment
 #' # '.expr' may be specified as an empty {} in such cases:
 #' everywhere({}, a = 1, b = 2)
-#' m <- mirai(a + b - y == 0L)
-#' m[]
-#' # everywhere() returns a list of mirai which may be waited for and inspected
-#' mlist <- everywhere("just a normal operation")
-#' collect_mirai(mlist)
-#' mlist <- everywhere(stop("error"))
-#' collect_mirai(mlist)
+#' mirai(a + b - y == 0L)[]
+#'
+#' # everywhere() returns a mirai_map object:
+#' mp <- everywhere("just a normal operation")
+#' mp
+#' mp[]
 #' daemons(0)
 #'
 #' # loading a package on all daemons
diff --git a/README.Rmd b/README.Rmd
index 498837071..004361bf8 100644
--- a/README.Rmd
+++ b/README.Rmd
@@ -30,126 +30,116 @@ knitr::opts_chunk$set(
 <br /><br />
 Minimalist Async Evaluation Framework for R
 <br /><br />
-→ Designed for simplicity, a 'mirai' evaluates an R expression asynchronously in a parallel process, locally or distributed over the network.
 
-→ Modern networking and concurrency, built on [nanonext](https://github.com/r-lib/nanonext/) and [NNG](https://nng.nanomsg.org/), ensures reliable scheduling over fast inter-process communications or TCP/IP secured by TLS.
+mirai is a comprehensive solution for performing computationally-intensive tasks efficiently.
 
-→ Launch remote resources via SSH or cluster managers for distributed computing.
+→ Run R code in parallel in the background, without blocking your session
+	
+→ Distribute workloads across local or remote machines
+ 
+→ Execute tasks on different compute resources based on requirements
+ 
+→ Perform actions as soon as tasks complete via promises
 
-→ Scales efficiently to millions of tasks over thousands of connections, requiring no storage on the file system due to its inherently queued architecture.
-
-→ Innovative features include event-driven promises, asynchronous parallel map, and seamless serialization of otherwise non-exportable reference objects.
-<br /><br />
+<br />
 
-### Quick Start
+### Installation
 
-mirai is Japanese for 'future' and is an implementation of *futures* in R.
+```{r}
+#| label: cran
+#| eval: false
+install.packages("mirai")
+```
 
-→ `mirai()`:
+### Quick Start
 
-Sends an expression to be evaluated asynchronously in a separate R process and returns a mirai object immediately. Creation of a mirai is never blocking.
+→ `mirai()`: Evaluate an R expression asynchronously in a parallel process.
 
-The result of a mirai `m` will be available at `m$data` once evaluation is complete and its return value is received. `m[]` may be used to wait for and collect the value.
+→ `daemons()`: Set and launch persistent background processes, local or remote, on which to run mirai tasks.
 
 ```{r}
 #| label: exec
 library(mirai)
 
-m <- mirai(
-  {
-    # slow operation
-    Sys.sleep(2)
-    sample(1:100, 1)
-  }
-)
+daemons(5)
 
-m
-m$data
+m <- mirai({
+  Sys.sleep(1)
+  100 + 42
+})
 
-# do other work
+mp <- mirai_map(1:9, \(x) {
+  Sys.sleep(1)
+  x^2
+})
 
+m
 m[]
-m$data
-```
-
-→ `daemons()`:
-
-Sets persistent background processes (*daemons*) where mirai are evaluated.
 
-To launch 6 local daemons:
+mp
+mp[.flat]
 
-```{r}
-#| label: daemons
-daemons(6)
+daemons(0)
 ```
 
-To launch daemons over the network for distributed computing, this is supported via:
+### Design Concepts
 
-- SSH
-- HPC cluster resource managers (for Slurm, SGE, Torque, PBS, LSF)
+mirai is designed from the ground up to provide a production-grade experience.
 
-See the [reference vignette](https://mirai.r-lib.org/articles/mirai.html) for further details.
+→ Modern
 
-→ `mirai_map()`:
+- Current technologies built on [nanonext](https://github.com/r-lib/nanonext/) and [NNG](https://nng.nanomsg.org/)
+- Communications layer supports IPC (Inter-Process Communication), TCP/IP and TLS
 
-Maps a function over a list or vector, with each element processed as a mirai.
-For a dataframe or matrix, it automatically performs multiple map over the rows.
+→ Efficient
 
-A 'mirai_map' object is returned immediately, and is always non-blocking.
+- 1,000x more responsive vs. other alternatives [<sup>[1]</sup>](https://github.com/r-lib/mirai/pull/142#issuecomment-2457589563)
+- Ideal for low-latency applications e.g. real time inference & Shiny apps
 
-Its value may be retrieved using its `[]` method, returning a list.
-The `[]` method also provides options for flatmap, early stopping and progress indicators.
+→ Reliable
 
-```{r}
-#| label: map
-df <- data.frame(
-  fruit = c("apples", "oranges", "pears"),
-  price = c(3L, 2L, 5L)
-)
+- No reliance on global options or variables for consistent behaviour
+- Explicit evaluation for transparent and predictable results
 
-m <- df |>
-  mirai_map(\(...) sprintf("%s: $%d", ...))
-m
-m[.flat]
-```
+→ Scalable
 
-### Design Concepts
+- Capacity for millions of tasks over thousands of connections
+- Proven track record for heavy-duty workloads in the life sciences industry
 
-mirai is designed from the ground up to provide a production-grade experience.
+### Key Features
 
-→ Fast
+→ Distributed Execution: Run tasks across networks and clusters using various deployment methods (SSH, HPC clusters using Slurm, SGE, Torque, PBS, LSF, etc.)
 
-- 1,000x more responsive vs. common alternatives [<sup>[1]</sup>](https://github.com/r-lib/mirai/pull/142#issuecomment-2457589563)
-- Built for low-latency applications e.g. real time inference & Shiny apps
+→ Compute Profiles: Manage different sets of daemons independently, allowing tasks with different requirements to be executed on appropriate resources.
 
-→ Reliable
+→ Promises Integration: An event-driven implementation performs actions on returned values as soon as tasks complete, ensuring minimal latency.
 
-- No reliance on global options or variables for consistent behaviour
-- Explicit evaluation for transparent and predictable results
+→ Serialization Support: Native serialization support for reference objects such as Arrow Tables, Polars DataFrames or torch tensors.
 
-→ Scalable
+→ Error Handling: Robust error handling and reporting, with full stack traces for debugging.
 
-- Launch millions of tasks over thousands of connections
-- Proven track record for heavy-duty workloads in the life sciences industry
+→ RNG Management: L'Ecuyer-CMRG RNG streams for reproducible random number generation in parallel execution.
 
 ### Powering the Ecosystem
 
-mirai features the following core integrations, with usage examples in the linked vignettes:
+mirai serves as a foundation for asynchronous and parallel computing in the R ecosystem:
 
-[<img alt="R parallel" src="https://www.r-project.org/logo/Rlogo.png" width="40" height="31" />](https://mirai.r-lib.org/articles/v04-parallel.html) &nbsp; Provides the first official alternative communications backend for R, implementing the 'MIRAI' parallel cluster type, a feature request by R-Core at R Project Sprint 2023.
+[<img alt="R parallel" src="https://www.r-project.org/logo/Rlogo.png" width="40" height="31" />](https://mirai.r-lib.org/articles/v04-parallel.html) &nbsp; Implements the first official alternative communications backend for R — the 'MIRAI' parallel cluster — fulfilling a feature request by R-Core at R Project Sprint 2023.
 
 [<img alt="purrr" src="https://purrr.tidyverse.org/logo.png" width="40" height="46" />](https://purrr.tidyverse.org) &nbsp; Powers parallel map for the purrr functional programming toolkit, a core tidyverse package.
 
-[<img alt="promises" src="https://solutions.posit.co/images/brand/posit-icon-fullcolor.svg" width="40" height="36" />](https://mirai.r-lib.org/articles/v02-promises.html) &nbsp; Implements next generation, event-driven promises. 'mirai' and 'mirai_map' objects are readily convertible to 'promises', and may be used directly with the promise pipe.
+[<img alt="promises" src="https://solutions.posit.co/images/brand/posit-icon-fullcolor.svg" width="40" height="36" />](https://mirai.r-lib.org/articles/v02-promises.html) &nbsp; Promises for 'mirai' and 'mirai_map' objects are event-driven, providing the lowest latency and highest responsiveness for performance-critical applications.
 
-[<img alt="Shiny" src="https://github.com/rstudio/shiny/raw/main/man/figures/logo.png" width="40" height="46" />](https://mirai.r-lib.org/articles/v02-promises.html) &nbsp; The primary async backend for Shiny, supporting ExtendedTask and the next level of responsiveness and scalability for Shiny apps.
+[<img alt="Shiny" src="https://github.com/rstudio/shiny/raw/main/man/figures/logo.png" width="40" height="46" />](https://mirai.r-lib.org/articles/v02-promises.html) &nbsp; The primary async backend for Shiny, with full ExtendedTask support, providing the next level of responsiveness and scalability for Shiny apps.
 
-[<img alt="Plumber" src="https://rstudio.github.io/cheatsheets/html/images/logo-plumber.png" width="40" height="46" />](https://mirai.r-lib.org/articles/v02-promises.html) &nbsp; The built-in async evaluator behind the `@async` tag in plumber2; also provides an async backend for Plumber.
+[<img alt="plumber2" src="https://github.com/posit-dev/plumber2/raw/main/man/figures/logo.svg" width="40" height="46" />](https://mirai.r-lib.org/articles/v02-promises.html) &nbsp; The built-in async evaluator behind the `@async` tag in plumber2; also provides an async backend for Plumber.
 
 [<img alt="torch" src="https://torch.mlverse.org/css/images/hex/torch.png" width="40" height="46" />](https://mirai.r-lib.org/articles/v03-serialization.html) &nbsp; Allows Torch tensors and complex objects such as models and optimizers to be used seamlessly across parallel processes.
 
 [<img alt="Arrow" src="https://arrow.apache.org/img/arrow-logo_hex_black-txt_white-bg.png" width="40" height="46" />](https://mirai.r-lib.org/articles/v03-serialization.html) &nbsp; Allows queries using the Apache Arrow format to be handled seamlessly over ADBC database connections hosted in background processes.
 
+[<img alt="Polars" src="https://github.com/pola-rs/polars-static/raw/master/logos/polars_logo_blue.svg" width="40" height="46" />](https://mirai.r-lib.org/articles/v03-serialization.html) &nbsp; R Polars is a pioneer of mirai's serialization registration mechanism, which allows transparent use of Polars objects across parallel processes, with no user setup required.
+
 [<img alt="targets" src="https://github.com/ropensci/targets/raw/main/man/figures/logo.png" width="40" height="46" />](https://docs.ropensci.org/targets/) &nbsp; Targets, a make-like pipeline tool, uses crew as its default high-performance computing backend.
 Crew is a distributed worker launcher extending mirai to different computing platforms, from traditional clusters to cloud services.
 
@@ -165,30 +155,14 @@ We would like to thank in particular:
 
 [Travers Ching](https://github.com/traversc) for a novel idea in extending the original custom serialization support in the package.
 
+[Hadley Wickham](https://github.com/hadley) for original implementations of the scoped helper functions, on which ours are based.
+
 [Henrik Bengtsson](https://github.com/HenrikBengtsson/) for valuable insights leading to the interface accepting broader usage patterns.
 
 [Daniel Falbel](https://github.com/dfalbel/) for discussion around an efficient solution to serialization and transmission of torch tensors.
 
 [Kirill Müller](https://github.com/krlmlr/) for discussion on using parallel processes to host Arrow database connections.
 
-### Installation
-
-Install the latest release from CRAN:
-
-```{r}
-#| label: cran
-#| eval: false
-install.packages("mirai")
-```
-
-The current development version is available from R-universe:
-
-```{r}
-#| label: universe
-#| eval: false
-install.packages("mirai", repos = "https://r-lib.r-universe.dev")
-```
-
 ### Links & References
 
 ◈ mirai R package: <https://mirai.r-lib.org/> <br />
diff --git a/README.md b/README.md
index ca2afb346..26a420959 100644
--- a/README.md
+++ b/README.md
@@ -18,112 +18,64 @@ coverage](https://codecov.io/gh/r-lib/mirai/graph/badge.svg)](https://app.codeco
 ### ミライ
 
 <br /> みらい 未来 <br /><br /> Minimalist Async Evaluation Framework
-for R <br /><br /> → Designed for simplicity, a ‘mirai’ evaluates an R
-expression asynchronously in a parallel process, locally or distributed
-over the network.
+for R <br /><br />
 
-→ Modern networking and concurrency, built on
-[nanonext](https://github.com/r-lib/nanonext/) and
-[NNG](https://nng.nanomsg.org/), ensures reliable scheduling over fast
-inter-process communications or TCP/IP secured by TLS.
+mirai is a comprehensive solution for performing
+computationally-intensive tasks efficiently.
 
-→ Launch remote resources via SSH or cluster managers for distributed
-computing.
+→ Run R code in parallel in the background, without blocking your
+session
 
-→ Scales efficiently to millions of tasks over thousands of connections,
-requiring no storage on the file system due to its inherently queued
-architecture.
+→ Distribute workloads across local or remote machines
 
-→ Innovative features include event-driven promises, asynchronous
-parallel map, and seamless serialization of otherwise non-exportable
-reference objects. <br /><br />
+→ Execute tasks on different compute resources based on requirements
 
-### Quick Start
-
-mirai is Japanese for ‘future’ and is an implementation of *futures* in
-R.
-
-→ `mirai()`:
+→ Perform actions as soon as tasks complete via promises
 
-Sends an expression to be evaluated asynchronously in a separate R
-process and returns a mirai object immediately. Creation of a mirai is
-never blocking.
+<br />
 
-The result of a mirai `m` will be available at `m$data` once evaluation
-is complete and its return value is received. `m[]` may be used to wait
-for and collect the value.
+### Installation
 
 ``` r
-library(mirai)
-
-m <- mirai(
-  {
-    # slow operation
-    Sys.sleep(2)
-    sample(1:100, 1)
-  }
-)
-
-m
-#> < mirai [] >
-m$data
-#> 'unresolved' logi NA
-
-# do other work
-
-m[]
-#> [1] 86
-m$data
-#> [1] 86
+install.packages("mirai")
 ```
 
-→ `daemons()`:
+### Quick Start
 
-Sets persistent background processes (*daemons*) where mirai are
-evaluated.
+→ `mirai()`: Evaluate an R expression asynchronously in a parallel
+process.
 
-To launch 6 local daemons:
+→ `daemons()`: Set and launch persistent background processes, local or
+remote, on which to run mirai tasks.
 
 ``` r
-daemons(6)
-#> [1] 6
-```
-
-To launch daemons over the network for distributed computing, this is
-supported via:
-
-- SSH
-- HPC cluster resource managers (for Slurm, SGE, Torque, PBS, LSF)
-
-See the [reference
-vignette](https://mirai.r-lib.org/articles/mirai.html) for further
-details.
+library(mirai)
 
-→ `mirai_map()`:
+daemons(5)
+#> [1] 5
 
-Maps a function over a list or vector, with each element processed as a
-mirai. For a dataframe or matrix, it automatically performs multiple map
-over the rows.
+m <- mirai({
+  Sys.sleep(1)
+  100 + 42
+})
 
-A ‘mirai_map’ object is returned immediately, and is always
-non-blocking.
+mp <- mirai_map(1:9, \(x) {
+  Sys.sleep(1)
+  x^2
+})
 
-Its value may be retrieved using its `[]` method, returning a list. The
-`[]` method also provides options for flatmap, early stopping and
-progress indicators.
+m
+#> < mirai [] >
+m[]
+#> [1] 142
 
-``` r
-df <- data.frame(
-  fruit = c("apples", "oranges", "pears"),
-  price = c(3L, 2L, 5L)
-)
+mp
+#> < mirai map [4/9] >
+mp[.flat]
+#> [1]  1  4  9 16 25 36 49 64 81
 
-m <- df |>
-  mirai_map(\(...) sprintf("%s: $%d", ...))
-m
-#> < mirai map [0/3] >
-m[.flat]
-#> [1] "apples: $3"  "oranges: $2" "pears: $5"
+daemons(0)
+#> [1] 0
 ```
 
 ### Design Concepts
@@ -131,11 +83,19 @@ m[.flat]
 mirai is designed from the ground up to provide a production-grade
 experience.
 
-→ Fast
+→ Modern
+
+- Current technologies built on
+  [nanonext](https://github.com/r-lib/nanonext/) and
+  [NNG](https://nng.nanomsg.org/)
+- Communications layer supports IPC (Inter-Process Communication),
+  TCP/IP and TLS
+
+→ Efficient
 
-- 1,000x more responsive vs. common alternatives
+- 1,000x more responsive vs. other alternatives
   [<sup>\[1\]</sup>](https://github.com/r-lib/mirai/pull/142#issuecomment-2457589563)
-- Built for low-latency applications e.g. real time inference & Shiny
+- Ideal for low-latency applications e.g. real time inference & Shiny
   apps
 
 → Reliable
@@ -145,34 +105,57 @@ experience.
 
 → Scalable
 
-- Launch millions of tasks over thousands of connections
+- Capacity for millions of tasks over thousands of connections
 - Proven track record for heavy-duty workloads in the life sciences
   industry
 
+### Key Features
+
+→ Distributed Execution: Run tasks across networks and clusters using
+various deployment methods (SSH, HPC clusters using Slurm, SGE, Torque,
+PBS, LSF, etc.)
+
+→ Compute Profiles: Manage different sets of daemons independently,
+allowing tasks with different requirements to be executed on appropriate
+resources.
+
+→ Promises Integration: An event-driven implementation performs actions
+on returned values as soon as tasks complete, ensuring minimal latency.
+
+→ Serialization Support: Native serialization support for reference
+objects such as Arrow Tables, Polars DataFrames or torch tensors.
+
+→ Error Handling: Robust error handling and reporting, with full stack
+traces for debugging.
+
+→ RNG Management: L’Ecuyer-CMRG RNG streams for reproducible random
+number generation in parallel execution.
+
 ### Powering the Ecosystem
 
-mirai features the following core integrations, with usage examples in
-the linked vignettes:
+mirai serves as a foundation for asynchronous and parallel computing in
+the R ecosystem:
 
 [<img alt="R parallel" src="https://www.r-project.org/logo/Rlogo.png" width="40" height="31" />](https://mirai.r-lib.org/articles/v04-parallel.html)
-  Provides the first official alternative communications backend for R,
-implementing the ‘MIRAI’ parallel cluster type, a feature request by
-R-Core at R Project Sprint 2023.
+  Implements the first official alternative communications backend for R
+— the ‘MIRAI’ parallel cluster — fulfilling a feature request by R-Core
+at R Project Sprint 2023.
 
 [<img alt="purrr" src="https://purrr.tidyverse.org/logo.png" width="40" height="46" />](https://purrr.tidyverse.org)
   Powers parallel map for the purrr functional programming toolkit, a
 core tidyverse package.
 
 [<img alt="promises" src="https://solutions.posit.co/images/brand/posit-icon-fullcolor.svg" width="40" height="36" />](https://mirai.r-lib.org/articles/v02-promises.html)
-  Implements next generation, event-driven promises. ‘mirai’ and
-‘mirai_map’ objects are readily convertible to ‘promises’, and may be
-used directly with the promise pipe.
+  Promises for ‘mirai’ and ‘mirai_map’ objects are event-driven,
+providing the lowest latency and highest responsiveness for
+performance-critical applications.
 
 [<img alt="Shiny" src="https://github.com/rstudio/shiny/raw/main/man/figures/logo.png" width="40" height="46" />](https://mirai.r-lib.org/articles/v02-promises.html)
-  The primary async backend for Shiny, supporting ExtendedTask and the
-next level of responsiveness and scalability for Shiny apps.
+  The primary async backend for Shiny, with full ExtendedTask support,
+providing the next level of responsiveness and scalability for Shiny
+apps.
 
-[<img alt="Plumber" src="https://rstudio.github.io/cheatsheets/html/images/logo-plumber.png" width="40" height="46" />](https://mirai.r-lib.org/articles/v02-promises.html)
+[<img alt="plumber2" src="https://github.com/posit-dev/plumber2/raw/main/man/figures/logo.svg" width="40" height="46" />](https://mirai.r-lib.org/articles/v02-promises.html)
   The built-in async evaluator behind the `@async` tag in plumber2; also
 provides an async backend for Plumber.
 
@@ -184,6 +167,11 @@ to be used seamlessly across parallel processes.
   Allows queries using the Apache Arrow format to be handled seamlessly
 over ADBC database connections hosted in background processes.
 
+[<img alt="Polars" src="https://github.com/pola-rs/polars-static/raw/master/logos/polars_logo_blue.svg" width="40" height="46" />](https://mirai.r-lib.org/articles/v03-serialization.html)
+  R Polars is a pioneer of mirai’s serialization registration mechanism,
+which allows transparent use of Polars objects across parallel
+processes, with no user setup required.
+
 [<img alt="targets" src="https://github.com/ropensci/targets/raw/main/man/figures/logo.png" width="40" height="46" />](https://docs.ropensci.org/targets/)
   Targets, a make-like pipeline tool, uses crew as its default
 high-performance computing backend. Crew is a distributed worker
@@ -211,6 +199,9 @@ processing, and making it possible for mirai to be the first
 [Travers Ching](https://github.com/traversc) for a novel idea in
 extending the original custom serialization support in the package.
 
+[Hadley Wickham](https://github.com/hadley) for original implementations
+of the scoped helper functions, on which ours are based.
+
 [Henrik Bengtsson](https://github.com/HenrikBengtsson/) for valuable
 insights leading to the interface accepting broader usage patterns.
 
@@ -220,20 +211,6 @@ efficient solution to serialization and transmission of torch tensors.
 [Kirill Müller](https://github.com/krlmlr/) for discussion on using
 parallel processes to host Arrow database connections.
 
-### Installation
-
-Install the latest release from CRAN:
-
-``` r
-install.packages("mirai")
-```
-
-The current development version is available from R-universe:
-
-``` r
-install.packages("mirai", repos = "https://r-lib.r-universe.dev")
-```
-
 ### Links & References
 
 ◈ mirai R package: <https://mirai.r-lib.org/> <br /> ◈ nanonext R
diff --git a/man/everywhere.Rd b/man/everywhere.Rd
index b4e8e9735..07b309a0d 100644
--- a/man/everywhere.Rd
+++ b/man/everywhere.Rd
@@ -38,9 +38,11 @@ options are persisted regardless of a daemon's \code{cleanup} setting.
 \details{
 If using dispatcher, this function forces a synchronization point at
 dispatcher, whereby the \code{\link[=everywhere]{everywhere()}} call must have been evaluated on all
-daemons prior to subsequent evaluations taking place. It is an error to call
-\code{\link[=everywhere]{everywhere()}} successively without at least one \code{\link[=mirai]{mirai()}} call in between,
-as an ordinary mirai call is required to exit each synchronization point.
+daemons prior to subsequent evaluations taking place.
+
+It is an error to call \code{\link[=everywhere]{everywhere()}} successively without at least one
+\code{\link[=mirai]{mirai()}} call in between, as an ordinary mirai call is required to exit each
+synchronization point.
 }
 \section{Evaluation}{
 
@@ -67,16 +69,16 @@ being found.
 daemons(1)
 # export common data by a super-assignment expression:
 everywhere(y <<- 3)
+mirai(y)[]
 # '...' variables are assigned to the global environment
 # '.expr' may be specified as an empty {} in such cases:
 everywhere({}, a = 1, b = 2)
-m <- mirai(a + b - y == 0L)
-m[]
-# everywhere() returns a list of mirai which may be waited for and inspected
-mlist <- everywhere("just a normal operation")
-collect_mirai(mlist)
-mlist <- everywhere(stop("error"))
-collect_mirai(mlist)
+mirai(a + b - y == 0L)[]
+
+# everywhere() returns a mirai_map object:
+mp <- everywhere("just a normal operation")
+mp
+mp[]
 daemons(0)
 
 # loading a package on all daemons
