Upload 77 files

.gitattributes

@@ -57,3 +57,5 @@ www/Roboto-Bold.ttf filter=lfs diff=lfs merge=lfs -text
 www/Roboto-Light.ttf filter=lfs diff=lfs merge=lfs -text
 www/Roboto-Medium.ttf filter=lfs diff=lfs merge=lfs -text
 www/Roboto-Regular.ttf filter=lfs diff=lfs merge=lfs -text
+renv/library/windows/R-4.5/x86_64-w64-mingw32/renv/help/renv.rdb filter=lfs diff=lfs merge=lfs -text
+renv/library/windows/R-4.5/x86_64-w64-mingw32/renv/R/renv.rdb filter=lfs diff=lfs merge=lfs -text

renv/.gitignore

@@ -0,0 +1,7 @@
+library/
+local/
+cellar/
+lock/
+python/
+sandbox/
+staging/

renv/activate.R

@@ -0,0 +1,1334 @@
+
+local({
+
+  # the requested version of renv
+  version <- "1.1.5"
+  attr(version, "sha") <- NULL
+
+  # the project directory
+  project <- Sys.getenv("RENV_PROJECT")
+  if (!nzchar(project))
+    project <- getwd()
+
+  # use start-up diagnostics if enabled
+  diagnostics <- Sys.getenv("RENV_STARTUP_DIAGNOSTICS", unset = "FALSE")
+  if (diagnostics) {
+    start <- Sys.time()
+    profile <- tempfile("renv-startup-", fileext = ".Rprof")
+    utils::Rprof(profile)
+    on.exit({
+      utils::Rprof(NULL)
+      elapsed <- signif(difftime(Sys.time(), start, units = "auto"), digits = 2L)
+      writeLines(sprintf("- renv took %s to run the autoloader.", format(elapsed)))
+      writeLines(sprintf("- Profile: %s", profile))
+      print(utils::summaryRprof(profile))
+    }, add = TRUE)
+  }
+
+  # figure out whether the autoloader is enabled
+  enabled <- local({
+
+    # first, check config option
+    override <- getOption("renv.config.autoloader.enabled")
+    if (!is.null(override))
+      return(override)
+
+    # if we're being run in a context where R_LIBS is already set,
+    # don't load -- presumably we're being run as a sub-process and
+    # the parent process has already set up library paths for us
+    rcmd <- Sys.getenv("R_CMD", unset = NA)
+    rlibs <- Sys.getenv("R_LIBS", unset = NA)
+    if (!is.na(rlibs) && !is.na(rcmd))
+      return(FALSE)
+
+    # next, check environment variables
+    # prefer using the configuration one in the future
+    envvars <- c(
+      "RENV_CONFIG_AUTOLOADER_ENABLED",
+      "RENV_AUTOLOADER_ENABLED",
+      "RENV_ACTIVATE_PROJECT"
+    )
+
+    for (envvar in envvars) {
+      envval <- Sys.getenv(envvar, unset = NA)
+      if (!is.na(envval))
+        return(tolower(envval) %in% c("true", "t", "1"))
+    }
+
+    # enable by default
+    TRUE
+
+  })
+
+  # bail if we're not enabled
+  if (!enabled) {
+
+    # if we're not enabled, we might still need to manually load
+    # the user profile here
+    profile <- Sys.getenv("R_PROFILE_USER", unset = "~/.Rprofile")
+    if (file.exists(profile)) {
+      cfg <- Sys.getenv("RENV_CONFIG_USER_PROFILE", unset = "TRUE")
+      if (tolower(cfg) %in% c("true", "t", "1"))
+        sys.source(profile, envir = globalenv())
+    }
+
+    return(FALSE)
+
+  }
+
+  # avoid recursion
+  if (identical(getOption("renv.autoloader.running"), TRUE)) {
+    warning("ignoring recursive attempt to run renv autoloader")
+    return(invisible(TRUE))
+  }
+
+  # signal that we're loading renv during R startup
+  options(renv.autoloader.running = TRUE)
+  on.exit(options(renv.autoloader.running = NULL), add = TRUE)
+
+  # signal that we've consented to use renv
+  options(renv.consent = TRUE)
+
+  # load the 'utils' package eagerly -- this ensures that renv shims, which
+  # mask 'utils' packages, will come first on the search path
+  library(utils, lib.loc = .Library)
+
+  # unload renv if it's already been loaded
+  if ("renv" %in% loadedNamespaces())
+    unloadNamespace("renv")
+
+  # load bootstrap tools   
+  ansify <- function(text) {
+    if (renv_ansify_enabled())
+      renv_ansify_enhanced(text)
+    else
+      renv_ansify_default(text)
+  }
+  
+  renv_ansify_enabled <- function() {
+  
+    override <- Sys.getenv("RENV_ANSIFY_ENABLED", unset = NA)
+    if (!is.na(override))
+      return(as.logical(override))
+  
+    pane <- Sys.getenv("RSTUDIO_CHILD_PROCESS_PANE", unset = NA)
+    if (identical(pane, "build"))
+      return(FALSE)
+  
+    testthat <- Sys.getenv("TESTTHAT", unset = "false")
+    if (tolower(testthat) %in% "true")
+      return(FALSE)
+  
+    iderun <- Sys.getenv("R_CLI_HAS_HYPERLINK_IDE_RUN", unset = "false")
+    if (tolower(iderun) %in% "false")
+      return(FALSE)
+  
+    TRUE
+  
+  }
+  
+  renv_ansify_default <- function(text) {
+    text
+  }
+  
+  renv_ansify_enhanced <- function(text) {
+  
+    # R help links
+    pattern <- "`\\?(renv::(?:[^`])+)`"
+    replacement <- "`\033]8;;x-r-help:\\1\a?\\1\033]8;;\a`"
+    text <- gsub(pattern, replacement, text, perl = TRUE)
+  
+    # runnable code
+    pattern <- "`(renv::(?:[^`])+)`"
+    replacement <- "`\033]8;;x-r-run:\\1\a\\1\033]8;;\a`"
+    text <- gsub(pattern, replacement, text, perl = TRUE)
+  
+    # return ansified text
+    text
+  
+  }
+  
+  renv_ansify_init <- function() {
+  
+    envir <- renv_envir_self()
+    if (renv_ansify_enabled())
+      assign("ansify", renv_ansify_enhanced, envir = envir)
+    else
+      assign("ansify", renv_ansify_default, envir = envir)
+  
+  }
+  
+  `%||%` <- function(x, y) {
+    if (is.null(x)) y else x
+  }
+  
+  catf <- function(fmt, ..., appendLF = TRUE) {
+  
+    quiet <- getOption("renv.bootstrap.quiet", default = FALSE)
+    if (quiet)
+      return(invisible())
+  
+    msg <- sprintf(fmt, ...)
+    cat(msg, file = stdout(), sep = if (appendLF) "\n" else "")
+  
+    invisible(msg)
+  
+  }
+  
+  header <- function(label,
+                     ...,
+                     prefix = "#",
+                     suffix = "-",
+                     n = min(getOption("width"), 78))
+  {
+    label <- sprintf(label, ...)
+    n <- max(n - nchar(label) - nchar(prefix) - 2L, 8L)
+    if (n <= 0)
+      return(paste(prefix, label))
+  
+    tail <- paste(rep.int(suffix, n), collapse = "")
+    paste0(prefix, " ", label, " ", tail)
+  
+  }
+  
+  heredoc <- function(text, leave = 0) {
+  
+    # remove leading, trailing whitespace
+    trimmed <- gsub("^\\s*\\n|\\n\\s*$", "", text)
+  
+    # split into lines
+    lines <- strsplit(trimmed, "\n", fixed = TRUE)[[1L]]
+  
+    # compute common indent
+    indent <- regexpr("[^[:space:]]", lines)
+    common <- min(setdiff(indent, -1L)) - leave
+    text <- paste(substring(lines, common), collapse = "\n")
+  
+    # substitute in ANSI links for executable renv code
+    ansify(text)
+  
+  }
+  
+  bootstrap <- function(version, library) {
+  
+    friendly <- renv_bootstrap_version_friendly(version)
+    section <- header(sprintf("Bootstrapping renv %s", friendly))
+    catf(section)
+  
+    # attempt to download renv
+    catf("- Downloading renv ... ", appendLF = FALSE)
+    withCallingHandlers(
+      tarball <- renv_bootstrap_download(version),
+      error = function(err) {
+        catf("FAILED")
+        stop("failed to download:\n", conditionMessage(err))
+      }
+    )
+    catf("OK")
+    on.exit(unlink(tarball), add = TRUE)
+  
+    # now attempt to install
+    catf("- Installing renv  ... ", appendLF = FALSE)
+    withCallingHandlers(
+      status <- renv_bootstrap_install(version, tarball, library),
+      error = function(err) {
+        catf("FAILED")
+        stop("failed to install:\n", conditionMessage(err))
+      }
+    )
+    catf("OK")
+  
+    # add empty line to break up bootstrapping from normal output
+    catf("")
+  
+    return(invisible())
+  }
+  
+  renv_bootstrap_tests_running <- function() {
+    getOption("renv.tests.running", default = FALSE)
+  }
+  
+  renv_bootstrap_repos <- function() {
+  
+    # get CRAN repository
+    cran <- getOption("renv.repos.cran", "https://cloud.r-project.org")
+  
+    # check for repos override
+    repos <- Sys.getenv("RENV_CONFIG_REPOS_OVERRIDE", unset = NA)
+    if (!is.na(repos)) {
+  
+      # check for RSPM; if set, use a fallback repository for renv
+      rspm <- Sys.getenv("RSPM", unset = NA)
+      if (identical(rspm, repos))
+        repos <- c(RSPM = rspm, CRAN = cran)
+  
+      return(repos)
+  
+    }
+  
+    # check for lockfile repositories
+    repos <- tryCatch(renv_bootstrap_repos_lockfile(), error = identity)
+    if (!inherits(repos, "error") && length(repos))
+      return(repos)
+  
+    # retrieve current repos
+    repos <- getOption("repos")
+  
+    # ensure @CRAN@ entries are resolved
+    repos[repos == "@CRAN@"] <- cran
+  
+    # add in renv.bootstrap.repos if set
+    default <- c(FALLBACK = "https://cloud.r-project.org")
+    extra <- getOption("renv.bootstrap.repos", default = default)
+    repos <- c(repos, extra)
+  
+    # remove duplicates that might've snuck in
+    dupes <- duplicated(repos) | duplicated(names(repos))
+    repos[!dupes]
+  
+  }
+  
+  renv_bootstrap_repos_lockfile <- function() {
+  
+    lockpath <- Sys.getenv("RENV_PATHS_LOCKFILE", unset = "renv.lock")
+    if (!file.exists(lockpath))
+      return(NULL)
+  
+    lockfile <- tryCatch(renv_json_read(lockpath), error = identity)
+    if (inherits(lockfile, "error")) {
+      warning(lockfile)
+      return(NULL)
+    }
+  
+    repos <- lockfile$R$Repositories
+    if (length(repos) == 0)
+      return(NULL)
+  
+    keys <- vapply(repos, `[[`, "Name", FUN.VALUE = character(1))
+    vals <- vapply(repos, `[[`, "URL", FUN.VALUE = character(1))
+    names(vals) <- keys
+  
+    return(vals)
+  
+  }
+  
+  renv_bootstrap_download <- function(version) {
+  
+    sha <- attr(version, "sha", exact = TRUE)
+  
+    methods <- if (!is.null(sha)) {
+  
+      # attempting to bootstrap a development version of renv
+      c(
+        function() renv_bootstrap_download_tarball(sha),
+        function() renv_bootstrap_download_github(sha)
+      )
+  
+    } else {
+  
+      # attempting to bootstrap a release version of renv
+      c(
+        function() renv_bootstrap_download_tarball(version),
+        function() renv_bootstrap_download_cran_latest(version),
+        function() renv_bootstrap_download_cran_archive(version)
+      )
+  
+    }
+  
+    for (method in methods) {
+      path <- tryCatch(method(), error = identity)
+      if (is.character(path) && file.exists(path))
+        return(path)
+    }
+  
+    stop("All download methods failed")
+  
+  }
+  
+  renv_bootstrap_download_impl <- function(url, destfile) {
+  
+    mode <- "wb"
+  
+    # https://bugs.r-project.org/bugzilla/show_bug.cgi?id=17715
+    fixup <-
+      Sys.info()[["sysname"]] == "Windows" &&
+      substring(url, 1L, 5L) == "file:"
+  
+    if (fixup)
+      mode <- "w+b"
+  
+    args <- list(
+      url      = url,
+      destfile = destfile,
+      mode     = mode,
+      quiet    = TRUE
+    )
+  
+    if ("headers" %in% names(formals(utils::download.file))) {
+      headers <- renv_bootstrap_download_custom_headers(url)
+      if (length(headers) && is.character(headers))
+        args$headers <- headers
+    }
+  
+    do.call(utils::download.file, args)
+  
+  }
+  
+  renv_bootstrap_download_custom_headers <- function(url) {
+  
+    headers <- getOption("renv.download.headers")
+    if (is.null(headers))
+      return(character())
+  
+    if (!is.function(headers))
+      stopf("'renv.download.headers' is not a function")
+  
+    headers <- headers(url)
+    if (length(headers) == 0L)
+      return(character())
+  
+    if (is.list(headers))
+      headers <- unlist(headers, recursive = FALSE, use.names = TRUE)
+  
+    ok <-
+      is.character(headers) &&
+      is.character(names(headers)) &&
+      all(nzchar(names(headers)))
+  
+    if (!ok)
+      stop("invocation of 'renv.download.headers' did not return a named character vector")
+  
+    headers
+  
+  }
+  
+  renv_bootstrap_download_cran_latest <- function(version) {
+  
+    spec <- renv_bootstrap_download_cran_latest_find(version)
+    type  <- spec$type
+    repos <- spec$repos
+  
+    baseurl <- utils::contrib.url(repos = repos, type = type)
+    ext <- if (identical(type, "source"))
+      ".tar.gz"
+    else if (Sys.info()[["sysname"]] == "Windows")
+      ".zip"
+    else
+      ".tgz"
+    name <- sprintf("renv_%s%s", version, ext)
+    url <- paste(baseurl, name, sep = "/")
+  
+    destfile <- file.path(tempdir(), name)
+    status <- tryCatch(
+      renv_bootstrap_download_impl(url, destfile),
+      condition = identity
+    )
+  
+    if (inherits(status, "condition"))
+      return(FALSE)
+  
+    # report success and return
+    destfile
+  
+  }
+  
+  renv_bootstrap_download_cran_latest_find <- function(version) {
+  
+    # check whether binaries are supported on this system
+    binary <-
+      getOption("renv.bootstrap.binary", default = TRUE) &&
+      !identical(.Platform$pkgType, "source") &&
+      !identical(getOption("pkgType"), "source") &&
+      Sys.info()[["sysname"]] %in% c("Darwin", "Windows")
+  
+    types <- c(if (binary) "binary", "source")
+  
+    # iterate over types + repositories
+    for (type in types) {
+      for (repos in renv_bootstrap_repos()) {
+  
+        # build arguments for utils::available.packages() call
+        args <- list(type = type, repos = repos)
+  
+        # add custom headers if available -- note that
+        # utils::available.packages() will pass this to download.file()
+        if ("headers" %in% names(formals(utils::download.file))) {
+          headers <- renv_bootstrap_download_custom_headers(repos)
+          if (length(headers) && is.character(headers))
+            args$headers <- headers
+        }
+  
+        # retrieve package database
+        db <- tryCatch(
+          as.data.frame(
+            do.call(utils::available.packages, args),
+            stringsAsFactors = FALSE
+          ),
+          error = identity
+        )
+  
+        if (inherits(db, "error"))
+          next
+  
+        # check for compatible entry
+        entry <- db[db$Package %in% "renv" & db$Version %in% version, ]
+        if (nrow(entry) == 0)
+          next
+  
+        # found it; return spec to caller
+        spec <- list(entry = entry, type = type, repos = repos)
+        return(spec)
+  
+      }
+    }
+  
+    # if we got here, we failed to find renv
+    fmt <- "renv %s is not available from your declared package repositories"
+    stop(sprintf(fmt, version))
+  
+  }
+  
+  renv_bootstrap_download_cran_archive <- function(version) {
+  
+    name <- sprintf("renv_%s.tar.gz", version)
+    repos <- renv_bootstrap_repos()
+    urls <- file.path(repos, "src/contrib/Archive/renv", name)
+    destfile <- file.path(tempdir(), name)
+  
+    for (url in urls) {
+  
+      status <- tryCatch(
+        renv_bootstrap_download_impl(url, destfile),
+        condition = identity
+      )
+  
+      if (identical(status, 0L))
+        return(destfile)
+  
+    }
+  
+    return(FALSE)
+  
+  }
+  
+  renv_bootstrap_download_tarball <- function(version) {
+  
+    # if the user has provided the path to a tarball via
+    # an environment variable, then use it
+    tarball <- Sys.getenv("RENV_BOOTSTRAP_TARBALL", unset = NA)
+    if (is.na(tarball))
+      return()
+  
+    # allow directories
+    if (dir.exists(tarball)) {
+      name <- sprintf("renv_%s.tar.gz", version)
+      tarball <- file.path(tarball, name)
+    }
+  
+    # bail if it doesn't exist
+    if (!file.exists(tarball)) {
+  
+      # let the user know we weren't able to honour their request
+      fmt <- "- RENV_BOOTSTRAP_TARBALL is set (%s) but does not exist."
+      msg <- sprintf(fmt, tarball)
+      warning(msg)
+  
+      # bail
+      return()
+  
+    }
+  
+    catf("- Using local tarball '%s'.", tarball)
+    tarball
+  
+  }
+  
+  renv_bootstrap_github_token <- function() {
+    for (envvar in c("GITHUB_TOKEN", "GITHUB_PAT", "GH_TOKEN")) {
+      envval <- Sys.getenv(envvar, unset = NA)
+      if (!is.na(envval))
+        return(envval)
+    }
+  }
+  
+  renv_bootstrap_download_github <- function(version) {
+  
+    enabled <- Sys.getenv("RENV_BOOTSTRAP_FROM_GITHUB", unset = "TRUE")
+    if (!identical(enabled, "TRUE"))
+      return(FALSE)
+  
+    # prepare download options
+    token <- renv_bootstrap_github_token()
+    if (is.null(token))
+      token <- ""
+  
+    if (nzchar(Sys.which("curl")) && nzchar(token)) {
+      fmt <- "--location --fail --header \"Authorization: token %s\""
+      extra <- sprintf(fmt, token)
+      saved <- options("download.file.method", "download.file.extra")
+      options(download.file.method = "curl", download.file.extra = extra)
+      on.exit(do.call(base::options, saved), add = TRUE)
+    } else if (nzchar(Sys.which("wget")) && nzchar(token)) {
+      fmt <- "--header=\"Authorization: token %s\""
+      extra <- sprintf(fmt, token)
+      saved <- options("download.file.method", "download.file.extra")
+      options(download.file.method = "wget", download.file.extra = extra)
+      on.exit(do.call(base::options, saved), add = TRUE)
+    }
+  
+    url <- file.path("https://api.github.com/repos/rstudio/renv/tarball", version)
+    name <- sprintf("renv_%s.tar.gz", version)
+    destfile <- file.path(tempdir(), name)
+  
+    status <- tryCatch(
+      renv_bootstrap_download_impl(url, destfile),
+      condition = identity
+    )
+  
+    if (!identical(status, 0L))
+      return(FALSE)
+  
+    renv_bootstrap_download_augment(destfile)
+  
+    return(destfile)
+  
+  }
+  
+  # Add Sha to DESCRIPTION. This is stop gap until #890, after which we
+  # can use renv::install() to fully capture metadata.
+  renv_bootstrap_download_augment <- function(destfile) {
+    sha <- renv_bootstrap_git_extract_sha1_tar(destfile)
+    if (is.null(sha)) {
+      return()
+    }
+  
+    # Untar
+    tempdir <- tempfile("renv-github-")
+    on.exit(unlink(tempdir, recursive = TRUE), add = TRUE)
+    untar(destfile, exdir = tempdir)
+    pkgdir <- dir(tempdir, full.names = TRUE)[[1]]
+  
+    # Modify description
+    desc_path <- file.path(pkgdir, "DESCRIPTION")
+    desc_lines <- readLines(desc_path)
+    remotes_fields <- c(
+      "RemoteType: github",
+      "RemoteHost: api.github.com",
+      "RemoteRepo: renv",
+      "RemoteUsername: rstudio",
+      "RemotePkgRef: rstudio/renv",
+      paste("RemoteRef: ", sha),
+      paste("RemoteSha: ", sha)
+    )
+    writeLines(c(desc_lines[desc_lines != ""], remotes_fields), con = desc_path)
+  
+    # Re-tar
+    local({
+      old <- setwd(tempdir)
+      on.exit(setwd(old), add = TRUE)
+  
+      tar(destfile, compression = "gzip")
+    })
+    invisible()
+  }
+  
+  # Extract the commit hash from a git archive. Git archives include the SHA1
+  # hash as the comment field of the tarball pax extended header
+  # (see https://www.kernel.org/pub/software/scm/git/docs/git-archive.html)
+  # For GitHub archives this should be the first header after the default one
+  # (512 byte) header.
+  renv_bootstrap_git_extract_sha1_tar <- function(bundle) {
+  
+    # open the bundle for reading
+    # We use gzcon for everything because (from ?gzcon)
+    # > Reading from a connection which does not supply a 'gzip' magic
+    # > header is equivalent to reading from the original connection
+    conn <- gzcon(file(bundle, open = "rb", raw = TRUE))
+    on.exit(close(conn))
+  
+    # The default pax header is 512 bytes long and the first pax extended header
+    # with the comment should be 51 bytes long
+    # `52 comment=` (11 chars) + 40 byte SHA1 hash
+    len <- 0x200 + 0x33
+    res <- rawToChar(readBin(conn, "raw", n = len)[0x201:len])
+  
+    if (grepl("^52 comment=", res)) {
+      sub("52 comment=", "", res)
+    } else {
+      NULL
+    }
+  }
+  
+  renv_bootstrap_install <- function(version, tarball, library) {
+  
+    # attempt to install it into project library
+    dir.create(library, showWarnings = FALSE, recursive = TRUE)
+    output <- renv_bootstrap_install_impl(library, tarball)
+  
+    # check for successful install
+    status <- attr(output, "status")
+    if (is.null(status) || identical(status, 0L))
+      return(status)
+  
+    # an error occurred; report it
+    header <- "installation of renv failed"
+    lines <- paste(rep.int("=", nchar(header)), collapse = "")
+    text <- paste(c(header, lines, output), collapse = "\n")
+    stop(text)
+  
+  }
+  
+  renv_bootstrap_install_impl <- function(library, tarball) {
+  
+    # invoke using system2 so we can capture and report output
+    bin <- R.home("bin")
+    exe <- if (Sys.info()[["sysname"]] == "Windows") "R.exe" else "R"
+    R <- file.path(bin, exe)
+  
+    args <- c(
+      "--vanilla", "CMD", "INSTALL", "--no-multiarch",
+      "-l", shQuote(path.expand(library)),
+      shQuote(path.expand(tarball))
+    )
+  
+    system2(R, args, stdout = TRUE, stderr = TRUE)
+  
+  }
+  
+  renv_bootstrap_platform_prefix_default <- function() {
+  
+    # read version component
+    version <- Sys.getenv("RENV_PATHS_VERSION", unset = "R-%v")
+  
+    # expand placeholders
+    placeholders <- list(
+      list("%v", format(getRversion()[1, 1:2])),
+      list("%V", format(getRversion()[1, 1:3]))
+    )
+  
+    for (placeholder in placeholders)
+      version <- gsub(placeholder[[1L]], placeholder[[2L]], version, fixed = TRUE)
+  
+    # include SVN revision for development versions of R
+    # (to avoid sharing platform-specific artefacts with released versions of R)
+    devel <-
+      identical(R.version[["status"]],   "Under development (unstable)") ||
+      identical(R.version[["nickname"]], "Unsuffered Consequences")
+  
+    if (devel)
+      version <- paste(version, R.version[["svn rev"]], sep = "-r")
+  
+    version
+  
+  }
+  
+  renv_bootstrap_platform_prefix <- function() {
+  
+    # construct version prefix
+    version <- renv_bootstrap_platform_prefix_default()
+  
+    # build list of path components
+    components <- c(version, R.version$platform)
+  
+    # include prefix if provided by user
+    prefix <- renv_bootstrap_platform_prefix_impl()
+    if (!is.na(prefix) && nzchar(prefix))
+      components <- c(prefix, components)
+  
+    # build prefix
+    paste(components, collapse = "/")
+  
+  }
+  
+  renv_bootstrap_platform_prefix_impl <- function() {
+  
+    # if an explicit prefix has been supplied, use it
+    prefix <- Sys.getenv("RENV_PATHS_PREFIX", unset = NA)
+    if (!is.na(prefix))
+      return(prefix)
+  
+    # if the user has requested an automatic prefix, generate it
+    auto <- Sys.getenv("RENV_PATHS_PREFIX_AUTO", unset = NA)
+    if (is.na(auto) && getRversion() >= "4.4.0")
+      auto <- "TRUE"
+  
+    if (auto %in% c("TRUE", "True", "true", "1"))
+      return(renv_bootstrap_platform_prefix_auto())
+  
+    # empty string on failure
+    ""
+  
+  }
+  
+  renv_bootstrap_platform_prefix_auto <- function() {
+  
+    prefix <- tryCatch(renv_bootstrap_platform_os(), error = identity)
+    if (inherits(prefix, "error") || prefix %in% "unknown") {
+  
+      msg <- paste(
+        "failed to infer current operating system",
+        "please file a bug report at https://github.com/rstudio/renv/issues",
+        sep = "; "
+      )
+  
+      warning(msg)
+  
+    }
+  
+    prefix
+  
+  }
+  
+  renv_bootstrap_platform_os <- function() {
+  
+    sysinfo <- Sys.info()
+    sysname <- sysinfo[["sysname"]]
+  
+    # handle Windows + macOS up front
+    if (sysname == "Windows")
+      return("windows")
+    else if (sysname == "Darwin")
+      return("macos")
+  
+    # check for os-release files
+    for (file in c("/etc/os-release", "/usr/lib/os-release"))
+      if (file.exists(file))
+        return(renv_bootstrap_platform_os_via_os_release(file, sysinfo))
+  
+    # check for redhat-release files
+    if (file.exists("/etc/redhat-release"))
+      return(renv_bootstrap_platform_os_via_redhat_release())
+  
+    "unknown"
+  
+  }
+  
+  renv_bootstrap_platform_os_via_os_release <- function(file, sysinfo) {
+  
+    # read /etc/os-release
+    release <- utils::read.table(
+      file             = file,
+      sep              = "=",
+      quote            = c("\"", "'"),
+      col.names        = c("Key", "Value"),
+      comment.char     = "#",
+      stringsAsFactors = FALSE
+    )
+  
+    vars <- as.list(release$Value)
+    names(vars) <- release$Key
+  
+    # get os name
+    os <- tolower(sysinfo[["sysname"]])
+  
+    # read id
+    id <- "unknown"
+    for (field in c("ID", "ID_LIKE")) {
+      if (field %in% names(vars) && nzchar(vars[[field]])) {
+        id <- vars[[field]]
+        break
+      }
+    }
+  
+    # read version
+    version <- "unknown"
+    for (field in c("UBUNTU_CODENAME", "VERSION_CODENAME", "VERSION_ID", "BUILD_ID")) {
+      if (field %in% names(vars) && nzchar(vars[[field]])) {
+        version <- vars[[field]]
+        break
+      }
+    }
+  
+    # join together
+    paste(c(os, id, version), collapse = "-")
+  
+  }
+  
+  renv_bootstrap_platform_os_via_redhat_release <- function() {
+  
+    # read /etc/redhat-release
+    contents <- readLines("/etc/redhat-release", warn = FALSE)
+  
+    # infer id
+    id <- if (grepl("centos", contents, ignore.case = TRUE))
+      "centos"
+    else if (grepl("redhat", contents, ignore.case = TRUE))
+      "redhat"
+    else
+      "unknown"
+  
+    # try to find a version component (very hacky)
+    version <- "unknown"
+  
+    parts <- strsplit(contents, "[[:space:]]")[[1L]]
+    for (part in parts) {
+  
+      nv <- tryCatch(numeric_version(part), error = identity)
+      if (inherits(nv, "error"))
+        next
+  
+      version <- nv[1, 1]
+      break
+  
+    }
+  
+    paste(c("linux", id, version), collapse = "-")
+  
+  }
+  
+  renv_bootstrap_library_root_name <- function(project) {
+  
+    # use project name as-is if requested
+    asis <- Sys.getenv("RENV_PATHS_LIBRARY_ROOT_ASIS", unset = "FALSE")
+    if (asis)
+      return(basename(project))
+  
+    # otherwise, disambiguate based on project's path
+    id <- substring(renv_bootstrap_hash_text(project), 1L, 8L)
+    paste(basename(project), id, sep = "-")
+  
+  }
+  
+  renv_bootstrap_library_root <- function(project) {
+  
+    prefix <- renv_bootstrap_profile_prefix()
+  
+    path <- Sys.getenv("RENV_PATHS_LIBRARY", unset = NA)
+    if (!is.na(path))
+      return(paste(c(path, prefix), collapse = "/"))
+  
+    path <- renv_bootstrap_library_root_impl(project)
+    if (!is.null(path)) {
+      name <- renv_bootstrap_library_root_name(project)
+      return(paste(c(path, prefix, name), collapse = "/"))
+    }
+  
+    renv_bootstrap_paths_renv("library", project = project)
+  
+  }
+  
+  renv_bootstrap_library_root_impl <- function(project) {
+  
+    root <- Sys.getenv("RENV_PATHS_LIBRARY_ROOT", unset = NA)
+    if (!is.na(root))
+      return(root)
+  
+    type <- renv_bootstrap_project_type(project)
+    if (identical(type, "package")) {
+      userdir <- renv_bootstrap_user_dir()
+      return(file.path(userdir, "library"))
+    }
+  
+  }
+  
+  renv_bootstrap_validate_version <- function(version, description = NULL) {
+  
+    # resolve description file
+    #
+    # avoid passing lib.loc to `packageDescription()` below, since R will
+    # use the loaded version of the package by default anyhow. note that
+    # this function should only be called after 'renv' is loaded
+    # https://github.com/rstudio/renv/issues/1625
+    description <- description %||% packageDescription("renv")
+  
+    # check whether requested version 'version' matches loaded version of renv
+    sha <- attr(version, "sha", exact = TRUE)
+    valid <- if (!is.null(sha))
+      renv_bootstrap_validate_version_dev(sha, description)
+    else
+      renv_bootstrap_validate_version_release(version, description)
+  
+    if (valid)
+      return(TRUE)
+  
+    # the loaded version of renv doesn't match the requested version;
+    # give the user instructions on how to proceed
+    dev <- identical(description[["RemoteType"]], "github")
+    remote <- if (dev)
+      paste("rstudio/renv", description[["RemoteSha"]], sep = "@")
+    else
+      paste("renv", description[["Version"]], sep = "@")
+  
+    # display both loaded version + sha if available
+    friendly <- renv_bootstrap_version_friendly(
+      version = description[["Version"]],
+      sha     = if (dev) description[["RemoteSha"]]
+    )
+  
+    fmt <- heredoc("
+      renv %1$s was loaded from project library, but this project is configured to use renv %2$s.
+      - Use `renv::record(\"%3$s\")` to record renv %1$s in the lockfile.
+      - Use `renv::restore(packages = \"renv\")` to install renv %2$s into the project library.
+    ")
+    catf(fmt, friendly, renv_bootstrap_version_friendly(version), remote)
+  
+    FALSE
+  
+  }
+  
+  renv_bootstrap_validate_version_dev <- function(version, description) {
+  
+    expected <- description[["RemoteSha"]]
+    if (!is.character(expected))
+      return(FALSE)
+  
+    pattern <- sprintf("^\\Q%s\\E", version)
+    grepl(pattern, expected, perl = TRUE)
+  
+  }
+  
+  renv_bootstrap_validate_version_release <- function(version, description) {
+    expected <- description[["Version"]]
+    is.character(expected) && identical(expected, version)
+  }
+  
+  renv_bootstrap_hash_text <- function(text) {
+  
+    hashfile <- tempfile("renv-hash-")
+    on.exit(unlink(hashfile), add = TRUE)
+  
+    writeLines(text, con = hashfile)
+    tools::md5sum(hashfile)
+  
+  }
+  
+  renv_bootstrap_load <- function(project, libpath, version) {
+  
+    # try to load renv from the project library
+    if (!requireNamespace("renv", lib.loc = libpath, quietly = TRUE))
+      return(FALSE)
+  
+    # warn if the version of renv loaded does not match
+    renv_bootstrap_validate_version(version)
+  
+    # execute renv load hooks, if any
+    hooks <- getHook("renv::autoload")
+    for (hook in hooks)
+      if (is.function(hook))
+        tryCatch(hook(), error = warnify)
+  
+    # load the project
+    renv::load(project)
+  
+    TRUE
+  
+  }
+  
+  renv_bootstrap_profile_load <- function(project) {
+  
+    # if RENV_PROFILE is already set, just use that
+    profile <- Sys.getenv("RENV_PROFILE", unset = NA)
+    if (!is.na(profile) && nzchar(profile))
+      return(profile)
+  
+    # check for a profile file (nothing to do if it doesn't exist)
+    path <- renv_bootstrap_paths_renv("profile", profile = FALSE, project = project)
+    if (!file.exists(path))
+      return(NULL)
+  
+    # read the profile, and set it if it exists
+    contents <- readLines(path, warn = FALSE)
+    if (length(contents) == 0L)
+      return(NULL)
+  
+    # set RENV_PROFILE
+    profile <- contents[[1L]]
+    if (!profile %in% c("", "default"))
+      Sys.setenv(RENV_PROFILE = profile)
+  
+    profile
+  
+  }
+  
+  renv_bootstrap_profile_prefix <- function() {
+    profile <- renv_bootstrap_profile_get()
+    if (!is.null(profile))
+      return(file.path("profiles", profile, "renv"))
+  }
+  
+  renv_bootstrap_profile_get <- function() {
+    profile <- Sys.getenv("RENV_PROFILE", unset = "")
+    renv_bootstrap_profile_normalize(profile)
+  }
+  
+  renv_bootstrap_profile_set <- function(profile) {
+    profile <- renv_bootstrap_profile_normalize(profile)
+    if (is.null(profile))
+      Sys.unsetenv("RENV_PROFILE")
+    else
+      Sys.setenv(RENV_PROFILE = profile)
+  }
+  
+  renv_bootstrap_profile_normalize <- function(profile) {
+  
+    if (is.null(profile) || profile %in% c("", "default"))
+      return(NULL)
+  
+    profile
+  
+  }
+  
+  renv_bootstrap_path_absolute <- function(path) {
+  
+    substr(path, 1L, 1L) %in% c("~", "/", "\\") || (
+      substr(path, 1L, 1L) %in% c(letters, LETTERS) &&
+      substr(path, 2L, 3L) %in% c(":/", ":\\")
+    )
+  
+  }
+  
+  renv_bootstrap_paths_renv <- function(..., profile = TRUE, project = NULL) {
+    renv <- Sys.getenv("RENV_PATHS_RENV", unset = "renv")
+    root <- if (renv_bootstrap_path_absolute(renv)) NULL else project
+    prefix <- if (profile) renv_bootstrap_profile_prefix()
+    components <- c(root, renv, prefix, ...)
+    paste(components, collapse = "/")
+  }
+  
+  renv_bootstrap_project_type <- function(path) {
+  
+    descpath <- file.path(path, "DESCRIPTION")
+    if (!file.exists(descpath))
+      return("unknown")
+  
+    desc <- tryCatch(
+      read.dcf(descpath, all = TRUE),
+      error = identity
+    )
+  
+    if (inherits(desc, "error"))
+      return("unknown")
+  
+    type <- desc$Type
+    if (!is.null(type))
+      return(tolower(type))
+  
+    package <- desc$Package
+    if (!is.null(package))
+      return("package")
+  
+    "unknown"
+  
+  }
+  
+  renv_bootstrap_user_dir <- function() {
+    dir <- renv_bootstrap_user_dir_impl()
+    path.expand(chartr("\\", "/", dir))
+  }
+  
+  renv_bootstrap_user_dir_impl <- function() {
+  
+    # use local override if set
+    override <- getOption("renv.userdir.override")
+    if (!is.null(override))
+      return(override)
+  
+    # use R_user_dir if available
+    tools <- asNamespace("tools")
+    if (is.function(tools$R_user_dir))
+      return(tools$R_user_dir("renv", "cache"))
+  
+    # try using our own backfill for older versions of R
+    envvars <- c("R_USER_CACHE_DIR", "XDG_CACHE_HOME")
+    for (envvar in envvars) {
+      root <- Sys.getenv(envvar, unset = NA)
+      if (!is.na(root))
+        return(file.path(root, "R/renv"))
+    }
+  
+    # use platform-specific default fallbacks
+    if (Sys.info()[["sysname"]] == "Windows")
+      file.path(Sys.getenv("LOCALAPPDATA"), "R/cache/R/renv")
+    else if (Sys.info()[["sysname"]] == "Darwin")
+      "~/Library/Caches/org.R-project.R/R/renv"
+    else
+      "~/.cache/R/renv"
+  
+  }
+  
+  renv_bootstrap_version_friendly <- function(version, shafmt = NULL, sha = NULL) {
+    sha <- sha %||% attr(version, "sha", exact = TRUE)
+    parts <- c(version, sprintf(shafmt %||% " [sha: %s]", substring(sha, 1L, 7L)))
+    paste(parts, collapse = "")
+  }
+  
+  renv_bootstrap_exec <- function(project, libpath, version) {
+    if (!renv_bootstrap_load(project, libpath, version))
+      renv_bootstrap_run(project, libpath, version)
+  }
+  
+  renv_bootstrap_run <- function(project, libpath, version) {
+  
+    # perform bootstrap
+    bootstrap(version, libpath)
+  
+    # exit early if we're just testing bootstrap
+    if (!is.na(Sys.getenv("RENV_BOOTSTRAP_INSTALL_ONLY", unset = NA)))
+      return(TRUE)
+  
+    # try again to load
+    if (requireNamespace("renv", lib.loc = libpath, quietly = TRUE)) {
+      return(renv::load(project = project))
+    }
+  
+    # failed to download or load renv; warn the user
+    msg <- c(
+      "Failed to find an renv installation: the project will not be loaded.",
+      "Use `renv::activate()` to re-initialize the project."
+    )
+  
+    warning(paste(msg, collapse = "\n"), call. = FALSE)
+  
+  }
+  
+  renv_json_read <- function(file = NULL, text = NULL) {
+  
+    jlerr <- NULL
+  
+    # if jsonlite is loaded, use that instead
+    if ("jsonlite" %in% loadedNamespaces()) {
+  
+      json <- tryCatch(renv_json_read_jsonlite(file, text), error = identity)
+      if (!inherits(json, "error"))
+        return(json)
+  
+      jlerr <- json
+  
+    }
+  
+    # otherwise, fall back to the default JSON reader
+    json <- tryCatch(renv_json_read_default(file, text), error = identity)
+    if (!inherits(json, "error"))
+      return(json)
+  
+    # report an error
+    if (!is.null(jlerr))
+      stop(jlerr)
+    else
+      stop(json)
+  
+  }
+  
+  renv_json_read_jsonlite <- function(file = NULL, text = NULL) {
+    text <- paste(text %||% readLines(file, warn = FALSE), collapse = "\n")
+    jsonlite::fromJSON(txt = text, simplifyVector = FALSE)
+  }
+  
+  renv_json_read_patterns <- function() {
+  
+    list(
+  
+      # objects
+      list("{", "\t\n\tobject(\t\n\t", TRUE),
+      list("}", "\t\n\t)\t\n\t",       TRUE),
+  
+      # arrays
+      list("[", "\t\n\tarray(\t\n\t", TRUE),
+      list("]", "\n\t\n)\n\t\n",      TRUE),
+  
+      # maps
+      list(":", "\t\n\t=\t\n\t", TRUE),
+  
+      # newlines
+      list("\\u000a", "\n", FALSE)
+  
+    )
+  
+  }
+  
+  renv_json_read_envir <- function() {
+  
+    envir <- new.env(parent = emptyenv())
+  
+    envir[["+"]] <- `+`
+    envir[["-"]] <- `-`
+  
+    envir[["object"]] <- function(...) {
+      result <- list(...)
+      names(result) <- as.character(names(result))
+      result
+    }
+  
+    envir[["array"]] <- list
+  
+    envir[["true"]]  <- TRUE
+    envir[["false"]] <- FALSE
+    envir[["null"]]  <- NULL
+  
+    envir
+  
+  }
+  
+  renv_json_read_remap <- function(object, patterns) {
+  
+    # repair names if necessary
+    if (!is.null(names(object))) {
+  
+      nms <- names(object)
+      for (pattern in patterns)
+        nms <- gsub(pattern[[2L]], pattern[[1L]], nms, fixed = TRUE)
+      names(object) <- nms
+  
+    }
+  
+    # repair strings if necessary
+    if (is.character(object)) {
+      for (pattern in patterns)
+        object <- gsub(pattern[[2L]], pattern[[1L]], object, fixed = TRUE)
+    }
+  
+    # recurse for other objects
+    if (is.recursive(object))
+      for (i in seq_along(object))
+        object[i] <- list(renv_json_read_remap(object[[i]], patterns))
+  
+    # return remapped object
+    object
+  
+  }
+  
+  renv_json_read_default <- function(file = NULL, text = NULL) {
+  
+    # read json text
+    text <- paste(text %||% readLines(file, warn = FALSE), collapse = "\n")
+  
+    # convert into something the R parser will understand
+    patterns <- renv_json_read_patterns()
+    transformed <- text
+    for (pattern in patterns)
+      transformed <- gsub(pattern[[1L]], pattern[[2L]], transformed, fixed = TRUE)
+  
+    # parse it
+    rfile <- tempfile("renv-json-", fileext = ".R")
+    on.exit(unlink(rfile), add = TRUE)
+    writeLines(transformed, con = rfile)
+    json <- parse(rfile, keep.source = FALSE, srcfile = NULL)[[1L]]
+  
+    # evaluate in safe environment
+    result <- eval(json, envir = renv_json_read_envir())
+  
+    # fix up strings if necessary -- do so only with reversible patterns
+    patterns <- Filter(function(pattern) pattern[[3L]], patterns)
+    renv_json_read_remap(result, patterns)
+  
+  }
+  
+
+  # load the renv profile, if any
+  renv_bootstrap_profile_load(project)
+
+  # construct path to library root
+  root <- renv_bootstrap_library_root(project)
+
+  # construct library prefix for platform
+  prefix <- renv_bootstrap_platform_prefix()
+
+  # construct full libpath
+  libpath <- file.path(root, prefix)
+
+  # run bootstrap code
+  renv_bootstrap_exec(project, libpath, version)
+
+  invisible()
+
+})

renv/library/windows/R-4.5/x86_64-w64-mingw32/renv/DESCRIPTION

@@ -0,0 +1,40 @@
+Package: renv
+Type: Package
+Title: Project Environments
+Version: 1.1.5
+Authors@R: c(
+    person("Kevin", "Ushey", role = c("aut", "cre"), email = "kevin@rstudio.com",
+           comment = c(ORCID = "0000-0003-2880-7407")),
+    person("Hadley", "Wickham", role = c("aut"), email = "hadley@rstudio.com",
+           comment = c(ORCID = "0000-0003-4757-117X")),
+    person("Posit Software, PBC", role = c("cph", "fnd"))
+    )
+Description: A dependency management toolkit for R. Using 'renv', you can create
+    and manage project-local R libraries, save the state of these libraries to
+    a 'lockfile', and later restore your library as required. Together, these
+    tools can help make your projects more isolated, portable, and reproducible.
+License: MIT + file LICENSE
+URL: https://rstudio.github.io/renv/, https://github.com/rstudio/renv
+BugReports: https://github.com/rstudio/renv/issues
+Imports: utils
+Suggests: BiocManager, cli, compiler, covr, cpp11, devtools, generics,
+        gitcreds, jsonlite, jsonvalidate, knitr, miniUI, modules,
+        packrat, pak, R6, remotes, reticulate, rmarkdown, rstudioapi,
+        shiny, testthat, uuid, waldo, yaml, webfakes
+Encoding: UTF-8
+RoxygenNote: 7.3.2
+VignetteBuilder: knitr
+Config/Needs/website: tidyverse/tidytemplate
+Config/testthat/edition: 3
+Config/testthat/parallel: true
+Config/testthat/start-first:
+        bioconductor,python,install,restore,snapshot,retrieve,remotes
+NeedsCompilation: no
+Packaged: 2025-07-24 20:47:34 UTC; kevin
+Author: Kevin Ushey [aut, cre] (ORCID: <https://orcid.org/0000-0003-2880-7407>),
+  Hadley Wickham [aut] (ORCID: <https://orcid.org/0000-0003-4757-117X>),
+  Posit Software, PBC [cph, fnd]
+Maintainer: Kevin Ushey <kevin@rstudio.com>
+Repository: CRAN
+Date/Publication: 2025-07-24 21:40:02 UTC
+Built: R 4.5.1; ; 2025-10-06 00:52:18 UTC; windows

renv/library/windows/R-4.5/x86_64-w64-mingw32/renv/INDEX

@@ -0,0 +1,44 @@
+activate                Activate or deactivate a project
+autoload                Auto-load the active project
+checkout                Checkout a repository
+clean                   Clean a project
+config                  User-level settings
+consent                 Consent to usage of renv
+dependencies            Find R package dependencies in a project
+diagnostics             Print a diagnostics report
+embed                   Capture and re-use dependencies within a '.R',
+                        '.Rmd' or '.qmd'
+history                 View and revert to a historical lockfile
+imbue                   Imbue an renv Installation
+init                    Use renv in a project
+install                 Install packages
+isolate                 Isolate a project
+load                    Load a project
+lockfiles               Lockfiles
+migrate                 Migrate a project from packrat to renv
+modify                  Modify a Lockfile
+paths                   Path for storing global state
+project                 Retrieve the active project
+purge                   Purge packages from the cache
+rebuild                 Rebuild the packages in your project library
+record                  Update package records in a lockfile
+refresh                 Refresh the local cache of available packages
+rehash                  Re-hash packages in the renv cache
+remote                  Resolve a Remote
+remove                  Remove packages
+renv-package            Project-local Environments for R
+repair                  Repair a project
+restore                 Restore project library from a lockfile
+retrieve                Retrieve packages
+run                     Run a script
+sandbox                 The default library sandbox
+scaffold                Generate project infrastructure
+settings                Project settings
+snapshot                Record current state of the project library in
+                        the lockfile
+status                  Report inconsistencies between lockfile,
+                        library, and dependencies
+sysreqs                 R System Requirements
+update                  Update packages
+upgrade                 Upgrade renv
+use_python              Use python

renv/library/windows/R-4.5/x86_64-w64-mingw32/renv/LICENSE

@@ -0,0 +1,2 @@
+YEAR: 2025
+COPYRIGHT HOLDER: Posit Software, PBC

renv/library/windows/R-4.5/x86_64-w64-mingw32/renv/MD5

@@ -0,0 +1,74 @@
+c5d8c489e2157d9d03ab32c719f8a6b2 *DESCRIPTION
+ffc7d98cd968589b4559299a1bec4a48 *INDEX
+0d37e729582c25a6fc726cf9f8763140 *LICENSE
+fc7fedf0bc60154d18f26e09da68ee4a *Meta/Rd.rds
+97f39cfa069205fc947ab1e51ea53d4e *Meta/features.rds
+5cf9daf20085ed2d641679940b048f66 *Meta/hsearch.rds
+698c2f9238cc8db0e9ead83db7e48d9b *Meta/links.rds
+19a8aedb20addf5e98236c305580383d *Meta/nsInfo.rds
+2809cf24689debb00c47a2bb9f37b9e8 *Meta/package.rds
+7fa855e9d63d009f3ddeb81d63f983d6 *Meta/vignette.rds
+9cd30053a51f82ef8e77b7f7a33786c2 *NAMESPACE
+337f9cc15b344eb4f51124af121f5d84 *NEWS.md
+d6c68f1fe41ced6e98a766a3757313da *R/renv
+373b7cab7b29d54a28c22e232f22bd5f *R/renv.rdb
+304080e5caadfc883c104f6dc66e0773 *R/renv.rdx
+bbd0f31a99032014b85ee7e57b604da8 *bin/renv
+64af3537ec68355c83d8c11a9edc5ace *bin/renv.bat
+ed79102f3bbeaa1db3cb59472a5d572c *config.yml
+25ee8dd0f95a8eb5c34ca2c95e0031c2 *doc/ci.R
+bbc0b57c605ca7bdd7f4ff461631f516 *doc/ci.Rmd
+e7b732d93a986d3f6a4f946748437285 *doc/ci.html
+25ee8dd0f95a8eb5c34ca2c95e0031c2 *doc/docker.R
+b0aeeb316287ab1a4b33fd39edb6f404 *doc/docker.Rmd
+32a3fa84767d0490d771704c02aea98a *doc/docker.html
+967388b8be33dc6690fd11f9ab123ede *doc/faq.R
+38216911fd5d56f14b213825b74e4c30 *doc/faq.Rmd
+13b3d8aee5765c66fac10b1098742f5a *doc/faq.html
+c2df4d32fa83979a769004aee71e2055 *doc/index.html
+ac80c906219e0881596ad649e10ca0e7 *doc/package-install.R
+4ca39246ce092e6750c2e169cd7d7415 *doc/package-install.Rmd
+55354cb2de7c6c7926bba33506894713 *doc/package-install.html
+8fad93585af2ca808bc5f0c5f4b9e48f *doc/package-sources.R
+252378a26c59438a315dfbf7c0323e86 *doc/package-sources.Rmd
+7e245342a719fc750d7e38928fd6a9ae *doc/package-sources.html
+cb0bb561a0c04947b860c100b28e4e62 *doc/packages.R
+8ee0f53c4ec62650ffddca39c642b11a *doc/packages.Rmd
+ddd3b400337284cf3c59fd77c9863913 *doc/packages.html
+35adc15da3c96ab90464927525185a3c *doc/packrat.R
+6c5c41c499a5b7df70d63f64772c9050 *doc/packrat.Rmd
+b31c489ea4a2e1e38ec1b7f91d44150e *doc/packrat.html
+958902b8cd108c353df2c6c41a6c7612 *doc/profiles.R
+6ca67b63922c88c4b46f78417d0c7d23 *doc/profiles.Rmd
+a2dec62988a7c04d7f64681cf806500a *doc/profiles.html
+25ee8dd0f95a8eb5c34ca2c95e0031c2 *doc/python.R
+44f57dfdaa4ed236deb9fdd4070a8e59 *doc/python.Rmd
+c9eeedc715edc6cd9d9dde296fd0d12e *doc/python.html
+6c5b1238e42fc8a2488ad73aa1cb7dfd *doc/renv.R
+d30e4c4f776341b6ff2648a496095bfb *doc/renv.Rmd
+ea39c9ac07269d67364c15a271b14aab *doc/renv.html
+25ee8dd0f95a8eb5c34ca2c95e0031c2 *doc/rsconnect.R
+ca8ebc764f16251d80cba7c1fed0f40d *doc/rsconnect.Rmd
+a9dd905639ed0b21e13e9dd490e6d94e *doc/rsconnect.html
+2ae06701f8059e053b6862920fcab4b9 *ext/renv.c
+66791df47f538fdc1dcf07d279bcc348 *help/AnIndex
+446b065bb406ef8a4724a989611c2797 *help/aliases.rds
+268d837fc485cdd1a80a48b8dcfde613 *help/figures/logo.svg
+23b98263e3e7d5f49c29297e8e6892ee *help/paths.rds
+8620256521337c665eed6e78e8e8f279 *help/renv.rdb
+f80c2b1a3a42bb25d854b9b1b6411fa5 *help/renv.rdx
+dd05677433fd5c706810facee5f3e5e3 *html/00Index.html
+8b9362669af13540a86a3ac6cf22f99d *html/R.css
+286fec9ce3625c787546337b633c330d *repos/src/contrib/PACKAGES
+a4559dbd631559c694552f82b51629b5 *repos/src/contrib/PACKAGES.gz
+82040a1a2e09e1d8378d2c668b146767 *repos/src/contrib/PACKAGES.rds
+810097cd50cabaa53f5be2e489ad3ad4 *repos/src/contrib/renv_1.1.5.tar.gz
+c852598faf15e9a614eee1ae5933ad09 *resources/WELCOME
+60e2e5f466d4aa607c2e80fdc8108e0d *resources/activate.R
+38ebcc4778f15ad0c0e1cf144f17bf4e *resources/scripts-git-askpass.cmd
+0f28660d57f2dd9dad52380e812e83d5 *resources/scripts-git-askpass.sh
+63ba0c4b0cfe770b0241478e3e93ef37 *resources/vendor/renv.R
+d41d8cd98f00b204e9800998ecf8427e *resources/watchdog-process.R
+5a30cca829fc56645aa643e1b9b12ae9 *rstudio/addins.dcf
+a4018a811560562430f0a19df6439ab4 *schema/draft-07.renv.lock.schema.json
+5de6852987292942c6ca1d805d8c6290 *sysreqs/sysreqs.json

renv/library/windows/R-4.5/x86_64-w64-mingw32/renv/NAMESPACE

@@ -0,0 +1,86 @@
+# Generated by roxygen2: do not edit by hand
+
+export(activate)
+export(autoload)
+export(checkout)
+export(clean)
+export(config)
+export(consent)
+export(deactivate)
+export(dependencies)
+export(diagnostics)
+export(embed)
+export(equip)
+export(history)
+export(hydrate)
+export(init)
+export(install)
+export(isolate)
+export(load)
+export(lockfile_create)
+export(lockfile_modify)
+export(lockfile_read)
+export(lockfile_validate)
+export(lockfile_write)
+export(migrate)
+export(modify)
+export(paths)
+export(project)
+export(purge)
+export(rebuild)
+export(record)
+export(refresh)
+export(rehash)
+export(remove)
+export(repair)
+export(restore)
+export(retrieve)
+export(revert)
+export(run)
+export(sandbox)
+export(scaffold)
+export(settings)
+export(snapshot)
+export(status)
+export(sysreqs)
+export(update)
+export(upgrade)
+export(use)
+export(use_python)
+importFrom(tools,file_ext)
+importFrom(tools,md5sum)
+importFrom(tools,package_dependencies)
+importFrom(tools,pskill)
+importFrom(tools,psnice)
+importFrom(tools,write_PACKAGES)
+importFrom(utils,Rprof)
+importFrom(utils,URLencode)
+importFrom(utils,adist)
+importFrom(utils,available.packages)
+importFrom(utils,browseURL)
+importFrom(utils,citation)
+importFrom(utils,contrib.url)
+importFrom(utils,download.file)
+importFrom(utils,download.packages)
+importFrom(utils,file.edit)
+importFrom(utils,getCRANmirrors)
+importFrom(utils,head)
+importFrom(utils,help)
+importFrom(utils,install.packages)
+importFrom(utils,installed.packages)
+importFrom(utils,modifyList)
+importFrom(utils,old.packages)
+importFrom(utils,packageDescription)
+importFrom(utils,packageVersion)
+importFrom(utils,read.table)
+importFrom(utils,remove.packages)
+importFrom(utils,sessionInfo)
+importFrom(utils,str)
+importFrom(utils,summaryRprof)
+importFrom(utils,tail)
+importFrom(utils,tar)
+importFrom(utils,toBibtex)
+importFrom(utils,untar)
+importFrom(utils,unzip)
+importFrom(utils,update.packages)
+importFrom(utils,zip)

renv/library/windows/R-4.5/x86_64-w64-mingw32/renv/NEWS.md

@@ -0,0 +1,2067 @@
+
+# renv 1.1.5
+
+* Fixed an issue where `renv::dependencies()` could fail for chunks which
+  had a `label` which was not a length-one character vector. (#2144)
+
+* Fixed an issue where `file.rename()` could fail when unpacking a
+  package during installation in certain Windows environments. (#2156)
+
+* `renv`'s dependency discovery now supports usages of `base::use()`. (#2130)
+
+* Fixed an issue where `renv` could fail to parse remote references
+  containing an `@` character. (#2135)
+
+* Fixed an issue where `renv::sysreqs(distro = <...>)` could fail when
+  passed an alternate distribution without a version specifier. (#2105)
+
+* Fixed an issue where multimode R documents containing chunk headers
+  which did not parse to an R list could cause dependency inference
+  to fail. (#2110)
+
+
+# renv 1.1.4
+
+* Fixed an issue where `renv` could erroneously record packages installed
+  from Posit Package Manager snapshots as being installed from CRAN. (#2104)
+
+* `renv` now only checks for archived packages during installation when
+  `options(renv.install.allowArchivedPackages = TRUE)` is set. This fixes
+  an issue where `renv` could erroneously discover that Rcpp 1.3 was
+  available when using the Posit Package Manager repository.
+
+* Fixed an issue where `renv::dependencies()` could fail with an
+  unhelpful error message if the scanned document contained a
+  YAML header whose contents was not a map. (#2117)
+
+
+# renv 1.1.3
+
+* Fixed an issue where `renv::hydrate()` could fail to install packages
+  discovered in the user library during `renv::init()`. (#2109)
+
+* `renv::update()` now only updates the packages installed in the project
+  library by default. `renv::update(all = TRUE)` can be used to also
+  check if packages installed in the default library are out-of-date, and
+  install updated copies into the project library. (#2108)
+  
+* Fixed an issue where package installation could fail on Arch Linux with the
+  error message "don't know how to check sysreqs on this system". (#2107)
+
+* `renv` now supports profile-specific comments within `.gitignore` and
+  `.renvignore` files. These are comments of the form `#| <code>`, where
+  `<code>` is R code which should indicate if the `.renvignore` rules should
+  apply. Typically, this should be of the form `#| profile == "extra"`, or
+  `#| profile %in% c("extra", "other")`. Note that only a small subset of
+  base R functions are available for evaluation in this context. Note that
+  the first section in a `.renvignore` implicitly applies to all profiles --
+  if you want to limit it to just the default profile, you can use
+  `#| profile == "default"` for the first line. (#1662)
+  
+* The environment variable `RENV_PATHS_VERSION` can now be used to substitute
+  the R version component normally used in library / cache paths. The provided
+  path can include placeholders like `%V` for the full R version including
+  the patch level, and `%v` for the R version without the patch level. Defaults
+  to `R-%v` when unset. (#1687)
+
+* `renv::install()` gains the `transactional` argument, for parity with
+  `renv::restore()`. (#1109)
+
+
+# renv 1.1.2
+
+* `renv` gains the `sysreqs()` function, which can be used to query the system
+  packages required by a set of R packages. Functionality is currently available
+  for Debian-based distributions, as well as Red Hat distributions.
+  
+* On Linux, `renv` now uses the database from
+  <https://github.com/rstudio/r-system-requirements> when determining if
+  an R package's required system libraries are installed, and notifies
+  the user which packages (if any) are missing during install / restore.
+  
+* Fixed an issue where `renv` could fail to retrieve credentials registered
+  for 'github.com' when querying URLs at 'api.github.com'.
+
+* Fixed an issue where `renv` could stall when loading a project and validating
+  that the configured version of Bioconductor is compatible with the version
+  of R currently in use.
+
+* `renv::snapshot()` no longer fails to generate a new lockfile if the project
+  contains a lockfile which could not be read or parsed.
+
+* Fixed an issue where lockfiles containing unicode characters were not
+  correctly written or read with versions of R (< 4.2.0) on Windows. (#2091)
+
+
+# renv 1.1.1
+
+* Fixed an issue where very long lockfiles could be truncated on write. (#2089)
+
+* Fixed an issue where `renv` inadvertently made web requests in
+  tests during `R CMD check`.
+
+
+# renv 1.1.0
+
+## Major Changes
+
+* `renv` now includes additional package DESCRIPTION fields in the lockfile.
+  This can be useful for validating the provenance of packages recorded in the
+  lockfile, and also for applications using `renv` which would like to
+  recompute the hash used for package caching from the lockfile itself.
+
+  If needed, old-style lockfiles can be generated by setting the option
+  `options(renv.lockfile.version = 1)`. Note that this version of `renv`
+  remains compatible both with the older (minimal) lockfiles, as well
+  as with the newer lockfiles in this release. (#2057)
+
+## Other Fixes
+
+* The `renv` sandbox is now unlocked on exit after a call to `renv::use()`.
+  This should alleviate issues seen where R's attempts to clean up the
+  temporary directory could fail due to inadequate permissions on the
+  sandbox directory. (#2076)
+
+* Fixed an issue where `renv::restore()` did not respect the named repository
+  within the lockfile when installing packages from the archives of the
+  configured package repositories. (#2081)
+  
+* Fixed an issue where `renv::snapshot()` could fail if invoked within
+  a project containing empty or invalid `.ipynb` files. (#2073)
+
+* Fixed an issue where R package installation could fail if the project
+  depended on a package whose current version available from the configured
+  package repositories required on a newer version of R than what was currently
+  installed, even if that package need not be updated. (#2071)
+
+* Fixed an issue where `RENV_CONFIG_EXTERNAL_LIBRARIES` was incorrectly
+  split when using Windows paths. (#2069)
+  
+* Fixed an issue where `renv` failed to restore packages installed from
+  r-universe when the associated lockfile record had no `RemoteRef` field.
+  (#2068)
+
+* `renv` now detects dependencies from usages of `utils::citation()`. (#2047)
+  
+* Fixed an issue where packages installed from r-universe via an explicit
+  URL remote could not be restored. (#2060)
+
+* Fixed an issue where the repositories provided to `renv::init()` were ignored
+  when also initializing `renv` with a specific version of Bioconductor.
+
+* `renv::install()` gains the `include` parameter, which can be useful when
+  you'd like to install a subset of dependencies within a project while also
+  respecting any declared remotes in that project's `DESCRIPTION` file. (#2055)
+
+* Fixed an issue where `renv` could fail to check for updates for packages
+  installed using `pak` without an explicit branch specified. (#2040)
+  
+* `renv::use()` no longer re-installs packages which are already installed
+  and compatible with the requested packages. (#2044)
+
+* Fixed an issue where `renv::init()` could fail when using named remotes
+  in a DESCRIPTION file's `Remotes:` field. (#2055)
+
+* Fixed an issue where ignore rules of the form `!*.*` were not parsed
+  and handled correctly during dependency discovery. (#2052)
+
+* Fixed an issue where `renv` erroneously reported that installed packages were
+  cached when the cache was not writable. (#2041).
+
+* `renv` now supports updating of currently-installed packages via `renv::install()`
+  when configured to use `pak`. (#2037)
+
+* Fixed an issue where `renv` library paths were not properly reset following
+  a suspend / resume in RStudio Server. (#2036)
+
+* `renv::run()` gains the `args` parameter, which can be used to pass command-line
+  arguments to a script. (#2015)
+
+* `renv` now infers a dependency on `rmarkdown` and `knitr` for R scripts which
+  include YAML front-matter. (#2023)
+
+* The performance of `renv`'s built-in JSON reader has been improved. (#2021)
+
+* Fixed an issue where `renv` could erroneously create a binding called 'object'
+  in the global environment on startup. (#2017)
+
+
+# renv 1.0.11
+
+* Fixed an issue where headers were not properly passed to `available.packages()`
+  during `renv` bootstrap. (#1942)
+  
+* `renv` now assumes that Artifactory package repositories will use a CRAN-like
+  layout of packages for packages in the archive. (#1996)
+
+* `renv` now includes compiled extensions on Linux + macOS. These
+  extensions are primarily used to improve the performance of
+  `renv::dependencies()` and other static analysis code.
+  Support for Windows may come in a future release.
+
+* Fixed an issue where `renv::snapshot()` could fail if the project
+  contained a call to `module()` with no arguments. (#2007)
+
+* On Linux, `renv` now emits a message on load if the R temporary directory
+  is within a folder that has been mounted as 'noexec'. This message can be
+  suppressed by setting the `RENV_TEMPDIR_NOEXEC_CHECK=FALSE` environment
+  variable.
+  
+
+# renv 1.0.10
+
+* Fixed a performance regression in `renv::dependencies()`. (#1999)
+
+* Fixed an issue where `renv` tests could fail if the `parallel` package was
+  loaded during test execution.
+
+* `renv` now determines a package repository's type through the HTTP headers
+  provided when accessing `src/contrib/PACKAGES`. This is mainly relevant
+  when detecting Nexus and Artifactory repositories.
+
+
+# renv 1.0.9
+
+* Fixed an issue where repository URLs were inappropriately transformed into
+  binary repository URLs on Linux. (#1991)
+
+* Fixed an issue where code following `source("renv/activate.R")` in the project
+  `.Rprofile` was not invoked for projects using RStudio. (#1990)
+
+
+# renv 1.0.8
+
+* `renv` now infers a dependency on the `ragg` package when the `ragg_png` device
+  is used in R Markdown / Quarto documents, for documents using the code
+  `knitr::opts_chunk$set(dev = "ragg_png")`. (#1985)
+  
+* `renv` now automatically generates a lockfile when loading a project containing
+  a `manifest.json` file (typical for application bundles published to Posit Connect).
+  (#1980, @toph-allen)
+
+* `renv::install()` now errs if an incompatible `type` argument is provided.
+
+* `renv::checkout()` now also checks out the version of `renv` available
+  and associated with the requested snapshot date. (#1966)
+
+* Fixed an issue where `renv::hydrate()` did not hydrate packages which
+  were also listed as dependencies within a project's `DESCRIPTION` file.
+  (#1970)
+  
+* Fixed an issue where `renv::checkout()` omitted some fields from lockfile
+  records when using `actions = c("snapshot", "restore")`. (#1969)
+
+* `renv` gains the function `renv::retrieve()`, which can be used to download
+  packages without installing them. This is primarily useful in CI / CD scenarios,
+  where you might want to download packages in a single stage before attempting
+  to install / restore them. (#1965)
+
+* `renv` now preserves `Remote` fields present on packages installed from
+  public package repositories (e.g. <https://r-universe.dev/>). (#1961)
+
+* Fixed an issue where `renv::load()` could fail to load an alternate project
+  when `options(renv.config.autoloader.enabled = FALSE)` was set. (#1959)
+
+* `renv` now emits clickable hyperlinks for runnable code snippets and help,
+  for front-ends which support the `ide:run` and `ide:help` ANSI escapes.
+
+* `renv::init(bioc = "<version>")` now prompts the user in interactive sessions
+  when requesting a version of Bioconductor which is not compatible with the
+  current version of R. (#1943)
+
+* `renv::restore()` gains the `transactional` argument, which can be
+  used to control whether `renv` will allow successfully-installed
+  packages remain in the project library even if a package fails
+  to install during a later step. (#1109)
+
+* `renv` now infers a dependency on the `xml2` package for projects
+  using the `testthat::JunitReporter` for tests. (#1936)
+
+* Fixed an issue where `renv::dependencies()` could emit a warning
+  when attempting to parse chunks using chunk options like
+  `#| eval: c(1, 2)`. (#1906)
+
+* `renv::install()` now properly delegates the `type` and `rebuild`
+  arguments to `pak` when `options(renv.config.pak.enabled = TRUE)`
+  is set. (#1924)
+
+* `renv` now infers a dependency on the `svglite` package if it detects
+  calls of the form `ggsave(filename = "path.svg")`. (#1930)
+
+* `renv` now supports setting of GitHub authentication credentials via
+  any of `GITHUB_TOKEN`, `GITHUB_PAT`, and `GH_TOKEN`. (#1937)
+
+* `renv` now also passes any custom headers available to
+  `utils::available.packages()` during bootstrap. (#1942)
+
+* Fixed an issue where `renv` could fail during installation of packages
+  stored within repository sub-directories, if that repository also
+  contained a top-level DESCRIPTION file. (#1941)
+
+* `renv` now normalizes lockfile entries for Bioconductor packages installed
+  via `pak::pkg_install()`, to help prevent spurious diffs being produced
+  via `renv::status()`. (#1920)
+
+* `renv::install()` now respects the `prompt` parameter when `pak` is enabled,
+  as via `options(renv.config.pak.enabled = TRUE)`. (#1907)
+
+* Fixed an issue with `renv`'s `pak` integration where `renv` could install the
+  wrong version of a GitHub package during restore if
+  `options(renv.config.pak.enabled = TRUE)` was set. (#1883)
+
+* `renv` no longer interacts with the user during autoloading, which coincides
+  with R startup. If the IDE offers a session init hook (RStudio does),
+  loading is deferred until startup is complete and interaction is possible.
+  Otherwise, any suggested renv actions, such as `renv::restore()`, are emitted
+  as a message for the user to act on. (#1879, #1915).
+
+* Fixed an issue where installation of packages from local sources, as via 
+  `install("<package>", repos = NULL, type = "source")`, could fail. (#1880)
+
+* A new function, `renv::lockfile_validate()`, can be used to validate your `renv.lock`
+  against a default or custom schema. (#1889)
+
+
+# renv 1.0.7
+
+* Fixed an issue where `renv`'s activate script failed to report version
+  conflict errors when starting up. (#1874)
+
+
+# renv 1.0.6
+
+* Fixed an issue where downloads could fail with curl >= 8.7.1. (#1869)
+
+* Fixed an issue where `renv::snapshot()` did not properly normalize
+  package records generated from packages installed using the `pak`
+  package, e.g. via `pak::pkg_install("cran::<package>")`.
+
+* Fixed an issue where `renv` could incorrectly prompt the user to record
+  a version of `renv` installed from GitHub in some cases. (#1857)
+
+* `renv::load()` now delegates to `base::load()` when it detects that the
+  call was likely intended for `base::load()`, but `renv::load()` was used
+  instead (e.g. because `base::load()` was masked by `renv::load()`).
+  
+* `renv::update()` gains the `lock` argument, which can be used to
+  instruct `renv` to automatically update the lockfile after the requested
+  packages have been updated. (#1849)
+
+* Fixed an issue where `renv` could fail to update the project autoloader
+  after calling `renv::upgrade()`. (#1837)
+
+* Fixed an issue where attempts to install binary packages from older
+  PPM snapshots could fail. (#1839)
+
+* `renv` now uses a platform-specific prefix on Linux for library and
+  cache paths by default with R (>= 4.4.0). This is equivalent to setting
+  `RENV_PATHS_PREFIX_AUTO = TRUE`. If necessary, this behavior can be
+  disabled by setting `RENV_PATHS_PREFIX_AUTO = FALSE` in an appropriate
+  R startup file. (#1211)
+
+
+# renv 1.0.5
+
+* `renv` now only writes a `.renvignore` file into the cache directory
+  if the cache appears to be part of the current project.
+
+* `renv` now reports missing system libraries as part of its ABI
+  checks in `renv::diagnostics()`.
+
+* Fixed an issue where `renv::install(lock = TRUE)` produced lockfiles
+  containing records with extraneous data. (#1828)
+
+
+# renv 1.0.4
+
+* `renv::install()` gains the `lock` argument. When `TRUE`, the project
+  lockfile will be updated after the requested packages have been
+  successfully installed. (#1811)
+  
+* `renv` now supports the use of GitHub Enterprise servers with the
+  `gitcreds` package for authentication credentials. (#1814)
+
+* `renv::dependencies()` now treats `#| eval: !expr <...>` chunk options
+  as truthy by default, implying that such chunks are scanned for their
+  R package dependencies. (#1816)
+  
+* `renv::dependencies()` now requires usages of the [import](https://cran.r-project.org/package=import)
+  package to be namespace-qualified in order to be handled via static
+  analysis; that is, `import::from(<pkg>)` is parsed for dependencies,
+  but `from(pkg)` is not. (#1815)
+  
+* `renv::load()` gains the `profile` argument, allowing one to
+  explicitly load a specific profile associated with an `renv` project.
+  See `vignette("profiles", package = "renv")` or
+  https://rstudio.github.io/renv/articles/profiles.html
+  for more details.
+  
+* `renv::dependencies()` no longer includes `R` dependency versions
+  declared from a `DESCRIPTION` file in its output. (#1806)
+
+* Fixed an issue where `renv` could fail to infer dependencies from
+  R Markdown code chunks using engine 'R' (upper-case) rather than
+  'r' (lower-case). (#1803)
+
+* Fixed an issue where `renv` did not report out-of-sync packages when
+  one or more packages used in the project were not installed. (#1788)
+
+* Fixed an issue where `renv` could over-aggressively activate P3M
+  repositories when initializing a project. (#1782)
+
+* `renv::status()` now notifies the user if the version of R recorded in
+  the lockfile does not match the version of R currently in use. (#1779)
+
+* Fixed an issue where packages could appear multiple times in the lockfile,
+  if that package was installed into multiple library paths. (#1781)
+
+* Installation of historical binaries of packages is once again enabled,
+  now using the [Posit Public Package Manager (P3M)](https://packagemanager.posit.co)
+  service instead of Microsoft's (now defunct) MRAN service.
+
+* `renv::init()` now respects the `Remotes:` field declared in a project's
+  `DESCRIPTION` file, if any. (#1522)
+
+* `renv::embed()` now supports Quarto Markdown (`.qmd`) files. (#1700)
+
+* renv now sets the `R_INSTALL_TAR` environment variable to match the default
+  `tar` executable (if any) when installing packages. (#1724)
+
+* renv now uses `--ssl-revoke-best-effort` by default when downloading files
+  using `curl` on Windows. (#1739)
+
+* Fixed an issue where `renv::install()` could fail to detect incompatible
+  recursive package dependencies. (#1671)
+
+* `renv::install()` now records remote information for packages installed from
+  CRAN-like repositories, and uses that information when generating a lockfile
+  and restoring those packages. This helps ensure that packages installed within
+  an renv project via calls like `renv::install("<pkg>", repos = "<repos>")` can
+  still be successfully restored in future sessions. (#1765)
+
+* `renv::install()` now lazily resolves project remotes. (#1755)
+
+* `renv::init()` now respects Remotes declared within a project's `DESCRIPTION`
+  file, if any.
+
+* Calling `renv::activate()` without explicitly providing the `profile` argument
+  now preserves the current profile, if any. Use `renv::activate(profile = "default")`
+  if you'd like to re-activate a project using the default profile. (#1217)
+
+* Fixed an issue where `renv` would try to prompt for the installation of
+  `BiocManager` when activating a project using Bioconductor. (#1754)
+
+* Fixed an issue where directories containing a large number of files could
+  cause `renv` to fail to activate a project. (#1733)
+
+* Expanded the set of Linux distributions detected for automatic transformation
+  of Posit Package Manager URLs to install binary packages. `renv` now correctly
+  detects Red Hat Enterprise Linux 9, Rocky Linux 8 and 9, SLES 15 SP4 and SP5,
+  Debian 11 and 12, AlmaLinux 8 and 9, and Amazon Linux 2. (#1720, #1721)
+
+
+# renv 1.0.3
+
+* Fixed an issue where `renv` could warn the project appeared to be out-of-sync
+  when using packages installed without an explicit source recorded. (#1683)
+
+* `renv::install()` gains the `exclude` argument, which can be useful when
+  installing a subset of project dependencies.
+
+* Fixed an issue where PPM repositories were not appropriately transformed
+  into the correct binary repository in `renv::restore()` when using pak.
+
+* `renv::init()` no longer prompts the user for the intended action for
+  projects containing a library with only renv installed. (#1668)
+
+* Fixed an issue where non-interactive usages of `renv::init()` could fail
+  with projects containing a DESCRIPTION file. (#1663)
+
+* Fixed an issue that could cause code within a project `.Rprofile` to execute
+  before the project had been loaded in RStudio. (#1650)
+
+* `renv::snapshot()` and `renv::status()` gain the `dev` argument. This
+  can be used when you'd like to capture package dependencies from
+  the *Suggests* field of your package's DESCRIPTION file. (#1019)
+
+
+# renv 1.0.2
+
+* renv now parses package `NAMESPACE` files for imported dependencies. (#1637)
+
+* renv no longer locks the sandbox by default.
+
+* Fixed an issue where renv used the wrong library paths when attempting
+  to activate the watchdog. This could cause a 10 second delay when activating
+  the sandbox.
+
+
+# renv 1.0.1
+
+* Fixed an issue where authentication headers could be duplicated when
+  using the `libcurl` download method. (#1605)
+
+* `renv::use()` now defaults to setting `isolate = TRUE` when `sandbox = TRUE`.
+
+* Fixed an issue where the renv watchdog could fail to load, leading to slowness
+  in activating the sandbox on startup. (#1617)
+
+* Fixed an issue where renv did not display warnings / errors from `renv::snapshot()`
+  when `options(renv.verbose = FALSE)` was set. The display of these messages
+  is now controlled via the `renv.caution.verbose` R option. (#1607, #1608)
+
+* `renv::load()` now notifies the user if the synchronization check took an
+  excessive amount of time due to the number of files being scanned in the
+  project. (#1573)
+
+* `renv::init()` gains the `load` argument, making it possible to initialize
+  a project without explicitly loading it. (#1583)
+  
+* renv now uses a lock when synchronizing installed packages with the cache.
+  This should help alleviate issues that can arise when multiple R processes
+  are installing and caching packages concurrently. (#1571)
+
+* Fixed a regression in parsing expressions within R Markdown chunk options. (#1558)
+
+* Fixed an issue that prevented `renv::install()` from functioning
+  when source-only repositories were included. (#1578)
+  
+* Fixed a logic error in reading `RENV_AUTOLOAD_ENABLED`. (#1580)
+
+* `renv::restore()` no longer runs without prompting on load if the 
+  library is empty. (#1543)
+
+* `renv::repair()` now checks for installed packages which lack a known
+  remote source, and updates their `DESCRIPTION` files if it can infer an
+  appropriate remote source. This typically occurs when a package is installed
+  from local sources, but appears to be maintained or published on a remote
+  repository (e.g. GitHub). This was previously done in `renv::snapshot()`, but
+  we've rolled back that change as the prompting was over-aggressive. (#1574)
+
+* `renv::status()` now first reports on uninstalled packages, before reporting on
+  used <-> installed mismatches. (#1538)
+
+* When the `RENV_STARTUP_DIAGNOSTICS` environment variable is set to `TRUE`,
+  renv now displays a short diagnostics report after a project's autoloader
+  has been run. This can be useful when diagnosing why renv is slow to load
+  in certain projects. (#1557)
+
+* renv now ensures the sandbox is activated on load, for R processes which
+  are launched with the renv sandbox on the library paths. (#1565)
+
+* `renv::restore()` no longer erroneously prompts when determining the packages
+  which need to be installed. (#1544)
+
+* `renv::update()` now ensures the `prompt` parameter is properly respected
+  during package installation. (#1540)
+
+* `renv::activate()` no longer erroneously preserves the previous library
+  paths after restarting the session within RStudio. (#1530)
+
+* Use correct spelling of IRkernel package (#1528).
+
+* Honor `R_LIBCURL_SSL_REVOKE_BEST_EFFORT` when using an external `curl.exe`
+  binary to download files. (#1624)
+
+
+# renv 1.0.0
+
+## New features
+
+* New `renv::checkout()` installings the latest-available packages from a 
+  repository. For example, `renv::checkout(date = "2023-02-08")` will install 
+  the packages available on 2023-02-08 from the Posit 
+  [Package Manager](https://packagemanager.rstudio.com/) repository. 
+  The `actions` argument allows you choose whether a lockfile is generated from 
+  the provided repositories ("snapshot"), or whether packages are installed 
+  from the provided repositories ("restore").
+
+* `renv::deactivate()` gains a `clean` argument: when `TRUE` it will delete
+  all renv files/directories, leaving the project the way it was found.
+
+* `renv::init()` now uses [Posit Public Package Manager](https://packagemanager.posit.co)
+  by default, for new projects where the repositories have not already been
+  configured externally. See the options `renv.config.ppm.enabled`,
+  `renv.config.ppm.default`, and `renv.config.ppm.url` in `?config` for more
+  details (#430).
+
+* `renv::lockfile_create()`, `renv::lockfile_read()`, `renv::lockfile_write()`
+  and `renv::lockfile_modify()` provide a small family of functions for 
+  interacting with renv lockfiles programmatically (#1438).
+
+* Handling of development dependencies has been refined. `renv::snapshot()` 
+  and `renv::status()` no longer track development dependencies, while
+  `install()` continues to install them (#1019). `Suggested` packages listed in 
+  `DESCRIPTION` files are declared as development dependencies regardless of 
+  whether or not they're a "package" project.
+
+* MRAN integration is now disabled by default, pending the upcoming shutdown
+  of Microsoft's MRAN service. Users who require binaries of older R packages
+  on Windows + macOS can consider using the instance of CRAN mirrored by the
+  [Posit Public Package Manager](https://packagemanager.posit.co) (#1343).
+
+## Bug fixes and minor improvements
+
+* Development versions of renv are now tracked using the Git SHA of the 
+  current commit, rather than a version number that's incremented on every
+  change (#1327). This shouldn't have any user facing impact, but makes
+  renv maintenance a little easier.
+
+* Fixed an issue causing "restarting interrupted promise evaluation" warnings
+  to be displayed when querying available packages failed. (#1260)
+
+* `renv::activate()` uses a three option menu that hopefully make your choices 
+  more clear (#1372).
+
+* `renv::dependencies()` now discovers R package dependencies inside Jupyter
+  notebooks (#929).
+
+* `renv::dependencies()` includes packages used by user profile (`~/.Rprofile`)
+  if `renv::config$user.profile()` is `TRUE`. They are set as development 
+  dependencies, which means that they will be installed by `install()` but not
+  recorded in the snapshot.
+
+* `renv::dependencies()` only extracts dependencies from text in YAML
+  headers that looks like valid R code (#1288).
+
+* `renv::dependencies()` no longer treats `box::use(module/file)` as using
+  package `module` (#1377).
+
+* `renv::init()` now prompts the user to select a snapshot type if the project
+  contains a top-level DESCRIPTION file (#1485).
+
+* `renv::install(type = "source")` now ensures source repositories are used
+  in projects using [PPM](https://packagemanager.posit.co/). (#927)
+
+* `renv::install()` activates Bioconductor repositories when installing a 
+  package from a remote (e.g. GitHub) which declares a Bioconductor dependency 
+  (via a non-empty 'biocViews' field) (#934).
+
+* `renv::install()` respects the project snapshot type, if set.
+
+* `renv::install()` now keeps source when installing packages from source (#522).
+
+* `renv::install()` now validates that binary packages can be loaded after
+  installation, in a manner similar to source packages (#1275).
+
+* `renv::install()` now supports Bioconductor remotes of the form
+  `bioc::<BiocVersion>/<Package>`, for installing packages from
+  a particular version of Bioconductor. Aliases like 'release' and
+  'devel' are also supported (#1195).
+
+* `renv::install()` now requires interactive confirmation that you want to 
+  install packages (#587).
+
+* `renv::load()` gives a more informative message if a lockfile is present but 
+  no packages are installed (#353).
+
+* `renv::load()` no longer attempts to query package repositories when checking
+  if a project is synchronized (#812).
+
+* `renv::load()` no longer duplicates entries on the `PATH` environment variable
+  (#1095).
+
+* `renv::restore()` can now use `pak::pkg_install()` to install packages
+  when `pak` integration is enabled. Set `RENV_CONFIG_PAK_ENABLED = TRUE`
+  in your project's `.Renviron` if you'd like to opt-in to this behavior.
+  Note that this requires a nightly build of `pak` (>= 0.4.0-9000);
+  see https://pak.r-lib.org/dev/reference/install.html for more details.
+  
+* `renv::restore()` now emits an error if called within a project that
+  does not contain a lockfile (#1474).
+
+* `renv::restore()` correctly restores packages downloaded and installed 
+  from [r-universe](https://r-universe.dev/) (#1359).
+
+* `renv::snapshot()` now standardises pak metadata so CRAN packages installed via
+  pak look the same as CRAN packages installed with renv or `install.packages()`
+  (#1239).
+
+* If `renv::snapshot()` finds missing packages, a new prompt allows you to 
+  install them before continuing (#1198).
+
+* `renv::snapshot()` no longer requires confirmation when writing the first
+  snapshot, since that's an action that can easily be undone (by deleting
+  `renv.lock`) (#1281).
+
+* `renv::snapshot()` reports if the R version changes, even if no packages
+  change (#962).
+
+* `renv::snapshot(exclude = <...>)` no longer warns when attempting to exclude 
+  a package that is not installed (#1396).
+
+* `renv::status()` now uses a more compact display when packages have some
+  inconsistent combination of being installed, used, and recorded.
+
+* `renv::status()` now works more like `renv::restore()` when package versions
+  are different (#675).
+
+* `renv::update()` can now update packages installed from GitLab (#136) and 
+  BitBucket (#1194).
+
+* `renv::settings$package.dependency.fields()` now only affects packages 
+  installed directly by the user, not downstream dependencies of those packages.
+
+* renv functions give a clearer error if `renv.lock` has somehow become 
+  corrupted (#1027).
+
+
+# renv 0.17.3
+
+* Fixed an issue where `renv::install("bioc::<package>")` could fail if
+  `BiocManager` was not already installed. (#1184)
+
+* Fixed an issue where package names were not included in the output
+  of `renv::diagnostics()`. (#1182)
+
+* The clarity of the message printed by `renv::status()` has been improved;
+  in particular, renv should better report the recommended actions when
+  a package required by the project is not installed.
+
+* `renv::snapshot()` gains the `exclude` argument, for explicitly
+  excluding certain packages from the generated lockfile.
+
+* Fixed an issue where renv was passing the wrong argument name to
+  `installed.packages()`, causing usages of renv to fail with
+  R (<= 3.4.0). (#1173)
+  
+* renv now sets the `SDKROOT` environment variable on macOS if it detects
+  that R was built using an LLVM build of `clang` on macOS.
+
+* `renv::install()` now parses the remotes included within, for example,
+  a `DESCRIPTION` file's `Config/Needs/...` field.
+  
+* renv now checks that the index directory is writable before attempting to
+  use it, e.g. for the `R` available packages index maintained by renv. (#1171)
+  
+* renv now checks that the version of `curl` used for downloads appears to
+  be functional, and reports a warning if it does not (for example, because
+  a requisite system library is missing). The version of `curl` used for
+  downloads can also be configured via the `RENV_CURL_EXECUTABLE` environment
+  variable.
+  
+
+# renv 0.17.2
+
+* Fixed a regression that caused package hashes to be computed incorrectly
+  in some cases. This was a regression in the 0.17.1 release. (#1168)
+
+
+# renv 0.17.1
+
+* renv gains the configuration option `install.remotes`, which can be used
+  to control whether renv attempts to read and use the `Remotes:` field
+  included with installed packages. This can be set to `FALSE` if you'd
+  like to ignore this field; e.g. because you know they will not be
+  accessible. (#1133)
+
+* General performance optimizations. In particular, `renv::update(check = TRUE)`
+  should now execute much faster.
+
+* renv now stores project settings within `renv/settings.json` rather than
+  `renv/settings.dcf`. Old settings will be automatically migrated.
+
+* The renv sandbox is now placed within the renv cache directory. (#1158)
+
+* Fixed an issue where `renv::status()` could erroneously report a project was
+  out-of-sync when using explicit snapshots. (#1159)
+
+* Fixed an issue where `renv::hydrate()` would print spurious warnings. (#1160)
+
+* `renv::status()` now suggests running `renv::restore()` if there are no
+  packages installed in the project library. (#1060)
+  
+* Fixed an issue where renv would fail to query [r-universe](https://r-universe.dev/)
+  repositories. (#1156)
+
+* renv no longer tries to set the `SDKROOT` environment variable on
+  macOS for R (>= 4.0.0).
+
+* Fixed an issue where installation of Bioconductor packages could fail
+  when `BiocManager` was not installed. (#1156, #1155)
+
+* Fixed an issue where the amount of time elapsed reported by `renv::install()`
+  failed to include the time spent retrieving packages.
+
+
+# renv 0.17.0
+
+* The performance of `renv::snapshot()` has improved.
+
+* renv now maintains an index of available packages, as retrieved from the
+  active package repositories, that is shared across `R` sessions. This should
+  improve renv's performance when querying for available packages across
+  multiple different `R` sessions.
+  
+* `renv::hydrate()` gains the `prompt` parameter. When `TRUE` (the default),
+  renv will prompt for confirmation before attempting to hydrate the active
+  library.
+  
+* Improved handling of package installation via SSH URLs with `git`. (#667)
+
+* Improved handling of R version validation when using projects with
+  Bioconductor. If you find renv is erroneously reporting that your version
+  of R is incompatible with the version of Bioconductor you are using, you can
+  set `options(renv.bioconductor.validate = FALSE)` to disable this validation
+  behaviour. (#1148)
+
+* Package names can now be associated with remotes in `renv::install()`; for
+  example, you can use `renv::install("igraph=igraph/rigraph")` to install
+  the `igraph` package. This is mainly important when using the `renv.auth`
+  authentication tools, where the package name of a remote needs to be
+  declared explicitly. (#667)
+  
+* Fixed an issue that could prevent `renv::restore()` from functioning when
+  attempting to install packages which had been archived on CRAN. (#1141)
+
+* `renv::install()` gains the `dependencies` argument, which behaves similarly
+  to the equivalent argument in `remotes::install_*()`. In particular, this can
+  be set to fields like `Config/Needs/dev` to tell renv to use custom
+  DESCRIPTION fields for dependency resolution in installation.
+
+* Fixed an issue where the function variant of the `renv.auth` option was not
+  resolved correctly. (#667)
+
+* `renv::install()` now supports remotes with a trailing slash -- such slashes
+  are now removed. (#1135)
+
+* Integration with the RStudio (Posit) Package Manager is now disabled
+  by default on aarch64 Linux instances.
+
+* The `RENV_CACHE_MODE` environment variable can now also be used
+  to adjust the permissions set on downloaded package tarballs / binaries.
+  (#988)
+
+* Fixed an issue where fields of the form `Remotes.1` could
+  enter lockfile records for older versions of R. (#736)
+
+* Fixed the performance of `renv::update()` in cases where
+  integration with MRAN is enabled.
+
+* Fixed an issue where package installation using `pak` could fail
+  in some cases.
+
+* `renv_file_find()` can now scan up to the root directory in Docker
+  containers. (#1115)
+
+* renv no longer uses the R temporary directory on Windows for the
+  sandbox. The sandbox directory can be customized via the
+  `RENV_PATHS_SANDBOX` environment variable if required. (#835)
+  
+* renv now reports the elapsed time when installing packages. (#1104)
+
+* For projects using "explicit" snapshots, renv now reports if
+  a package is required by the project, but the package is not
+  currently installed. (#949)
+
+* Fixed an issue where `renv::snapshot()` could fail to detect when
+  no changes had been made to the lockfile.
+
+* Fixed an issue where renv could emit JSON lockfiles which could not
+  be parsed by external JSON readers. (#1102)
+
+* renv now marks the sandbox as non-writable, which should hopefully
+  alleviate issues where attempts to update installed packages would
+  inadvertently install the updated package into the sandbox. (#1090)
+
+* `renv::use()` gains the `sandbox` argument, which allows one to control
+  whether the system library is sandboxed after a call to `renv::use()`.
+  (#1083)
+
+* The path to the Conda `environment.yml` file created by renv can
+  now be customized via the `RENV_PATHS_CONDA_EXPORT` environment
+  variable. We recommend setting this within your project-local
+  `.Renviron` file as appropriate. (#1089)
+
+* Fixed an issue where the renv sandbox location did not respect the
+  active renv profile. (#1088)
+
+
+# renv 0.16.0
+
+* renv now supports installation of packages with remotes of the form
+  `<package>=<remote>`. However, the provided package name is ignored
+  and is instead parsed from the remote itself. (#1064)
+
+* renv now passes along the headers produced by the `renv.download.headers`
+  option when bootstrapping itself in the call to `utils::download.file()`.
+  (#1084)
+
+* renv now reports if `renv::snapshot()` will change or update the
+  version of R recorded in the lockfile. (#1069)
+
+* renv now supports the `install.packages.check.source` R option, which
+  is used to allow R to query source repositories even if the option
+  `options(pkgType = "binary")` is set. (#1074)
+
+* renv better handles packages containing git submodules when installed
+  from GitHub remotes. (#1075)
+
+* renv now handles local sources within the current working directory. (#1079)
+
+* The renv sandbox is once again enabled by default. On Unix, the sandbox
+  is now created by default within the project's `renv/sandbox` library.
+  On Windows, the sandbox is created within the R session's `tempdir()`.
+  The path to the renv sandbox can be customized via the `RENV_PATHS_SANDBOX`
+  environment variable if required.
+
+* Fixed an issue where `renv::status()` could report spurious changes when
+  comparing packages installed using `pak` in some cases. (#1070)
+
+* `renv::restore()` now also ensures the project activate script is updated
+  after a successful restore. (#1066)
+
+* Fixed an issue where renv could attempt to install a package from the
+  repository archives even when `type = "binary"` was set. (#1046)
+
+* Fixed an issue where package installation could fail when the R session
+  is configured to use multiple repositories, some of which do not provide
+  any information on available packages for certain binary arms of the
+  repository. (#1045)
+
+* renv now uses `jsonlite` for reading lockfiles when loaded. This should
+  help ensure useful errors are provided for manually-edited lockfiles
+  which contain a JSON parsing error. If the `jsonlite` package is not loaded,
+  renv will fall back to its own internal JSON parser. (#1027)
+  
+* Fixed an issue that would cause renv to fail to source the user
+  `~/.Rprofile` if it attempted to register global calling handlers,
+  e.g. as `prompt::set_prompt()` does. (#1036)
+
+* (Linux only) renv now resets ACLs on packages copied to the cache, to
+  avoid persisting default ACLs that might have been inherited on packages
+  installed into a local project library. If desired, this behavior can be
+  disabled by setting the `RENV_CACHE_ACLS` environment variable to `FALSE`.
+  If you need finer control over ACLs set on packages moved into the cache,
+  consider defining a custom callback via the `renv.cache.callback` R option.
+  (#1025)
+  
+* Fixed an issue where `.gitignore` inclusion rules for sub-directories were
+  not parsed correctly by renv for dependency discovery. (#403)
+
+* Fixed an issue where renv could report spurious diffs within `renv::status()`
+  when comparing package records installed from `pak` versus the default R
+  package installer. (#998)
+
+* Fixed an issue where `renv::use_python()` could cause the Requirements field
+  for packages in the lockfile to be unintentionally dropped. (#974)
+  
+* The R option `renv.cache.callback` can now be set, to run a user-defined
+  callback after a package has been copied into the cache. This can be useful
+  if you'd like to take some action on the cached package's contents after
+  the package has been moved into the cache.
+
+* (Unix only) The `RENV_CACHE_MODE` environment variable can now be used to
+  change the access permissions of packages copied into the cache. When set,
+  after a package is copied into the cache, renv will use `chmod -Rf` to try
+  and change the permissions of the cache entry to the requested permissions.
+  
+* (Unix only) The `RENV_CACHE_USER` environment variable can now be used to
+  change the ownership of folders copied into the cache. When set, after a
+  package is copied into the cache, renv will use `chown -Rf` to try and
+  change the ownership of that cache entry to the requested user account.
+
+* Fixed an issue where repositories containing multiple packages in
+  sub-directories could fail to install. (#1016)
+
+
+# renv 0.15.5
+
+* Fixed an issue where indexing of packages in the package cellar could
+  be slow. (#1014)
+
+* Fixed an issue where installation of packages from Bioconductor's binary
+  Linux package repositories could fail. (#1013)
+  
+* `renv::restore()` now supports restoration of packages installed from
+  [R-Forge](https://r-forge.r-project.org/). (#671)
+
+* Fixed an issue where `renv::init(bioconductor = TRUE)` would not update
+  the version of Bioconductor used if a project setting had already been
+  set.
+
+* It is now possible to "update" an existing lockfile by using
+  `renv::snapshot(update = TRUE)`. When set, any records existing in the
+  old lockfile, but not the new lockfile, will be preserved. (#727)
+
+* Fixed an issue where renv could fail to parse Git remotes for users
+  whose username contains a number. (#1004)
+
+* renv no longer infers a dependency on the "quarto" R package in projects
+  containing a `_quarto.yml` file. (#995)
+
+* Fixed an issue where renv could fail to download a package from MRAN if
+  a compatible source package of the same version was available from the
+  active R repositories. (#990)
+
+* renv now reports permission errors during download more clearly. (#985)
+
+* Fixed an issue where `RENV_PATHS_LIBRARY_ROOT_ASIS` was not interpreted
+  correctly. (#976)
+
+* `renv::modify()` gains the `changes` argument, which can be used to modify
+  a project lockfile non-interactively.
+  
+* `renv::clean()` now returns the project directory, as documented. (#922)
+
+* Fixed an issue where renv could fail to parse embedded YAML chunk options
+  in R Markdown documents. (#963)
+  
+* renv now sets default placeholder names for the `repos` R option, for
+  any repository URLs which happen to be unnamed. (#964)
+
+* Fixed an issue where renv didn't respect the `PATH` ordering when
+  discovering Python installations via `renv_python_discover()`. (#961)
+
+* Fixed an issue where renv could fail to install packages containing
+  multibyte unicode characters in their DESCRIPTION file. (#956)
+  
+* Fixed detection of Rtools 4.2 (#1002)
+
+
+# renv 0.15.4
+
+* Fixed an issue where package installation could fail when referencing the
+  cache via a tilde-aliased path, e.g. `~/.local/share/renv`. (#953)
+
+
+# renv 0.15.3
+
+* A variety of fixes for R CMD check.
+
+* renv gains an experimental function, `renv::autoload()`, to be used as a
+  helper for automatically loading a project for R processes launched within a
+  sub-directory of that project. See `?renv::autoload` for more details.
+
+* renv will now print a warning message when attempting to read a lockfile
+  containing merge conflict markers (as from e.g. a git merge). (#945)
+
+* Fixed an issue where `renv::install()` could install into the wrong library
+  path on Windows, if the R installation had a site-wide profile that mutated
+  the library paths. (#941)
+
+* Fixed an issue where `renv::install()` would fail to find a package within
+  the cache when using an abbreviated commit hash for installation. (#943)
+
+* Fixed an issue where renv's automatic snapshot was not run after calls to
+  `renv::install()` in some cases. (#939)
+  
+* Fixed an issue where renv would incorrectly copy a package from the cache,
+  if the cached version of the package and the requested version of the package
+  had the same package version, even if they were retrieved from different
+  sources. (#938)
+
+* The path to an renv tarball can now be set via the environment variable
+  `RENV_BOOTSTRAP_TARBALL`, to be used to help renv bootstrap from local
+  sources. This can either be the path to a directory containing renv
+  source tarballs, or the path to the tarball itself.
+  
+* Fixed an issue where the R site library would not be appropriately masked
+  for resumed RStudio sessions. (#936)
+
+
+# renv 0.15.2
+
+* Fixed issues encountered in R CMD check.
+
+
+# renv 0.15.1
+
+* Fixed an issue where renv inadvertently inserted extra newlines into
+  a `DESCRIPTION` file when adding `Remotes` fields after install. (#914)
+
+* Fixed an issue where packages installed from a remote sub-directory would
+  fail to install when later re-installed from the cache. (#913)
+
+* renv now recognizes YAML chunk options of the form `#| key: value` when
+  used in R Markdown documents. (#912)
+
+* Fixed an issue where the R site library was visible in renv projects with
+  the system library sandbox disabled.
+
+* Fixed an issue where renv could update the wrong `.gitignore` in R
+  processes launched by `callr` (e.g. in `devtools::install`). (#910)
+
+* Fixed an issue where renv could fail to read mis-encoded
+  DESCRIPTION files. (#908)
+
+* Fixed an issue where `config$cache.symlinks()` would report `NULL` when
+  unset. (#906)
+
+
+# renv 0.15.0
+
+* The development branch for renv has moved from master to main.
+
+* renv package records in the lockfile now include a `Requirements`
+  entry, which gives a list of R packages this package depends on
+  in some way. This is primarily for internal use by the `pak`
+  package.
+
+* Fixed an issue where packages containing DESCRIPTION files using
+  a latin1 encoding would not be read correctly by renv.
+
+* Fixed an issue that could cause `renv::dependencies()` to fail
+  when a malformed `DESCRIPTION` file was encountered. (#892)
+
+* The path to the project-local renv folder can now be configured
+  via the `RENV_PATHS_RENV` environment variable. This can be useful
+  if you'd prefer to store your project's renv resources within
+  an alternate location in the project. (#472)
+  
+* renv now uses an external library by default for R package projects,
+  with the library located within `tools::R_user_dir("renv", "cache")`.
+  This directory can be configured via the `RENV_PATHS_LIBRARY_ROOT`
+  environment variable if desired. See
+  `vignette("packages", package = "renv")` for more details. (#384)
+
+* renv now uses the repositories as defined within the project lockfile
+  (if any) when attempting to bootstrap itself in a project. (#820)
+
+* The renv sandbox is now disabled by default -- see #614 for more details.
+
+* renv gains the function `repair()`, to be used to attempt to repair
+  the project library when links into the global package cache appear to
+  be broken. (#378)
+
+* Fixed an issue where the staging library used during install could fail to
+  inherit the same directory permissions as the target library itself. (#331)
+
+* Fixed an regression which caused `renv::history()` to fail. (#886)
+
+* renv gains experimental support for the [pak](https://pak.r-lib.org/)
+  package. Set `RENV_CONFIG_PAK_ENABLED = TRUE` in an appropriate `.Renviron`
+  file to enable `pak` integration. When enabled, calls to `renv::install()`
+  will use `pak` to download and install packages.
+  
+* `renv::init()` gains the `bioconductor` argument, to be used to initialize
+  a project with a particular Bioconductor release. You can also use
+  `renv::init(bioconductor = TRUE)` to initialize with the latest-available
+  release for the version of R being used.
+
+* Project settings can now be overridden by setting an R option of the same
+  name. For example, one could force a project to use Bioconductor 3.14 by
+  setting `options(renv.settings.bioconductor.version = "3.14")` within
+  the project `.Rprofile` (or similar startup R profile).
+
+* The ad-hoc package repository called "local sources" has been renamed to
+  the "package cellar". In addition, the path to the cellar is now
+  controlled by the `RENV_PATHS_CELLAR` environment variable, rather than
+  `RENV_PATHS_LOCAL`. This change was made to reduce confusion between
+  "local sources" of packages located somewhere on the filesystem, as
+  opposed to packages explicitly placed in this ad-hoc repository.
+  `RENV_PATHS_LOCAL` remains supported for backwards compatibility.
+  
+* The `RENV_PATHS_CELLAR` environment variable can now be set to multiple
+  paths. Use `;` as a separator between paths; for example,
+  `RENV_PATHS_LOCAL=/path/to/sources/v1;/path/to/sources/v2`. (#550)
+  
+* Packages installed via e.g. `renv::install("./path/to/package")`
+  will now retain the relative path to that package within the lockfile.
+  (#873)
+  
+* Fixed an issue where invalid `config` option values were not properly
+  reported. (#773)
+
+* renv now supports restoration of packages installed via one of the
+  [r-universe](https://r-universe.dev/) repositories.
+
+* renv gains the `bioconductor.version` project setting, used to freeze
+  the version of Bioconductor used in a particular project. When set, this
+  will override any version that might be selected via the `BiocManager`
+  package. (#864)
+
+* renv now infers that parameterized R Markdown documents have a dependency
+  on the `shiny` package. In addition, R code included within the `params:`
+  list will be parsed for dependencies. (#859)
+  
+* renv now ignores hidden directories during dependency discovery by default.
+  If you want to force a particular hidden directory to be included for
+  discovery, you can use a `.renvignore` file with an explicit inclusion
+  criteria; e.g. `!.hidden/`.
+  
+* renv now supports the `*release` remotes specifier for GitHub repositories,
+  for requesting installation of the latest declared release of a package from
+  GitHub. (#792)
+  
+* renv now handles packages stored within the sub-directory of a Git
+  repository better. (#793)
+
+* Fixed an issue where `renv::history()` would fail to resolve the correct
+  lockfile path if the working directory was changed. (#834)
+
+* Refined dependency discovery within `glue::glue()` expressions.
+
+* renv now parses packages referenced via the `base_format` field within
+  an R Markdown document's YAML header. (#854)
+
+* Fixed an issue where renv would fail to produce the appropriate binary
+  repository URL for RSPM repositories built using Red Hat Enterprise Linux.
+
+* Fixed an issue where `renv::snapshot()` could cause the environment name
+  and / or path associated with a Python environment to be omitted from the
+  lockfile. (#843)
+
+* Fixed an issue where `renv::restore()` could fail to restore packages which
+  referred to their source via an explicit path in the `Source` field. (#849)
+  
+* renv no longer requires explicit user consent when used within Singularity
+  containers. (#824, @kiwiroy)
+
+* renv now respects the `R_PROFILE_USER` environment variable, in addition
+  to the `user.profile` configuration option, when considering whether the
+  user `.Rprofile` should be examined for package dependencies. (#821)
+
+* The renv auto-loader can now be disabled by setting the environment
+  variable `RENV_AUTOLOADER_ENABLED = FALSE`. This can be useful if you'd like
+  to explicitly control how a project is loaded, e.g. by calling `renv::load()`
+  explicitly.
+
+* `renv::snapshot()` gains the `repos` argument, to be used to force
+  the lockfile to be generated with the requested set of R repositories
+  encoded within.
+
+* renv now validates that the `repos` option, as used by `renv::snapshot()`,
+  is a named vector. (#811)
+
+* Fixed an issue where renv's shims, e.g. for `install.packages()`, failed
+  to pass along other optional arguments to the shimmed function correctly.
+  (#808)
+  
+
+# renv 0.14.0
+
+* renv now uses `tools::R_user_dir()` to resolve the default path to the
+  global renv cache, for R installations 4.0.0 or greater. If the renv
+  cache still exists at the old location, that location will be used instead.
+  This change should only affect brand new installations of renv on newer
+  versions of `R`.
+  
+* Fixed an issue with renv tests failing with R (>= 4.2.0).
+
+* renv will no longer auto-activate itself within R processes launched via
+  `R CMD INSTALL`. This behavior can be controlled if necessary via the
+  `RENV_ACTIVATE_PROJECT` environment variable -- set this to `TRUE` to
+  force the project in the current working directory to be activated, and
+  `FALSE` to suppress the renv auto-loader altogether. (#804)
+  
+* Added dependency discovery support for R utility scripts identified by a
+  shebang line instead of a file extension. (#801; @klmr)
+
+* Fixed an issue where `renv::install("<package>", type = "both")` would attempt
+  to install the package from sources, even if the current system did not have
+  the requisite build tools available. (#800)
+  
+* `renv::scaffold()` gains the `settings` argument, used to create a project
+  scaffolding with some default project options set. (#791)
+  
+* renv now determines the default branch name for packages installed from
+  GitLab without an explicit reference supplied; for example, as in
+  `renv::install("gitlab::<user>/<repo>")`. (#795)
+  
+* renv now infers a dependency on the `bslib` package for R Markdown
+  documents using custom themes. (#790)
+
+* renv will now prompt users to activate the current project when calling
+  `renv::snapshot()` or `renv::restore()` from within a project that has not
+  yet been activated. (#777)
+  
+* renv now has improved handling for `git` remotes. (#776; @matthewstrasiotto)
+
+* `renv::restore()` gains the `exclude` argument, used to exclude a subset of
+  packages during restore. (#746)
+  
+* Fixed an issue where `renv::dependencies()` could fail to parse
+  dependencies in calls to `glue::glue()` that used custom open
+  and close delimiters. (#772)
+
+* Fixed an issue where `renv::init(bare = TRUE)` would unnecessarily
+  scour the project for R package dependencies. (#771)
+
+* Fixed an issue where renv could fail to install packages located
+  on GitHub within sub-subdirectories. (#759)
+  
+* renv gains the function `embed()`, used to embed a lockfile with an
+  R document (via a call to `renv::use()`).
+
+* `renv::use()` gains the lockfile argument. This can be useful for
+  R Markdown documents and scripts that you'd like to run with the
+  context for a particular lockfile applied.
+
+* `renv::rebuild()` gains the `type` parameter, for parity with
+  `renv::install()`.
+
+* Fixed an issue where renv could incorrectly copy an incompatible version
+  of an R package from a site library into the project library during install.
+  (#750)
+
+* `renv::dependencies()` can now parse (some) usages of `parsnip::set_engine()`.
+
+* `renv::dependencies()` now has improved handling for piped expressions.
+
+* Fixed crash during dependency discovery when encountering `box::use()`
+  declarations that use a trailing comma, and no longer treat `.` and `..` as
+  package names. (@klmr)
+
+* `renv::clean()` no longer attempts to clean the system library by default.
+  (#737)
+
+* Fixed an issue where `install.packages()` could fail when used within an
+  renv project to install a package from local sources. (#724)
+
+* The chunk `renv.ignore` parameter can now be set to `FALSE`. When set,
+  renv will explicitly parse dependencies from chunks even if other
+  chunk metadata would have told renv to ignore it (e.g. because it
+  was marked with `eval=F`). (#722)
+
+* Fixed an issue where chunks with the chunk option `eval=F` would
+  still be scanned for dependencies. (#421)
+  
+* In interactive sessions, `renv::use_python()` will now prompt for
+  the version of Python to be used. Python installations in a set
+  of common locations will be searched. See `?renv::use_python()`
+  for more details.
+
+* Fixed an issue where renv would fail to retrieve packages from the
+  archives if the lockfile entry was tagged with a `RemoteSha` field.
+
+* `renv::restore()` will now prefer restoring packages from the repository
+  named in the `Repository` field if available. The name is matched against
+  the repository names set in the R `repos` option, or as encoded in the
+  renv lockfile. (#701)
+  
+* renv now supports the discovery of dependencies within interpolated strings
+  as used by the `glue` package.
+
+* `RENV_CONFIG_EXTERNAL_LIBRARIES` can now be configured to use multiple
+  library paths, delimited by either `:`, `;`, or `,`. (#700)
+  
+* renv gains the configuration option, `exported.functions`, controlling
+  which functions and objects are placed on the R search path when renv
+  is attached (e.g. via `library(renv)`). Set this to `NULL` to instruct renv
+  not to place any functions on the search path. This helps avoid issues with,
+  for example, `renv::load()` masking `base::load()`. When set, all usages
+  of renv APIs must be explicitly qualified with the `renv::` prefix.
+  
+
+# renv 0.13.2
+
+* `renv::install("user/repo/subdir with spaces")` now works as expected. (#694)
+
+* renv can now parse package dependencies declared by
+  `targets::tar_option_set(packages = <...>)`. (#698)
+
+* renv no longer performs an automatic snapshot following a user-canceled
+  renv action -- for example, if `renv::restore()` is canceled, the next
+  automatic snapshot will be suppressed. (#697)
+
+* Added the `vcs.ignore.local` project setting, to control whether the
+  project's `renv/local` folder is added to renv's VCS ignore file
+  (e.g. `renv/.gitignore`). (#696)
+
+* Fixed an issue where renv's bootstrapping code could inadvertently bootstrap
+  with the wrong version of renv, if the source and binary versions of renv
+  on CRAN were not in sync. (#695)
+  
+* Fixed an issue where `renv::status()` could provide a misleading message
+  for packages which are recorded in the lockfile, but not explicitly
+  required by the project. (#684)
+
+
+# renv 0.13.1
+
+* `renv::clean()` gains the `actions` argument, allowing the caller to control
+  which specific actions are taken during a `clean()` operation.
+
+* renv no longer performs an automatic snapshot after a call to
+  `renv::status()`. (#651)
+
+* Fixed an issue where attempts to transform RSPM repository URLs could
+  fail if the copy of R was installed without a local `CRAN_mirrors.csv`
+  file.
+
+* Fixed an issue where `renv::init()` could fail when passed a relative
+  path to a directory. (#673)
+
+* Fixed an issue where `renv::dependencies()` would miss dependencies in
+  R Markdown YAML headers containing multiple output formats. (#674)
+
+* `renv::install()` now better respects the `Remotes` field in a project
+  `DESCRIPTION` file, if available. (#670)
+
+* `RENV_DOWNLOAD_METHOD` is now treated as an alias for
+  `RENV_DOWNLOAD_FILE_METHOD`.
+
+* Fixed an issue where renv would fail to load if the `~/.Rprofile` existed
+  but was an empty file.
+
+# renv 0.13.0
+
+* `renv::snapshot()` no longer creates an `renv/activate.R` file in the project
+  folder if one does not already exist. (#655)
+  
+* The `renv::hydrate()` function gains the `update` argument, used to control
+  whether `renv::hydrate()` chooses to update packages when invoked. When set
+  to `TRUE`, if the version of a package installed in the source library is
+  newer than that of the project library, then renv will copy that version
+  of the package into the project library. (#647)
+  
+* The `RENV_PATHS_PREFIX_AUTO` environment variable can now be set to instruct
+  renv to include an OS-specific component as part of the library and
+  cache paths. This is primarily useful for Linux systems, where one might
+  want to share a global cache with multiple different operating systems.
+  The path component is constructed from the `ID` and `VERSION_CODENAME` /
+  `VERSION_ID` components of the system's `/etc/os-release` file.
+  
+* renv's dependency discovery machinery now has preliminary support
+  for packages imported via the [box](https://github.com/klmr/box) package;
+  e.g. `box::use(dplyr[...])`.
+
+* Multiple cache paths can now be specified, with each cache path separated
+  by either a `;` or `:`. This can be useful when you'd like to use multiple
+  package caches within the same project; for example, because you'd like to
+  share a read-only cache with a set of projects. (#653, @vandenman)
+
+* Fixed an issue where renv could fail to discover dependencies in directories
+  with very large `.gitignore` or `.renvignore` files. (#652)
+
+* renv gains a new configuration option, `install.shortcuts`. When enabled,
+  if renv discovers that a package to be installed is already available in
+  the user or site libraries, renv will instead install a copy of that package
+  into the project library. (#636)
+
+* renv gains a new function, `renv::use()`, used to download, install, and
+  load a set of packages directly within an R script. `renv::use()` can make it
+  easier to share a standalone R script, with the packages required to install
+  that script embedded directly in the script. It is inspired in part by the
+  [groundhog](https://groundhogr.com/) package.
+
+* `renv::install(".")` can now be used to install a package from sources within
+  the current working directory. (#634)
+
+* Fixed an issue where `renv::update()` could fail if a package installed from
+  GitHub was missing the `RemoteHost` field in its DESCRIPTION file. (#632)
+
+* renv now has support for custom project profiles. Profiles can be used to
+  activate different sets of project libraries + lockfiles for different workflows
+  in a given project. See `vignette("profiles", package = "renv")` for more
+  details.
+  
+* Fixed an issue where attempts to initialize an renv project in a path
+  containing non-ASCII characters could fail on Windows. (#629)
+
+* Fixed an issue where `renv::install("<package>")` could fail if renv chose
+  to install the package from MRAN rather than from one of the active package
+  repositories. (#627)
+
+* renv again defaults to using the project's `renv/staging` folder for staged
+  / transactional installs. Use the `RENV_PATHS_LIBRARY_STAGING` environment
+  variable if more granular control over the staging library path is required.
+  This fixes issues on Windows with creating junction points to the global
+  package cache on Windows. (#584)
+  
+* renv no longer skips downloading a requested source package if an existing
+  cached download exists and appears to be valid. This should help avoid issues
+  when attempting to install a package whose associated tarball has changed
+  remotely. (#504)
+  
+* During bootstrap, renv will now attempt to download and unpack a binary
+  copy of renv if available from the specified package repositories.
+
+* renv now always attempts to bootstrap itself from the R Project's
+  Cloud package repository, as a fallback in case no other repository
+  is available. (#613)
+
+* `renv::rebuild(<package>)` now uses the latest-available version of the
+  requested package(s) if those packages are not currently installed.
+
+* Fixed an issue where `renv::restore(library = "/path/to/lib")` would fail to
+  restore packages, if those packages were already installed on the active
+  library paths (as reported by `.libPaths()`). (#612)
+  
+* `renv::snapshot()` gains the `reprex` argument. Set this to `TRUE` if you'd
+  like to embed an renv lockfile as part of a reproducible example, as
+  generated by the [`reprex`](https://www.tidyverse.org/help/#reprex-pkg)
+  package.
+  
+* `renv::status()` now reports packages that are referenced in a project's
+  scripts, but are neither installed in the project library nor recorded in the
+  lockfile. (#588)
+
+* Fixed an issue where package installation could fail if the `configure.vars`
+  option was set to be a named character, rather than a named list. (#609)
+
+
+# renv 0.12.5
+
+* Fixed an issue where renv would fail to bootstrap. (#608)
+
+
+# renv 0.12.4
+
+* renv now invalidates the available packages cache if the `https_proxy`
+  environment variable changes. (#579)
+  
+* `renv::install(<pkg>)` will now install the latest-available version of
+  that package from local sources, if that package is available and newer than
+  any package available on the active package repositories. (#591)
+
+* The configuration option `startup.quiet` has been added, allowing one to
+  control whether renv will display the typical startup banner when a
+  project is loaded.
+  
+* renv now better handles being unloaded and reloaded within the
+  same R session. In particular, warnings related to a corrupted
+  lazy-load database should no longer occur. (#600)
+
+* renv no longer reinstalls packages that are already installed and
+  up-to-date in bare calls to `renv::install()`.
+
+* renv now uses the R temporary directory for staging, when performing
+  transactional restores / installs. If you need to control the path used
+  for staged installs, please set the `RENV_PATHS_LIBRARY_STAGING` environment
+  variable.
+
+* The `install.verbose` configuration option has been added. When set to
+  `TRUE`, renv will stream the output generated by R when performing a
+  package installation. This can be helpful in some cases when diagnosing
+  a failed restore / install. (#330)
+  
+* Fixed an issue where renv could fail to parse R Markdown chunk headers
+  with an empty label. (#598)
+
+* The environment variable `RENV_PATHS_LIBRARY_ROOT_ASIS` can now be used
+  to control whether the project name should be used as-is when forming the
+  library path within the `RENV_PATHS_LIBRARY_ROOT` folder. Set this to
+  `"TRUE"` if you would prefer renv did not append a unique identifier
+  to your project's library path. (#593)
+  
+* Fixed an issue where GitLab references were not URL encoded. (#590)
+
+* renv no longer emits warnings when parsing multi-mode R files that make
+  use of re-used knitr chunks (those specified as `<<label>>`). (#586)
+
+* The library used for staged installs can now be configured via the
+  `RENV_PATHS_LIBRARY_STAGING` environment variable. (#584)
+  
+* Fixed an issue where bootstrapping an older version of renv could
+  fail if the R repositories had not been appropriately set.
+
+
+# renv 0.12.3
+
+* Fixed an issue where `renv::dependencies()` could give an error if called
+  with a `path` argument of length > 1.
+
+* `renv::restore()` gains the `rebuild` argument, allowing users to control
+  whether packages should be rebuilt on `restore()` rather than installed
+  via links or copies from the cache, or other sources providing
+  already-installed packages.
+
+* renv will now attempt to bootstrap itself from CRAN, in addition to any
+  repositories declared via `getOption("repos")`. If you'd prefer to disable
+  this behavior, you can set `options(renv.bootstrap.repos = character())`.
+
+* The renv setting `r.version` has been added. This can be set if you'd like
+  to associate a particular project with a specific version of R, independent
+  of the version of R actually used when subsequent lockfiles are created via
+  `renv::snapshot()`. For example, setting `renv::settings$r.version("4.0")`
+  will ensure that R version `"4.0"` is encoded in the lockfile for future
+  calls to `renv::snapshot()` in a project. (#254)
+
+* `renv::dependencies()` now detects the usage of R packages within dotfiles;
+  e.g. the project `.Rprofile`. (#569)
+
+* `renv::status()` gains the `cache` argument, used to control whether
+  `renv::status()` also performs diagnostics on the global package cache. (#570)
+
+* Fixed an issue where `renv::status()` would make an un-necessary call to
+  `renv::dependencies()`. (#570)
+
+* Fixed an issue where `renv::install("bioc::<package>", rebuild = TRUE)` would
+  fail to install the requested package. (#565)
+
+* Fixed an issue where the repository name for a package installed from
+  an R package repository was sometimes incorrect. (#402)
+
+* When `RENV_PATHS_LIBRARY_ROOT` is set, renv will now disambiguate library
+  paths based on a hash of the project's path. (#564)
+
+
+# renv 0.12.2
+
+* renv no longer errs when running tests with `_R_CHECK_SUGGESTS_ONLY_=false`.
+
+
+# renv 0.12.1
+
+* renv now ensures all of its dependencies are loaded eagerly when running
+  tests, to avoid issues with missing + lazily-loaded packages.
+
+* `renv::snapshot()` now accepts library paths specified with a relative
+  path. (#562)
+
+* `renv::snapshot()` no longer excludes the project itself, for `R` package
+  projects that use [golem](https://engineering-shiny.org/). (#538)
+  
+* The renv configuration option `cache.symlinks` can now be used to control
+  whether renv used symlinks into the cache, as opposed to full package
+  copies. Please see `?renv::config` for more details. (#556)
+
+* `renv::snapshot()` gains the `packages` argument, to be used when creating a
+  lockfile that captures a specific set of packages and their dependencies.
+  renv will use the currently-installed versions of those packages when
+  determining the package records to be written to the lockfile. (#554)
+  
+* `renv::dependencies()` now accepts an R function as the first argument,
+  for finding the packages used by a particular function. Currently,
+  package usages must be prefixed with `::` to be detected. (#554)
+
+* `renv::record(<package>)` now ensures that the latest-available version of
+  that package is recorded in the lockfile. Previously, a package record
+  without any specified version was added instead. For existing records
+  without a recorded version, the latest-available version on the package
+  repositories will be used during `restore()` instead. (#540)
+
+* renv now reads the default branch tagged for repositories created on GitHub,
+  ensuring that calls of the form `renv::install("<user>/<repo>")` resolve to
+  the declared default branch, rather than always defaulting to `"master"`.
+  (#557)
+
+* renv now only installs packages from sources if it detects that build tools
+  are available. This determination is done by checking whether `make` is
+  available on the `PATH`. (#552)
+  
+* Warnings related to unknown sources can now be suppressed by setting
+  `options(renv.warnings.unknown_sources = FALSE)`. (#546)
+
+* renv now ignores chunks with the parameter `exercise=TRUE` set, under the
+  assumption that such chunks might contain errors and so otherwise be
+  un-parsable.
+
+* renv now warns if sandbox generation takes a long time (> 30 seconds).
+
+* renv now provides an optional locking mechanism, to help minimize the
+  chance of interprocess conflicts when multiple R processes need to use the
+  same renv project. The option is currently disabled by default; it can be
+  enabled by setting `options(renv.config.locking.enabled = TRUE)` in an
+  appropriate R startup file. (#525)
+
+
+# renv 0.12.0
+
+* renv now uses R's internal tar implementation by default on Windows. This is
+  done to avoid issues that may occur when a version of `tar.exe` on the `PATH`
+  exists, but does not accept Windows-style paths. The `TAR` environment
+  variable can be set if one needs to explicitly force the use of a particular
+  `tar.exe` executable. (#521)
+
+* renv now prepends `renv (<version>)` to the user agent string. This should
+  help ensure that package binaries are located when installing packages from
+  RSPM outside of RStudio. (#520)
+
+* renv now uses a task callback to detect mutations to the project library
+  when the `auto.snapshot` configuration option is enabled. This will help
+  ensure that automatic snapshots occur when packages are installed via a
+  mechanism not explicitly understood by renv. (#501)
+
+* renv now treats the user + site libraries as package sources during a
+  restore. If renv sees that a package already installed in one of these
+  libraries is compatible with the record requested via `renv::install()` or
+  `renv::restore()`, that copy of the package will be copied and used. (#492)
+  
+* renv now performs a lighter-weight check as to whether the project lockfile
+  is synchronized with the project library on load. The default value for the
+  `synchronized.check` config option has been changed back to `TRUE`. (#496)
+
+* renv now handles the `remotes` syntax for installing packages lying within
+  the sub-directory of a GitHub repository; that is,
+  `renv::install("user/repo/subdir")` should work as expected. (#497)
+
+* Fixed an issue where renv did not construct the correct URL for packages to
+  be installed from Bitbucket remotes. (#494)
+
+* Fixed an issue where the `RENV_PATHS_PREFIX` environment variable was
+  inappropriately normalized when renv was loaded. (#465)
+  
+
+# renv 0.11.0
+
+* Fixed an issue where `renv::install(..., type = "binary")` would
+  still attempt to install packages from sources in some cases. (#461)
+  
+* renv now always writes `renv/.gitignore`, to ensure that the appropriate
+  directories are ignored for projects which initialize `git` after renv
+  itself is initialized. (#462)
+
+* R Markdown documents with the `.Rmarkdown` file extension are now parsed for
+  dependencies.
+
+* Fixed an issue where setting the `external.libraries` configuration option
+  would trigger a warning. (#452)
+
+* Improved handling of unicode paths on Windows. (#451)
+
+* `renv::snapshot(project = <path>)` now properly respects `.gitignore` /
+  `.renvignore` files, even when that project has not yet been explicitly
+  initialized yet. (#439)
+  
+* The default value of the `synchronized.check` option has been changed from
+  TRUE to FALSE.
+
+* Fixed an issue where packages downloaded from Bitbucket and GitLab did not
+  record the associated commit hash.
+
+* Fixed an issue where attempting to install packages from GitLab could fail
+  to install the correct version of the package. (#436)
+
+* `renv::snapshot()` now preserves records in a lockfile that are only
+  available for a different operating system. This should make it easier
+  to share lockfiles that make use of platform-specific packages. (#419)
+
+* renv better handles files that are removed during an invocation to
+  `renv::dependencies()`. (#429)
+
+* The configuration option `install.staged` has been renamed to
+  `install.transactional`, to better reflect its purpose. `install.staged`
+  remains supported as a deprecated alias.
+
+* Fixed an issue where renv could fail to parse non-ASCII content on Windows.
+  (#421)
+
+* `renv::update()` gains the `exclude` argument, useful in cases where one
+  would like to update all packages used in a project, except for a small
+  subset of excluded packages. (#425)
+
+* `renv::update()` now respects the project `ignored.packages` setting. (#425)
+
+* Fixed an issue where RSPM binary URL transformations could fail for
+  Ubuntu Trusty. (#423)
+
+* renv now records the `OS_type` reported in a package's `DESCRIPTION` file
+  (if any), and ignores packages incompatible with the current operating
+  system during restore. (#394)
+
+
+# renv 0.10.0
+
+* `renv::install()` gains the `type` argument, used to control whether renv
+  should attempt to install packages from sources (`"source"`) or using
+  binaries (`"binary"`).
+
+* renv now knows how to find and activate Rtools40, for R 4.0.0 installations
+  on Windows.
+
+* The `RENV_PATHS_PREFIX` environment variable can now be used to prepend an
+  optional path component to the project library and global cache paths.
+  This is primarily useful for users who want to share the renv cache across
+  multiple operating systems on Linux, but need to disambigutate these paths
+  according to the operating system in use. See `?renv::paths` for more details.
+  
+* Fixed an issue where `renv::install()` could fail for packages from GitHub
+  whose DESCRIPTION files contained Windows-style line endings. (#408)
+
+* `renv::update()` now also checks and updates any Bioconductor packages
+  used within a project. (#392)
+
+* renv now properly parses negated entries within a `.gitignore`; e.g.
+  `!script.R` will indicate that renv should include `script.R` when
+  parsing dependencies. (#403)
+
+* Fixed an issue where packages which had only binaries available on a
+  package repository were not detected as being from a package repository.
+  (#402)
+
+* Fixed an issue where calls of the form `p_load(char = <vctr>)` caused a
+  failure when enumerating dependencies. (#401)
+
+* Fixed an issue where `renv::install()` could fail when multiple versions
+  of a package are available from a single repository, but some versions of
+  those packages are incompatible with the current version of R. (#252)
+
+* Fixed an issue where downloads could fail when the associated pre-flight
+  HEAD request failed as well. (#390)
+
+* Fixed an issue where empty records within a DESCRIPTION file could cause
+  `renv::dependencies()` to fail. (#382)
+
+* renv will now download binaries of older packages from MRAN when possible.
+
+* renv will now attempt to re-generate the system library sandbox if it is
+  deleted while a session is active. (#361)
+
+* Fixed an issue where Python packages referenced using `reticulate::import()`
+  were incorrectly tagged as R package dependencies. Similarly, renv now only
+  considers calls to `modules::import()` if those calls occur within a call to
+  `modules::module()`. (#359)
+
+* `renv::scaffold()` now also generates a lockfile when invoked. (#351)
+
+* The argument `confirm` has been renamed to `prompt` in all places where it
+  is used. `confirm` remains supported for backwards compatibility, but is no
+  longer explicitly documented. (#347)
+
+* The continuous integration renv vignette now also contains a template for
+  using renv together with GitLab CI. (#348, @artemklevtsov)
+
+* renv now properly resets the session library paths when calling
+  `renv::deactivate()` from within RStudio. (#219)
+  
+* `renv::init()` now restores the associated project library when called in a
+  project containing a lockfile but no project library nor any pre-existing
+  project infrastructure.
+
+* Fixed an issue on Windows where attempts to download packages from package
+  repositories referenced with a `file://` scheme could fail.
+  
+* The configuration option `dependency.errors` has been added, controlling how
+  errors are handled during dependency enumeration. This is used, for
+  example, when enumerating dependencies during a call to `renv::snapshot()`.
+  By default, errors are reported, and (for interactive sessions) the user is
+  prompted to continue. (#342)
+  
+* `renv::dependencies()` gains two new arguments: the `progress` argument
+  controls whether renv reports progress while enumerating dependencies,
+  and `errors` controls how renv handles and reports errors encountered
+  during dependency discovery. The `quiet` argument is now soft-deprecated,
+  but continues to be supported for backwards compatibility. Specifying
+  `quiet = TRUE` is equivalent to specifying `progress = FALSE` and
+  `errors = "ignored"`. Please see the documentation in `?dependencies`
+  for more details. (#342)
+  
+* The environment variable `RENV_PATHS_LIBRARY_ROOT` can now be set, to
+  instruct renv to use a particular directory as a host for any project
+  libraries that are used by renv. This can be useful for certain cases
+  where it is cumbersome to include the project library within the project
+  itself; for example, when developing an R package. (#345)
+
+* The code used to bootstrap renv (that is, the code used to install renv
+  into a project) has been overhauled. (#344)
+
+* renv no longer unsets an error handler set within the user profile when
+  loading a project. (#343)
+
+* renv gains the "explicit" snapshot type, wherein only packages explicitly
+  listed as dependencies within the project `DESCRIPTION` file (and those
+  package's transitive dependencies) will enter the lockfile when
+  `renv::snapshot()` is called. (#338)
+
+* renv will now transform RSPM source URLs into binary URLs as appropriate,
+  allowing renv to use RSPM's binary repositories during restore. See
+  `?config` for more details. (#124)
+
+* renv will now infer a dependency on `hexbin` in projects that make
+  use of the `ggplot2::geom_hex()` function.
+
+* renv now tries to place Rtools on the PATH when a package is installed
+  with the `install.packages()` hook active. (#335)
+
+
+# renv 0.9.3
+
+* Fixed an issue where attempts to specify `RENV_PATHS_RTOOLS` would
+  be ignored by renv. (#335)
+
+* Fixed an issue where downloads could fail when using the `wininet`
+  downloader, typically with a message of the form
+  "InternetOpenUrl failed: 'The requested header was not found'".
+
+* renv better handles projects containing special characters on Windows.
+  (#334)
+
+* renv better handles unnamed repositories. (#333)
+
+* renv gains the config option `hydrate.libpaths`, allowing one to control
+  the library paths used by default for `renv::hydrate()`. (#329)
+
+* `renv::hydrate()` gains the `sources` argument, used to control the library
+  paths used by renv when hydrating a project. (#329)
+  
+* renv now sandboxes the system library by default on Windows.
+
+* renv now validates that the Xcode license has been accepted before
+  attempting to install R packages from sources. (#296)
+  
+* The R option `renv.download.override` can now be used to override the
+  machinery used by renv when downloading files. For example, setting
+  `options(renv.download.override = utils::download.file)` would instruct
+  renv to use R's own downloader when downloading files from the internet.
+  This can be useful when configuration of `curl` is challenging or
+  intractable in your environment, or you've already configured the base
+  R downloader suitably.
+
+* `renv::use_python("~/path/to/python")` now works as expected.
+
+* renv now properly expands `R_LIBS_SITE` and `R_LIBS_USER` when set within a
+  startup `.Renviron` file. (#318)
+
+* The `renv.download.headers` option can now be used to provide arbitrary HTTP
+  headers when downloading files. See the **Authentication** section in
+  `vignette("renv")` for more details. (#307)
+
+* renv gains the project setting `package.dependency.fields`, for controlling
+  which fields in an R package's `DESCRIPTION` file are examined when
+  discovering recursive package dependencies. This can be useful when you'd like
+  to instruct renv to track, for example, the `Suggests` dependencies of the
+  packages used in your project. (#315)
+
+* renv now better handles repositories referenced using file URIs.
+
+* Packages installed from GitHub using `renv::install()` will now also have
+  `Github*` fields added, in addition to the default `Remote*` fields. This
+  should help fix issues when attempting to deploy projects to RStudio Connect
+  requiring packages installed by renv. (#397)
+  
+* renv now prefers using a RemoteType field (if any) when attempting to
+  determine a package's source. (#306)
+
+* renv gains a new function `renv::scaffold()`, for generating renv project
+  infrastructure without explicitly loading the project. (#303)
+
+* renv now updates its local `.gitignore` file, when part of a git repository
+  whose git root lives in a parent directory. (#300)
+
+
+# renv 0.9.2
+
+* Fixed an issue in invoking `find` on Solaris.
+
+
+# renv 0.9.1
+
+* Fixed an issue in invoking `cp` on Solaris.
+
+
+# renv 0.9.0
+
+* renv gains a new function `renv::record()`, for recording new packages
+  within an existing lockfile. This can be useful when one or more of the
+  recorded packages need to be modified for some reason.
+
+* An empty `.renvignore` no longer erroneously ignores all files within a
+  directory. (#286)
+
+* renv now warns if the version of renv loaded within a project does not
+  match the version declared within the renv autoloader. (#285)
+
+* renv gains a new function `renv::run()`, for running R scripts within
+  a particular project's context inside an R subprocess. (#126)
+
+* The algorithm used by renv for hashing packages has changed. Consider 
+  using `renv::rehash()` to migrate packages from the old renv cache to
+  the new renv cache.
+
+* `renv::status()` now reports packages which are referenced in your project
+  code, but are not currently installed. (#271)
+
+* renv is now able to restore packages with a recorded URL remote. (#272)
+
+* `renv::dependencies()` can now parse R package dependencies used as custom
+  site generator in an Rmd yaml header. (#269, @cderv)
+
+* renv now properly respects a downloader requested by the environment
+  variable `RENV_DOWNLOAD_FILE_METHOD`.
+
+* renv no longer sources the user profile (normally located at `~/.Rprofile`)
+  by default. If you desire this behavior, you can opt-in by setting
+  `RENV_CONFIG_USER_PROFILE = TRUE`; e.g. within your project or user
+  `.Renviron` file. (#261)
+
+* `renv::restore()` gains the `packages` argument, to be used to restore
+  a subset of packages recorded within the lockfile. (#260)
+
+* renv now tries harder to preserve the existing structure in infrastructure
+  files (e.g. the project `.Rprofile`) that it modifies. (#259)
+
+* renv now warns if any Bioconductor packages used in the project appear
+  to be from a different Bioconductor release than the one currently active
+  and stored in the lockfile. (#244)
+
+* renv now normalizes any paths set in the `RENV_PATHS_*` family of
+  environment variables when renv is loaded.
+
+* Fixed an issue where renv would not properly clean up after a failed
+  attempt to call `Sys.junction()`. (#251)
+
+* Fixed an issue where renv would, in some cases, copy rather than link from
+  the package cache when the library path had been customized with the
+  `RENV_PATHS_LIBRARY` environment variable. (#245)
+
+* The method renv uses when copying directories can now be customized. When
+  copying directories, renv now by default uses `robocopy` on Windows, and
+  `cp` on Unix. This should improve robustness when attempting to copy files
+  in some contexts; e.g. when copying across network shares.
+
+* renv now tracks the version of Bioconductor used within a project
+  (if applicable), and uses that when retrieving the set of repositories
+  to be used during `renv::restore()`.
+
+* `renv::dependencies()` can now parse R package dependencies declared and
+  used by the `modules` package. (#238, @labriola)
+
+* Fixed an issue where `renv::restore()` could fail in Docker environments,
+  usually with an error message like 'Invalid cross-device link'. (#243)
+
+* `renv::install()` disables staged package install when running with the
+  Windows Subsystem for Linux. (#239)
+
+
+# renv 0.8.3
+
+* `renv::dependencies()` gains a new argument `dev`, indicating whether
+  development dependencies should also be included in the set of discovered
+  package dependencies. By default, only runtime dependencies will be reported.
+
+* renv has gained the function `renv::diagnostics()`, which can occasionally
+  be useful in understanding and diagnosing renv (mis)behaviors.
+
+* `renv::equip()` can now be used on macOS to install the R LLVM toolchain
+  normally used when compiling packages from source. renv will also use
+  this toolchain as appropriate when building packages from source.
+
+* `renv::install()` now provides a custom Makevars when building packages on
+  macOS with Apple Clang, to avoid issues due to the use of '-fopenmp' during
+  compilation.
+
+* `renv::install()` now respects explicit version requests when discovered
+  in a project's DESCRIPTION file. (#233)
+
+* Fixed an issue where `renv:::actions()` would fail to report any actions if
+  the project lockfile was empty. (#232)
+
+* When using renv for R package development, renv will no longer attempt to
+  write the package being developed to the lockfile. (#231)
+
+* Fixes for checks run on CRAN.
+
+* renv will now search for Rtools in more locations. (#225)
+
+* `renv::load()` now ensures that the version of renv associated with
+  the loaded project is loaded when possible. In addition, experimental
+  support for switching between projects with `renv::load()` has been
+  implemented. (#229)
+
+* `renv::dependencies()` no longer treats folders named with the extension
+  `.Rmd` as though they were regular files. (#228)
+
+* It is now possible to install source packages contained within `.zip`
+  archives using `renv::install()`.
+
+* Fixed an issue where attempts to call `renv::restore()` with the path to the
+  lockfile explicitly provided would fail. (#227)
+
+
+# renv 0.8.2
+
+* Further fixes for checks run on CRAN.
+
+
+# renv 0.8.1
+
+* Fixes for checks run on CRAN.
+
+
+# renv 0.8.0
+
+* Initial CRAN release.
+

renv/library/windows/R-4.5/x86_64-w64-mingw32/renv/R/renv

@@ -0,0 +1,27 @@
+#  File share/R/nspackloader.R
+#  Part of the R package, https://www.R-project.org
+#
+#  Copyright (C) 1995-2012 The R Core Team
+#
+#  This program is free software; you can redistribute it and/or modify
+#  it under the terms of the GNU General Public License as published by
+#  the Free Software Foundation; either version 2 of the License, or
+#  (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  A copy of the GNU General Public License is available at
+#  https://www.r-project.org/Licenses/
+
+local({
+    info <- loadingNamespaceInfo()
+    pkg <- info$pkgname
+    ns <- .getNamespace(as.name(pkg))
+    if (is.null(ns))
+        stop("cannot find namespace environment for ", pkg, domain = NA);
+    dbbase <- file.path(info$libname, pkg, "R", pkg)
+    lazyLoad(dbbase, ns, filter = function(n) n != ".__NAMESPACE__.")
+})

renv/library/windows/R-4.5/x86_64-w64-mingw32/renv/R/renv.rdb

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a5d8029d4b03fcaa47769f85a84f67f0ea025563e16e7aea01f4778f56126e63
+size 1293590

renv/library/windows/R-4.5/x86_64-w64-mingw32/renv/bin/renv

@@ -0,0 +1,8 @@
+#!/usr/bin/env sh
+
+if [ -z "${RENV_CONFIG_SYNCHRONIZED_CHECK}" ]; then
+  RENV_CONFIG_SYNCHRONIZED_CHECK=FALSE
+  export RENV_CONFIG_SYNCHRONIZED_CHECK
+fi
+
+R --no-save --no-restore -s -e "renv:::renv_cli_exec()" --args "$@"

renv/library/windows/R-4.5/x86_64-w64-mingw32/renv/bin/renv.bat

@@ -0,0 +1,2 @@
+set "RENV_CONFIG_SYNCHRONIZED_CHECK=FALSE"
+R --no-save --no-restore -s -e "renv:::renv_cli_exec()" --args %*

renv/library/windows/R-4.5/x86_64-w64-mingw32/renv/config.yml

@@ -0,0 +1,373 @@
+
+- name: "activate.prompt"
+  type: "logical[1]"
+  default: true
+  description: >
+    Automatically prompt the user to activate the current project, if it does
+    not appear to already be activated? This is mainly useful to help ensure
+    that calls to `renv::snapshot()` and `renv::restore()` use the project
+    library. See `?renv::activate` for more details.
+
+- name: "autoloader.enabled"
+  type: "logical[1]"
+  default: true
+  description: >
+    Enable the renv auto-loader? When `FALSE`, renv will not
+    automatically load a project containing an renv autoloader within
+    its `.Rprofile`. In addition, renv will not write out the project
+    auto-loader in calls to `renv::init()`.
+
+- name: "auto.snapshot"
+  type: "logical[1]"
+  default: false
+  description: >
+    Automatically snapshot changes to the project library when the project
+    dependencies change?
+
+- name: "bitbucket.host"
+  type: "character[1]"
+  default: "api.bitbucket.org/2.0"
+  description: >
+    The default Bitbucket host to be used during package retrieval.
+
+- name: "copy.method"
+  type: "*"
+  default: "auto"
+  description: >
+    The method to use when attempting to copy directories. See **Copy Methods**
+    for more information.
+
+- name: "connect.timeout"
+  type: "integer[1]"
+  default: 20
+  description: >
+    The amount of time to spend (in seconds) when attempting to download
+    a file. Only applicable when the `curl` downloader is used.
+
+- name: "connect.retry"
+  type: "integer[1]"
+  default: 3
+  description: >
+    The number of times to attempt re-downloading a file, when transient
+    download errors occur. Only applicable when the `curl` downloader is used.
+
+- name: "cache.enabled"
+  type: "logical[1]"
+  default: true
+  description: >
+    Enable the global renv package cache? When active, renv will install
+    packages into a global cache, and link or copy packages from the cache
+    into your \R library as appropriate. This can greatly save on disk space
+    and install time when \R packages are shared across multiple projects in
+    the same environment.
+
+- name: "cache.symlinks"
+  type: "logical[1]"
+  code: >
+    .Platform$OS.type == "unix"
+  description: >
+    Symlink packages from the global renv package cache into your project
+    library? When `TRUE`, renv will use symlinks (or, on Windows, junction
+    points) to reference packages installed in the cache. Set this to `FALSE`
+    if you'd prefer to copy packages from the cache into your project library.
+    Enabled by default, except on Windows where this feature is only enabled
+    if the project library and global package cache are on the same volume.
+
+- name: "dependency.errors"
+  type: "character[1]"
+  default: "reported"
+  description: >
+    Many renv APIs require the enumeration of your project's \R package
+    dependencies. This option controls how errors that occur during this enumeration
+    are handled. By default, errors are reported but are non-fatal. Set this to `"fatal"`
+    to force errors to be fatal, and `"ignored"` to ignore errors altogether. See
+    [`dependencies()`] for more details.
+
+- name: "dependencies.limit"
+  type: "integer[1]"
+  default: 1000
+  description: >
+    By default, renv reports if it discovers more than this many files when
+    looking for dependencies, as that may indicate you are running
+    `dependencies()` in the wrong place. Set to `Inf` to disable this warning.
+
+- name: "exported.functions"
+  type: "character[*]"
+  default: "*"
+  description: >
+    When `library(renv)` is called, should its exports be placed on the search
+    path? Set this to `FALSE` to avoid issues that can arise with, for example,
+    `renv::load()` masking `base::load()`. In general, we recommend referencing
+    renv functions from its namespace explicitly; e.g. prefer
+    `renv::snapshot()` over `snapshot()`.
+
+    By default, all exported renv functions are attached and placed on the
+    search path, for backwards compatibility with existing scripts using renv.
+
+
+- name: "external.libraries"
+  type: "character[*]"
+  default: ~
+  description: >
+    A character vector of external libraries, to be used in tandem with
+    your projects. Be careful when using external libraries: it's possible that things
+    can break within a project if the version(s) of packages used in your project
+    library happen to be incompatible with packages in your external libraries; for
+    example, if your project required `xyz 1.0` but `xyz 1.1` was present and loaded
+    from an external library. Can also be an \R function that provides the paths to
+    external libraries. Library paths will be expanded via [`.expand_R_libs_env_var()`]
+    as necessary.
+
+- name: "filebacked.cache"
+  type: "logical[1]"
+  default: true
+  description: >
+    Enable the renv file-backed cache? When enabled, renv will cache the
+    contents of files that are read (e.g. DESCRIPTION files) in memory, thereby
+    avoiding re-reading the file contents from the filesystem if the file has
+    not changed. renv uses the file `mtime` to determine if the file has
+    changed; consider disabling this if `mtime` is unreliable on your system.
+
+- name: "github.host"
+  type: "character[1]"
+  default: "api.github.com"
+  description: >
+    The default GitHub host to be used during package retrieval.
+
+- name: "gitlab.host"
+  type: "character[1]"
+  default: "gitlab.com"
+  description: >
+    The default GitLab host to be used during package retrieval.
+
+- name: "hydrate.libpaths"
+  type: "character[*]"
+  default: ~
+  description: >
+    A character vector of library paths, to be used by [hydrate()]
+    when attempting to hydrate projects. When empty, the default set of library paths
+    (as documented in `?renv::hydrate`) are used instead. See [`hydrate()`] for more details.
+
+- name: "install.build"
+  type: "logical[1]"
+  default: false
+  description: >
+    Should downloaded package archives be built (via `R CMD build`) before installation?
+    When TRUE, package vignettes will also be built as part of package installation.
+    Because building packages before installation may require packages within 'Suggests'
+    to be available, this option is not enabled by default.
+
+- name: "install.remotes"
+  type: "logical[1]"
+  default: true
+  description: >
+    Should renv read a package's `Remotes:` field when determining how
+    package dependencies should be installed?
+
+- name: "install.shortcuts"
+  type: "logical[1]"
+  default: true
+  description: >
+    Allow for a set of 'shortcuts' when installing packages with renv? When
+    enabled, if renv discovers that a package to be installed is already
+    available within the user or site libraries, then it will install a
+    local copy of that package.
+
+- name: "install.staged"
+  type: "logical[1]"
+  default: true
+  description: >
+    DEPRECATED: Please use `renv.config.install.transactional` instead.
+
+- name: "install.transactional"
+  type: "logical[1]"
+  default: true
+  description: >
+    Perform a transactional install of packages during install and restore? When
+    enabled, renv will first install packages into a temporary library, and later
+    copy or move those packages back into the project library only if all packages
+    were successfully downloaded and installed. This can be useful if you'd like to
+    avoid mutating your project library if installation of one or more packages fails.
+
+- name: "install.verbose"
+  type: "logical[1]"
+  default: false
+  description: >
+    Be verbose when installing R packages from sources? When `TRUE`, renv will
+    stream any output generated during package build + installation to the console.
+
+- name: "locking.enabled"
+  type: "logical[1]"
+  default: false
+  description: >
+    Use interprocess locks when invoking methods which might mutate the project
+    library? Enable this to allow multiple processes to use the same renv
+    project, while minimizing risks relating to concurrent access to the
+    project library. Disable this if you encounter locking issues. Locks are stored
+    as files within the project at `renv/lock`; if you need to manually remove a
+    stale lock you can do so via `unlink("renv/lock", recursive = TRUE)`.
+
+- name: "mran.enabled"
+  type: "logical[1]"
+  default: false
+  description: >
+    DEPRECATED: MRAN is no longer maintained by Microsoft.
+
+- name: "pak.enabled"
+  type: "logical[1]"
+  default: false
+  description: >
+    Use the [pak](https://pak.r-lib.org/) package to install packages?
+
+- name: "ppm.enabled"
+  type: "logical[1]"
+  default: true
+  description: >
+    Boolean; enable [Posit Package Manager](https://packagemanager.posit.co/)
+    integration in renv projects? When `TRUE`, renv will attempt to transform
+    repository URLs used by PPM into binary URLs as appropriate for the
+    current Linux platform. Set this to `FALSE` if you'd like to continue using
+    source-only PPM URLs, or if you find that renv is improperly transforming
+    your repository URLs. You can still set and use PPM repositories with this
+    option disabled; it only controls whether renv tries to transform source
+    repository URLs into binary URLs on your behalf.
+
+- name: "ppm.default"
+  type: "logical[1]"
+  default: true
+  description: >
+    Boolean; should new projects use the
+    [Posit Public Package Manager](https://packagemanager.posit.co/)
+    instance by default? When `TRUE` (the default), projects initialized with
+    `renv::init()` will use the P3M instance if the `repos` R option has not
+    already been set by some other means (for example, in a startup `.Rprofile`).
+
+- name: "ppm.url"
+  type: "character[1]"
+  default: "https://packagemanager.posit.co/cran/latest"
+  description: >
+    The default PPM URL to be used for new renv projects. Defaults to the
+    CRAN mirror maintained by Posit at <https://packagemanager.posit.co/>.
+    This option can be changed if you'd like renv to use an alternate package manager instance.
+
+- name: "repos.override"
+  type: "character[*]"
+  default: ~
+  description: >
+    Override the R package repositories used during [`restore()`]? Primarily
+    useful for deployment / continuous integration, where you might want to enforce
+    the usage of some set of repositories over what is defined in `renv.lock` or otherwise
+    set by the R session.
+
+- name: "rspm.enabled"
+  type: "logical[1]"
+  default: true
+  description: >
+    DEPRECATED: Please use `renv.config.ppm.enabled` instead.
+
+- name: "sandbox.enabled"
+  type: "logical[1]"
+  default: true
+  description: >
+    Enable sandboxing for renv projects? When active, renv will attempt
+    to sandbox the system library, preventing non-system packages installed in the
+    system library from becoming available in renv projects. (That is, only packages
+    with priority `"base"` or `"recommended"`, as reported by `installed.packages()`,
+    are made available.)
+
+    Sandboxing is done by linking or copying system packages into a separate
+    library path, and then instructing R to use that library path as the system
+    library path. In some environments, this action can take a large amount of
+    time -- in such a case, you may want to disable the renv sandbox.
+
+- name: "shims.enabled"
+  type: "logical[1]"
+  default: true
+  description: >
+    Should renv shims be installed on package load? When enabled, renv
+    will install its own shims over the functions `install.packages()`, `update.packages()`
+    and `remove.packages()`, delegating these functions to [`renv::install()`],
+    [`renv::update()`] and [`renv::remove()`] as appropriate.
+
+- name: "snapshot.inference"
+  type: "logical[1]"
+  default: true
+  description: >
+    For packages which were installed from local sources, should renv try to infer the
+    package's remote from its DESCRIPTION file? When `TRUE`, renv will check and prompt
+    you to update the package's DESCRIPTION file if the remote source can be ascertained.
+    Currently, this is only implemented for packages hosted on GitHub. Note that this
+    check is only performed in interactive R sessions.
+
+- name: "snapshot.validate"
+  type: "logical[1]"
+  default: true
+  description: >
+    Validate \R package dependencies when calling snapshot? When `TRUE`,
+    renv will attempt to diagnose potential issues in the project library before
+    creating `renv.lock` -- for example, if a package installed in the project library
+    depends on a package which is not currently installed.
+
+- name: "startup.quiet"
+  type: "logical[1]"
+  default: ~
+  description: >
+    Be quiet during startup? When set, renv will not display the typical
+    `Project <path> loaded. [renv <version>]` banner on startup.
+
+- name: "synchronized.check"
+  type: "logical[1]"
+  default: true
+  description: >
+    Check that the project library is synchronized with the lockfile on load?
+
+- name: "sysreqs.check"
+  type: "logical[1]"
+  default: true
+  description: >
+    Check whether the requisite system packages are installed during package
+    installation and restore? This feature uses the R System Requirements
+    database maintained at <https://github.com/rstudio/r-system-requirements>.
+
+- name: "updates.check"
+  type: "logical[1]"
+  default: false
+  description: >
+    Check for package updates when the session is initialized? This can
+    be useful if you'd like to ensure that your project lockfile remains up-to-date
+    with packages as they are released on CRAN.
+
+- name: "updates.parallel"
+  type: "*"
+  default: 2
+  description: >
+    Check for package updates in parallel? This can be useful when a large
+    number of packages installed from non-CRAN remotes are installed, as these packages
+    can then be checked for updates in parallel.
+
+- name: "user.environ"
+  type: "logical[1]"
+  default: true
+  description: >
+    Load the user R environ (typically located at `~/.Renviron`) when renv
+    is loaded?
+
+- name: "user.library"
+  type: "logical[1]"
+  default: false
+  description: >
+    Include the system library on the library paths for your projects? Note
+    that this risks breaking project encapsulation and is not recommended for projects
+    which you intend to share or collaborate on with other users. See also the caveats
+    for the `renv.config.external.libraries` option.
+
+- name: "user.profile"
+  type: "logical[1]"
+  default: false
+  description: >
+    Load the user R profile (typically located at `~/.Rprofile`) when renv
+    is loaded? This is disabled by default, as running arbitrary code from
+    the the user `~/.Rprofile` could risk breaking project encapsulation.
+    If your goal is to set environment variables that are visible within all
+    renv projects, then placing those in `~/.Renviron` is often a better
+    choice.

renv/library/windows/R-4.5/x86_64-w64-mingw32/renv/doc/ci.R

@@ -0,0 +1,7 @@
+## ----include=FALSE------------------------------------------------------------
+knitr::opts_chunk$set(
+  collapse = TRUE,
+  comment = "#>",
+  eval = FALSE
+)
+

renv/library/windows/R-4.5/x86_64-w64-mingw32/renv/doc/ci.Rmd

@@ -0,0 +1,118 @@
+---
+title: "Using renv with continuous integration"
+output: rmarkdown::html_vignette
+vignette: >
+  %\VignetteIndexEntry{Using renv with continuous integration}
+  %\VignetteEngine{knitr::rmarkdown}
+  %\VignetteEncoding{UTF-8}
+---
+
+```{r, include=FALSE}
+knitr::opts_chunk$set(
+  collapse = TRUE,
+  comment = "#>",
+  eval = FALSE
+)
+```
+
+When building, deploying, or testing an renv-using project with continuous 
+integration (CI) systems (e.g. [GitHub Actions][github-actions],
+[GitLab CI][gitlab-ci], and others) you need some way to tell the CI system
+to use renv to restore the same packages that you're using locally.
+
+The general idea is:
+
+1. Call `renv::snapshot()` on your local machine to generate `renv.lock`.
+
+2. Call `renv::restore()` on your CI service to restore the project library
+   from `renv.lock`.
+
+3. Cache the project library and global renv cache on the CI service.
+
+Note that this workflow is not generally a good fit for CRAN packages, because 
+CRAN itself runs `R CMD check` using the latest version of all dependencies.
+
+## GitHub actions
+
+Here, we describe two common approaches for integrating renv with a [GitHub Actions](https://github.com/features/actions) workflow:
+
+* Use the `r-lib/setup-renv` action.
+* Use GitHub's built-in cache action together with existing renv functionality;
+
+### Using r-lib/actions/setup-renv
+
+The r-lib organization offers some actions for R users, and among them a [`setup-renv`][r-lib-actions-renv] action is provided for projects using renv. To use this action, you can add the following steps to your workflow: 
+
+```yaml
+steps:
+- uses: actions/checkout@v3
+- uses: r-lib/actions/setup-r@v2
+- uses: r-lib/actions/setup-renv@v2
+```
+
+Using these steps will automatically perform the following actions:
+
+* renv will be installed, via `install.packages("renv")`,
+* renv will be configured to use the GitHub cache,
+* If provided via a `with: profile:` key, that renv profile will be activated,
+* The project will be restored via `renv::restore()`.
+
+After this, any steps using R will use the active renv project by default.
+
+### Using the GitHub Actions Cache with renv
+
+When using renv in your own custom GitHub action workflow, there are two main requirements:
+
+1. Cache any packages installed by renv across runs, 
+2. Use `renv::restore()` to restore packages using this cache to speed up installation
+
+As an example, these steps might look like:
+
+```yaml
+env:
+  RENV_PATHS_ROOT: ~/.cache/R/renv
+
+steps:
+
+- name: Cache packages
+  uses: actions/cache@v1
+  with:
+    path: ${{ env.RENV_PATHS_ROOT }}
+    key: ${{ runner.os }}-renv-${{ hashFiles('**/renv.lock') }}
+    restore-keys: |
+      ${{ runner.os }}-renv-
+
+- name: Restore packages
+  shell: Rscript {0}
+  run: |
+    if (!requireNamespace("renv", quietly = TRUE)) install.packages("renv")
+    renv::restore()
+```
+
+See also the [example][github-actions-renv] on GitHub actions.
+
+## GitLab CI
+
+The following template can be used as a base when using renv with
+[GitLab CI][gitlab-ci]:
+
+```yaml
+variables:
+  RENV_PATHS_ROOT: ${CI_PROJECT_DIR}/renv
+
+cache:
+  key: ${CI_PROJECT_NAME}
+  paths:
+    - ${RENV_PATHS_ROOT}
+
+before_script:
+  - < ... other pre-deploy steps ... >
+  - Rscript -e "if (!requireNamespace('renv', quietly = TRUE)) install.packages('renv')"
+  - Rscript -e "renv::restore()"
+```
+
+
+[gitlab-ci]: https://about.gitlab.com/solutions/continuous-integration/
+[github-actions]: https://github.com/features/actions
+[github-actions-renv]: https://github.com/actions/cache/blob/main/examples.md#r---renv
+[r-lib-actions-renv]: https://github.com/r-lib/actions/tree/v2-branch/setup-renv

renv/library/windows/R-4.5/x86_64-w64-mingw32/renv/doc/ci.html

@@ -0,0 +1,459 @@
+<!DOCTYPE html>
+
+<html>
+
+<head>
+
+<meta charset="utf-8" />
+<meta name="generator" content="pandoc" />
+<meta http-equiv="X-UA-Compatible" content="IE=EDGE" />
+
+<meta name="viewport" content="width=device-width, initial-scale=1" />
+
+
+
+<title>Using renv with continuous integration</title>
+
+<script>// Pandoc 2.9 adds attributes on both header and div. We remove the former (to
+// be compatible with the behavior of Pandoc < 2.8).
+document.addEventListener('DOMContentLoaded', function(e) {
+  var hs = document.querySelectorAll("div.section[class*='level'] > :first-child");
+  var i, h, a;
+  for (i = 0; i < hs.length; i++) {
+    h = hs[i];
+    if (!/^h[1-6]$/i.test(h.tagName)) continue;  // it should be a header h1-h6
+    a = h.attributes;
+    while (a.length > 0) h.removeAttribute(a[0].name);
+  }
+});
+</script>
+
+<style type="text/css">
+code{white-space: pre-wrap;}
+span.smallcaps{font-variant: small-caps;}
+span.underline{text-decoration: underline;}
+div.column{display: inline-block; vertical-align: top; width: 50%;}
+div.hanging-indent{margin-left: 1.5em; text-indent: -1.5em;}
+ul.task-list{list-style: none;}
+</style>
+
+
+
+<style type="text/css">
+code {
+white-space: pre;
+}
+.sourceCode {
+overflow: visible;
+}
+</style>
+<style type="text/css" data-origin="pandoc">
+html { -webkit-text-size-adjust: 100%; }
+pre > code.sourceCode { white-space: pre; position: relative; }
+pre > code.sourceCode > span { display: inline-block; line-height: 1.25; }
+pre > code.sourceCode > span:empty { height: 1.2em; }
+.sourceCode { overflow: visible; }
+code.sourceCode > span { color: inherit; text-decoration: inherit; }
+div.sourceCode { margin: 1em 0; }
+pre.sourceCode { margin: 0; }
+@media screen {
+div.sourceCode { overflow: auto; }
+}
+@media print {
+pre > code.sourceCode { white-space: pre-wrap; }
+pre > code.sourceCode > span { text-indent: -5em; padding-left: 5em; }
+}
+pre.numberSource code
+{ counter-reset: source-line 0; }
+pre.numberSource code > span
+{ position: relative; left: -4em; counter-increment: source-line; }
+pre.numberSource code > span > a:first-child::before
+{ content: counter(source-line);
+position: relative; left: -1em; text-align: right; vertical-align: baseline;
+border: none; display: inline-block;
+-webkit-touch-callout: none; -webkit-user-select: none;
+-khtml-user-select: none; -moz-user-select: none;
+-ms-user-select: none; user-select: none;
+padding: 0 4px; width: 4em;
+color: #aaaaaa;
+}
+pre.numberSource { margin-left: 3em; border-left: 1px solid #aaaaaa; padding-left: 4px; }
+div.sourceCode
+{ }
+@media screen {
+pre > code.sourceCode > span > a:first-child::before { text-decoration: underline; }
+}
+code span.al { color: #ff0000; font-weight: bold; } 
+code span.an { color: #60a0b0; font-weight: bold; font-style: italic; } 
+code span.at { color: #7d9029; } 
+code span.bn { color: #40a070; } 
+code span.bu { color: #008000; } 
+code span.cf { color: #007020; font-weight: bold; } 
+code span.ch { color: #4070a0; } 
+code span.cn { color: #880000; } 
+code span.co { color: #60a0b0; font-style: italic; } 
+code span.cv { color: #60a0b0; font-weight: bold; font-style: italic; } 
+code span.do { color: #ba2121; font-style: italic; } 
+code span.dt { color: #902000; } 
+code span.dv { color: #40a070; } 
+code span.er { color: #ff0000; font-weight: bold; } 
+code span.ex { } 
+code span.fl { color: #40a070; } 
+code span.fu { color: #06287e; } 
+code span.im { color: #008000; font-weight: bold; } 
+code span.in { color: #60a0b0; font-weight: bold; font-style: italic; } 
+code span.kw { color: #007020; font-weight: bold; } 
+code span.op { color: #666666; } 
+code span.ot { color: #007020; } 
+code span.pp { color: #bc7a00; } 
+code span.sc { color: #4070a0; } 
+code span.ss { color: #bb6688; } 
+code span.st { color: #4070a0; } 
+code span.va { color: #19177c; } 
+code span.vs { color: #4070a0; } 
+code span.wa { color: #60a0b0; font-weight: bold; font-style: italic; } 
+</style>
+<script>
+// apply pandoc div.sourceCode style to pre.sourceCode instead
+(function() {
+  var sheets = document.styleSheets;
+  for (var i = 0; i < sheets.length; i++) {
+    if (sheets[i].ownerNode.dataset["origin"] !== "pandoc") continue;
+    try { var rules = sheets[i].cssRules; } catch (e) { continue; }
+    var j = 0;
+    while (j < rules.length) {
+      var rule = rules[j];
+      // check if there is a div.sourceCode rule
+      if (rule.type !== rule.STYLE_RULE || rule.selectorText !== "div.sourceCode") {
+        j++;
+        continue;
+      }
+      var style = rule.style.cssText;
+      // check if color or background-color is set
+      if (rule.style.color === '' && rule.style.backgroundColor === '') {
+        j++;
+        continue;
+      }
+      // replace div.sourceCode by a pre.sourceCode rule
+      sheets[i].deleteRule(j);
+      sheets[i].insertRule('pre.sourceCode{' + style + '}', j);
+    }
+  }
+})();
+</script>
+
+
+
+
+<style type="text/css">body {
+background-color: #fff;
+margin: 1em auto;
+max-width: 700px;
+overflow: visible;
+padding-left: 2em;
+padding-right: 2em;
+font-family: "Open Sans", "Helvetica Neue", Helvetica, Arial, sans-serif;
+font-size: 14px;
+line-height: 1.35;
+}
+#TOC {
+clear: both;
+margin: 0 0 10px 10px;
+padding: 4px;
+width: 400px;
+border: 1px solid #CCCCCC;
+border-radius: 5px;
+background-color: #f6f6f6;
+font-size: 13px;
+line-height: 1.3;
+}
+#TOC .toctitle {
+font-weight: bold;
+font-size: 15px;
+margin-left: 5px;
+}
+#TOC ul {
+padding-left: 40px;
+margin-left: -1.5em;
+margin-top: 5px;
+margin-bottom: 5px;
+}
+#TOC ul ul {
+margin-left: -2em;
+}
+#TOC li {
+line-height: 16px;
+}
+table {
+margin: 1em auto;
+border-width: 1px;
+border-color: #DDDDDD;
+border-style: outset;
+border-collapse: collapse;
+}
+table th {
+border-width: 2px;
+padding: 5px;
+border-style: inset;
+}
+table td {
+border-width: 1px;
+border-style: inset;
+line-height: 18px;
+padding: 5px 5px;
+}
+table, table th, table td {
+border-left-style: none;
+border-right-style: none;
+}
+table thead, table tr.even {
+background-color: #f7f7f7;
+}
+p {
+margin: 0.5em 0;
+}
+blockquote {
+background-color: #f6f6f6;
+padding: 0.25em 0.75em;
+}
+hr {
+border-style: solid;
+border: none;
+border-top: 1px solid #777;
+margin: 28px 0;
+}
+dl {
+margin-left: 0;
+}
+dl dd {
+margin-bottom: 13px;
+margin-left: 13px;
+}
+dl dt {
+font-weight: bold;
+}
+ul {
+margin-top: 0;
+}
+ul li {
+list-style: circle outside;
+}
+ul ul {
+margin-bottom: 0;
+}
+pre, code {
+background-color: #f7f7f7;
+border-radius: 3px;
+color: #333;
+white-space: pre-wrap; 
+}
+pre {
+border-radius: 3px;
+margin: 5px 0px 10px 0px;
+padding: 10px;
+}
+pre:not([class]) {
+background-color: #f7f7f7;
+}
+code {
+font-family: Consolas, Monaco, 'Courier New', monospace;
+font-size: 85%;
+}
+p > code, li > code {
+padding: 2px 0px;
+}
+div.figure {
+text-align: center;
+}
+img {
+background-color: #FFFFFF;
+padding: 2px;
+border: 1px solid #DDDDDD;
+border-radius: 3px;
+border: 1px solid #CCCCCC;
+margin: 0 5px;
+}
+h1 {
+margin-top: 0;
+font-size: 35px;
+line-height: 40px;
+}
+h2 {
+border-bottom: 4px solid #f7f7f7;
+padding-top: 10px;
+padding-bottom: 2px;
+font-size: 145%;
+}
+h3 {
+border-bottom: 2px solid #f7f7f7;
+padding-top: 10px;
+font-size: 120%;
+}
+h4 {
+border-bottom: 1px solid #f7f7f7;
+margin-left: 8px;
+font-size: 105%;
+}
+h5, h6 {
+border-bottom: 1px solid #ccc;
+font-size: 105%;
+}
+a {
+color: #0033dd;
+text-decoration: none;
+}
+a:hover {
+color: #6666ff; }
+a:visited {
+color: #800080; }
+a:visited:hover {
+color: #BB00BB; }
+a[href^="http:"] {
+text-decoration: underline; }
+a[href^="https:"] {
+text-decoration: underline; }
+
+code > span.kw { color: #555; font-weight: bold; } 
+code > span.dt { color: #902000; } 
+code > span.dv { color: #40a070; } 
+code > span.bn { color: #d14; } 
+code > span.fl { color: #d14; } 
+code > span.ch { color: #d14; } 
+code > span.st { color: #d14; } 
+code > span.co { color: #888888; font-style: italic; } 
+code > span.ot { color: #007020; } 
+code > span.al { color: #ff0000; font-weight: bold; } 
+code > span.fu { color: #900; font-weight: bold; } 
+code > span.er { color: #a61717; background-color: #e3d2d2; } 
+</style>
+
+
+
+
+</head>
+
+<body>
+
+
+
+
+<h1 class="title toc-ignore">Using renv with continuous integration</h1>
+
+
+
+<p>When building, deploying, or testing an renv-using project with
+continuous integration (CI) systems (e.g. <a href="https://github.com/features/actions">GitHub Actions</a>, <a href="https://about.gitlab.com/solutions/continuous-integration/">GitLab
+CI</a>, and others) you need some way to tell the CI system to use renv
+to restore the same packages that you’re using locally.</p>
+<p>The general idea is:</p>
+<ol style="list-style-type: decimal">
+<li><p>Call <code>renv::snapshot()</code> on your local machine to
+generate <code>renv.lock</code>.</p></li>
+<li><p>Call <code>renv::restore()</code> on your CI service to restore
+the project library from <code>renv.lock</code>.</p></li>
+<li><p>Cache the project library and global renv cache on the CI
+service.</p></li>
+</ol>
+<p>Note that this workflow is not generally a good fit for CRAN
+packages, because CRAN itself runs <code>R CMD check</code> using the
+latest version of all dependencies.</p>
+<div id="github-actions" class="section level2">
+<h2>GitHub actions</h2>
+<p>Here, we describe two common approaches for integrating renv with a
+<a href="https://github.com/features/actions">GitHub Actions</a>
+workflow:</p>
+<ul>
+<li>Use the <code>r-lib/setup-renv</code> action.</li>
+<li>Use GitHub’s built-in cache action together with existing renv
+functionality;</li>
+</ul>
+<div id="using-r-libactionssetup-renv" class="section level3">
+<h3>Using r-lib/actions/setup-renv</h3>
+<p>The r-lib organization offers some actions for R users, and among
+them a <a href="https://github.com/r-lib/actions/tree/v2-branch/setup-renv"><code>setup-renv</code></a>
+action is provided for projects using renv. To use this action, you can
+add the following steps to your workflow:</p>
+<div class="sourceCode" id="cb1"><pre class="sourceCode yaml"><code class="sourceCode yaml"><span id="cb1-1"><a href="#cb1-1" tabindex="-1"></a><span class="fu">steps</span><span class="kw">:</span></span>
+<span id="cb1-2"><a href="#cb1-2" tabindex="-1"></a><span class="kw">-</span><span class="at"> </span><span class="fu">uses</span><span class="kw">:</span><span class="at"> actions/checkout@v3</span></span>
+<span id="cb1-3"><a href="#cb1-3" tabindex="-1"></a><span class="kw">-</span><span class="at"> </span><span class="fu">uses</span><span class="kw">:</span><span class="at"> r-lib/actions/setup-r@v2</span></span>
+<span id="cb1-4"><a href="#cb1-4" tabindex="-1"></a><span class="kw">-</span><span class="at"> </span><span class="fu">uses</span><span class="kw">:</span><span class="at"> r-lib/actions/setup-renv@v2</span></span></code></pre></div>
+<p>Using these steps will automatically perform the following
+actions:</p>
+<ul>
+<li>renv will be installed, via
+<code>install.packages(&quot;renv&quot;)</code>,</li>
+<li>renv will be configured to use the GitHub cache,</li>
+<li>If provided via a <code>with: profile:</code> key, that renv profile
+will be activated,</li>
+<li>The project will be restored via <code>renv::restore()</code>.</li>
+</ul>
+<p>After this, any steps using R will use the active renv project by
+default.</p>
+</div>
+<div id="using-the-github-actions-cache-with-renv" class="section level3">
+<h3>Using the GitHub Actions Cache with renv</h3>
+<p>When using renv in your own custom GitHub action workflow, there are
+two main requirements:</p>
+<ol style="list-style-type: decimal">
+<li>Cache any packages installed by renv across runs,</li>
+<li>Use <code>renv::restore()</code> to restore packages using this
+cache to speed up installation</li>
+</ol>
+<p>As an example, these steps might look like:</p>
+<div class="sourceCode" id="cb2"><pre class="sourceCode yaml"><code class="sourceCode yaml"><span id="cb2-1"><a href="#cb2-1" tabindex="-1"></a><span class="fu">env</span><span class="kw">:</span></span>
+<span id="cb2-2"><a href="#cb2-2" tabindex="-1"></a><span class="at">  </span><span class="fu">RENV_PATHS_ROOT</span><span class="kw">:</span><span class="at"> ~/.cache/R/renv</span></span>
+<span id="cb2-3"><a href="#cb2-3" tabindex="-1"></a></span>
+<span id="cb2-4"><a href="#cb2-4" tabindex="-1"></a><span class="fu">steps</span><span class="kw">:</span></span>
+<span id="cb2-5"><a href="#cb2-5" tabindex="-1"></a></span>
+<span id="cb2-6"><a href="#cb2-6" tabindex="-1"></a><span class="kw">-</span><span class="at"> </span><span class="fu">name</span><span class="kw">:</span><span class="at"> Cache packages</span></span>
+<span id="cb2-7"><a href="#cb2-7" tabindex="-1"></a><span class="at">  </span><span class="fu">uses</span><span class="kw">:</span><span class="at"> actions/cache@v1</span></span>
+<span id="cb2-8"><a href="#cb2-8" tabindex="-1"></a><span class="at">  </span><span class="fu">with</span><span class="kw">:</span></span>
+<span id="cb2-9"><a href="#cb2-9" tabindex="-1"></a><span class="at">    </span><span class="fu">path</span><span class="kw">:</span><span class="at"> ${{ env.RENV_PATHS_ROOT }}</span></span>
+<span id="cb2-10"><a href="#cb2-10" tabindex="-1"></a><span class="at">    </span><span class="fu">key</span><span class="kw">:</span><span class="at"> ${{ runner.os }}-renv-${{ hashFiles(&#39;**/renv.lock&#39;) }}</span></span>
+<span id="cb2-11"><a href="#cb2-11" tabindex="-1"></a><span class="fu">    restore-keys</span><span class="kw">: </span><span class="ch">|</span></span>
+<span id="cb2-12"><a href="#cb2-12" tabindex="-1"></a>      ${{ runner.os }}-renv-</span>
+<span id="cb2-13"><a href="#cb2-13" tabindex="-1"></a></span>
+<span id="cb2-14"><a href="#cb2-14" tabindex="-1"></a><span class="kw">-</span><span class="at"> </span><span class="fu">name</span><span class="kw">:</span><span class="at"> Restore packages</span></span>
+<span id="cb2-15"><a href="#cb2-15" tabindex="-1"></a><span class="at">  </span><span class="fu">shell</span><span class="kw">:</span><span class="at"> Rscript {0}</span></span>
+<span id="cb2-16"><a href="#cb2-16" tabindex="-1"></a><span class="fu">  run</span><span class="kw">: </span><span class="ch">|</span></span>
+<span id="cb2-17"><a href="#cb2-17" tabindex="-1"></a>    if (!requireNamespace(&quot;renv&quot;, quietly = TRUE)) install.packages(&quot;renv&quot;)</span>
+<span id="cb2-18"><a href="#cb2-18" tabindex="-1"></a>    renv::restore()</span></code></pre></div>
+<p>See also the <a href="https://github.com/actions/cache/blob/main/examples.md#r---renv">example</a>
+on GitHub actions.</p>
+</div>
+</div>
+<div id="gitlab-ci" class="section level2">
+<h2>GitLab CI</h2>
+<p>The following template can be used as a base when using renv with <a href="https://about.gitlab.com/solutions/continuous-integration/">GitLab
+CI</a>:</p>
+<div class="sourceCode" id="cb3"><pre class="sourceCode yaml"><code class="sourceCode yaml"><span id="cb3-1"><a href="#cb3-1" tabindex="-1"></a><span class="fu">variables</span><span class="kw">:</span></span>
+<span id="cb3-2"><a href="#cb3-2" tabindex="-1"></a><span class="at">  </span><span class="fu">RENV_PATHS_ROOT</span><span class="kw">:</span><span class="at"> ${CI_PROJECT_DIR}/renv</span></span>
+<span id="cb3-3"><a href="#cb3-3" tabindex="-1"></a></span>
+<span id="cb3-4"><a href="#cb3-4" tabindex="-1"></a><span class="fu">cache</span><span class="kw">:</span></span>
+<span id="cb3-5"><a href="#cb3-5" tabindex="-1"></a><span class="at">  </span><span class="fu">key</span><span class="kw">:</span><span class="at"> ${CI_PROJECT_NAME}</span></span>
+<span id="cb3-6"><a href="#cb3-6" tabindex="-1"></a><span class="at">  </span><span class="fu">paths</span><span class="kw">:</span></span>
+<span id="cb3-7"><a href="#cb3-7" tabindex="-1"></a><span class="at">    </span><span class="kw">-</span><span class="at"> ${RENV_PATHS_ROOT}</span></span>
+<span id="cb3-8"><a href="#cb3-8" tabindex="-1"></a></span>
+<span id="cb3-9"><a href="#cb3-9" tabindex="-1"></a><span class="fu">before_script</span><span class="kw">:</span></span>
+<span id="cb3-10"><a href="#cb3-10" tabindex="-1"></a><span class="kw">  - </span><span class="at">&lt; ... other pre-deploy steps ... </span><span class="ch">&gt;</span></span>
+<span id="cb3-11"><a href="#cb3-11" tabindex="-1"></a><span class="at">  </span><span class="kw">-</span><span class="at"> Rscript -e &quot;if (!requireNamespace(&#39;renv&#39;, quietly = TRUE)) install.packages(&#39;renv&#39;)&quot;</span></span>
+<span id="cb3-12"><a href="#cb3-12" tabindex="-1"></a><span class="at">  </span><span class="kw">-</span><span class="at"> Rscript -e &quot;renv::restore()&quot;</span></span></code></pre></div>
+</div>
+
+
+
+<!-- code folding -->
+
+
+<!-- dynamically load mathjax for compatibility with self-contained -->
+<script>
+  (function () {
+    var script = document.createElement("script");
+    script.type = "text/javascript";
+    script.src  = "https://mathjax.rstudio.com/latest/MathJax.js?config=TeX-AMS-MML_HTMLorMML";
+    document.getElementsByTagName("head")[0].appendChild(script);
+  })();
+</script>
+
+</body>
+</html>

renv/library/windows/R-4.5/x86_64-w64-mingw32/renv/doc/docker.R

@@ -0,0 +1,7 @@
+## ----include=FALSE------------------------------------------------------------
+knitr::opts_chunk$set(
+  collapse = TRUE,
+  comment = "#>",
+  eval = FALSE
+)
+

renv/library/windows/R-4.5/x86_64-w64-mingw32/renv/doc/docker.Rmd

@@ -0,0 +1,241 @@
+---
+title: "Using renv with Docker"
+output: rmarkdown::html_vignette
+vignette: >
+  %\VignetteIndexEntry{Using renv with Docker}
+  %\VignetteEngine{knitr::rmarkdown}
+  %\VignetteEncoding{UTF-8}
+---
+
+```{r, include=FALSE}
+knitr::opts_chunk$set(
+  collapse = TRUE,
+  comment = "#>",
+  eval = FALSE
+)
+```
+
+While renv can help capture the state of your R library at some point in time, there are still other aspects of the system that can influence the runtime behavior of your R application. In particular, the same R code can produce different results depending on:
+
+- The operating system in use,
+- The compiler flags used when R and packages are built,
+- The LAPACK / BLAS system(s) in use,
+- The versions of system libraries installed and in use,
+
+And so on. [Docker](https://www.docker.com/) is a tool that can help solve this problem through the use of **containers**. Very roughly speaking, one can think of a container as a small, self-contained system within which different applications can be run. Using Docker, one can declaratively state how a container should be built (what operating system it should use, and what system software should be installed within), and use that system to run applications. (For more details, please see <https://environments.rstudio.com/docker>.)
+
+Using Docker and renv together, one can then ensure that both the underlying system, alongside the required R packages, are fixed and constant for a particular application.
+
+The main challenges in using Docker with renv are:
+
+- Ensuring that the renv cache is visible to Docker containers, and
+
+- Ensuring that required R package dependencies are available at runtime.
+
+This vignette will assume you are already familiar with Docker; if you are not yet familiar with Docker, the [Docker Documentation](https://docs.docker.com/) provides a thorough introduction. To learn more about using Docker to manage R environments, visit [environments.rstudio.com](https://environments.rstudio.com/docker.html).
+
+We'll discuss two strategies for using renv with Docker:
+
+1. Using renv to install packages when the Docker image is generated;
+2. Using renv to install packages when Docker containers are run.
+
+We'll also explore the pros and cons of each strategy.
+
+
+## Creating Docker images with renv
+
+With Docker, [Dockerfiles](https://docs.docker.com/engine/reference/builder/) are used to define new images. Dockerfiles can be used to declaratively specify how a Docker image should be created. A Docker image captures the state of a machine at some point in time -- e.g., a Linux operating system after downloading and installing R `r getRversion()[1, 1:2]`. Docker containers can be created using that image as a base, allowing different independent applications to run using the same pre-defined machine state.
+
+First, you'll need to get renv installed on your Docker image. For example, you could install the latest release of renv from CRAN:
+
+```dockerfile
+RUN R -e "install.packages('renv', repos = c(CRAN = 'https://cloud.r-project.org'))"
+```
+
+Alternatively, if you need to use the development version of renv, you could use:
+
+```dockerfile
+RUN R -e "install.packages('renv', repos = 'https://rstudio.r-universe.dev')"
+```
+
+Next, we'll copy `renv.lock` into the container:
+
+```dockerfile
+WORKDIR /project
+COPY renv.lock renv.lock
+```
+
+Now, we `renv::restore()` to install those packages. At this stage, you'll need to decide which of R's library paths you'd like to use for pacakge installation. (See `?.libPaths` for more information.) There are a couple of options available:
+
+
+### Use the default library paths
+
+This method is appropriate if you'd like these packages to be visible to all R processes launched using this image, and can be done via:
+
+```dockerfile
+RUN R -e "renv::restore()"
+```
+
+Note that this method may fail if R's default library paths are not on a writable volume in the Docker image. If this is the case, consider one of the alternatives below.
+
+
+### Use the default project library path
+
+If you want to use renv's default project-local library path, you'll need to initialize the project within the Docker container as an renv project. This can be done with:
+
+```dockerfile
+RUN R -s -e "renv::init(bare = TRUE)"
+RUN R -s -e "renv::restore()"
+```
+
+Or, alternatively, if you already have a project autoloader + settings available -- e.g. because you're creating a Docker image from an existing renv project -- you could use:
+
+```dockerfile
+RUN mkdir -p renv
+COPY .Rprofile .Rprofile
+COPY renv/activate.R renv/activate.R
+COPY renv/settings.json renv/settings.json
+RUN R -s -e "renv::restore()"
+```
+
+Note that in this mode, the installed packages would only be visible to R sessions launched using `/project` as the working directory. This will be the default behavior as long as `WORKDIR` is not changed, but it's important to keep this in mind.
+
+
+### Use a custom library path
+
+If you'd like to fully customize the library path used, the simplest approach is likely to use the `RENV_PATHS_LIBRARY` environment variable. This mimics the above approach, but customizes the library paths used by renv. For example:
+
+```dockerfile
+ENV RENV_PATHS_LIBRARY=renv/library
+RUN R -s -e "renv::init(bare = TRUE)"
+RUN R -s -e "renv::restore()"
+```
+
+Alternatively, you could manage the library paths yourself via `.libPaths()` -- see `?.libPaths` in R for more inforamtion.
+
+
+## Speeding up package installations
+
+The previously-described approaches are useful if you have multiple applications with identical package requirements. In this case, a single image containing this identical package library could serve as the parent image for several containerized applications.
+
+However, `renv::restore()` is slow -- it needs to download and install packages, which can take some time. Thus, some care is required to efficiently make use of the renv cache for projects that require: 
+
+1. Building an image multiple times (e.g., to debug the production application as source code is updated), or
+
+2. Calling `renv::restore()` each time the container is run.
+
+The former process can be sped up using multi-stage builds, the latter by dynamically provisioning R Libraries, as described below.
+
+
+### Multi-stage builds
+
+For projects that require repeatedly building an image, [multi-stage builds](https://docs.docker.com/build/building/multi-stage/) can be used to speed up the build process. With multi-stage builds, multiple FROM statements are used in the Dockerfile and files can be copied across build stages. 
+
+This approach can be leveraged to generate more efficient builds by dedicating a first stage build to package synchronization and a second stage build to copying files and executing code that may need to be updated often across builds (e.g., code that needs to be debugged in the container).
+
+To implement a two stage build, the following code could be used as part of a Dockerfile.
+
+```dockerfile
+FROM <parent-image> AS base
+
+# intialize the project; assuming renv infrastructure available
+WORKDIR /project
+RUN mkdir -p renv
+COPY renv.lock renv.lock
+COPY .Rprofile .Rprofile
+COPY renv/activate.R renv/activate.R
+COPY renv/settings.dcf renv/settings.dcf
+
+# change default location of cache to project folder
+RUN mkdir renv/.cache
+ENV RENV_PATHS_CACHE=renv/.cache
+
+# restore 
+RUN R -s -e "renv::restore()"
+```
+
+The above code uses `FROM <parent-image> AS <name>` to name the first stage of the build `base`. Here, `<parent-image>` should be replaced with an appropriate image name. 
+
+Subsequently, the code uses approach 2 (described above) to copy the auto-loader to the project directory in the image. It additionally creates the `renv/.cache` directory that is to be used as the renv cache.
+
+The second stage of the build is defined by adding the following code to the same Dockerfile, below the previous code chunk.
+
+```dockerfile
+FROM <parent-image>
+
+WORKDIR /project
+COPY --from=base /project .
+
+# add commands that need to be debugged below
+```
+
+Here, `<parent-image>` could be the same as the parent image of `base`, but does not have to be (see [documentation](https://docs.docker.com/build/building/multi-stage/) for more details).
+
+The key line is the `COPY` command, which specifies that the contents of `/project` directory from the `base` image are copied into the `/project` directory of this image. 
+
+Any commands that will change frequently across builds could be included below the `COPY` command. If only this code associated with the second stage build is updated then `renv::restore()` will not be called again at build time. Instead, the layers associated with the `base` image will be loaded from Docker's cache, thereby saving significant time in build process.
+
+In fact, `renv::restore()` will only be called when the `base` image needs to be rebuilt (e.g., when changes are made to `renv.lock`). Docker's cache system is generally good at understanding the dependencies of images. However, if you find that the `base` image is not updating as expected, it is possible to manually enforce a clean build by including the `--no-cache` option in the call to `docker build`.
+
+
+### Dynamically Provisioning R Libraries with renv
+
+However, on occasion, one will have multiple applications built from a single base image, but each application will have its own independent R package requirements. In this case, rather than including the package dependencies in the image itself, it would be preferable for each container to provision its own library at runtime, based on that application's `renv.lock` lockfile.
+
+In effect, this is as simple as ensuring that `renv::restore()` happens at container runtime, rather than image build time. However, on its own, `renv::restore()` is slow -- it needs to download and install packages, which could take prohibitively long if an application needs to be run repeatedly.
+
+The renv package cache can be used to help ameliorate this issue. When the cache is enabled, whenever renv attempts to install or restore an R package, it first checks to see whether that package is already available within the renv cache. If it is, that instance of the package is linked into the project library. Otherwise, the package is first installed into the renv cache, and then that newly-installed copy is linked for use in the project.
+
+In effect, if the renv cache is available, you should only need to pay the cost of package installation once -- after that, the newly-installed package will be available for re-use across different projects. At the same time, each project's library will remain independent and isolated from one another, so installing a package within one container won't affect another container.
+
+However, by default, each Docker container will have its own independent filesystem. Ideally, we'd like for *all* containers launched from a particular image to have access to the same renv cache. To accomplish this, we'll have to tell each container to use an renv cache located on a shared mount.
+
+In sum, if we'd like to allow for runtime provisioning of R package dependencies, we will need to ensure the renv cache is located on a shared volume, which is visible to any containers launched. We will accomplish this by:
+
+1. Setting the `RENV_PATHS_CACHE` environment variable, to tell the instance of renv running in each container where the global cache lives;
+
+2. Telling Docker to mount some filesystem location from the host filesystem, at some location (`RENV_PATHS_CACHE_HOST`), to a container-specific location (`RENV_PATHS_CACHE_CONTAINER`).
+
+For example, if you had a container running a Shiny application:
+
+```dockerfile
+# the location of the renv cache on the host machine
+RENV_PATHS_CACHE_HOST=/opt/local/renv/cache
+
+# where the cache should be mounted in the container
+RENV_PATHS_CACHE_CONTAINER=/renv/cache
+
+# run the container with the host cache mounted in the container
+docker run --rm \
+    -e "RENV_PATHS_CACHE=${RENV_PATHS_CACHE_CONTAINER}" \
+    -v "${RENV_PATHS_CACHE_HOST}:${RENV_PATHS_CACHE_CONTAINER}" \
+    -p 14618:14618 \
+    R -s -e 'renv::restore(); shiny::runApp(host = "0.0.0.0", port = 14618)'
+```
+
+Note that the invocation above assumes that the project has already been initialized either via calling `renv::init()` or by copying the requisite `renv` project infrastructure. With this, any calls to renv APIs within the created docker container will have access to the mounted cache. The first time you run a container, renv will likely need to populate the cache, and so some time will be spent downloading and installing the required packages. Subsequent runs will be much faster, as renv will be able to reuse the global package cache.
+
+The primary downside with this approach compared to the image-based approach is that it requires you to modify how containers are created, and requires a bit of extra orchestration in how containers are launched. However, once the renv cache is active, newly-created containers will launch very quickly, and a single image can then be used as a base for a myriad of different containers and applications, each with their own independent package dependencies.
+
+
+## Handling the renv autoloader
+
+When `R` is launched within a project folder, the renv auto-loader (if present) will attempt to download and install renv into the project library if it's not available. Depending on how your Docker container is configured, this could fail. For example:
+
+```sh
+Error installing renv:
+======================
+ERROR: unable to create '/usr/local/pipe/renv/library/master/R-4.0/x86_64-pc-linux-gnu/renv'
+Warning messages:
+1: In system2(r, args, stdout = TRUE, stderr = TRUE) :
+  running command ''/usr/lib/R/bin/R' --vanilla CMD INSTALL -l 'renv/library/master/R-4.0/x86_64-pc-linux-gnu' '/tmp/RtmpwM7ooh/renv_0.12.2.tar.gz' 2>&1' had status 1
+2: Failed to find an renv installation: the project will not be loaded.
+Use `renv::activate()` to re-initialize the project.
+```
+
+Bootstrapping renv into the project library might be unnecessary for you. If that is the case, then you can avoid this behavior by launching R with the `--vanilla` flag set; for example:
+
+```{sh}
+R --vanilla -s -e 'renv::restore()'
+```
+

renv/library/windows/R-4.5/x86_64-w64-mingw32/renv/doc/docker.html

@@ -0,0 +1,646 @@
+<!DOCTYPE html>
+
+<html>
+
+<head>
+
+<meta charset="utf-8" />
+<meta name="generator" content="pandoc" />
+<meta http-equiv="X-UA-Compatible" content="IE=EDGE" />
+
+<meta name="viewport" content="width=device-width, initial-scale=1" />
+
+
+
+<title>Using renv with Docker</title>
+
+<script>// Pandoc 2.9 adds attributes on both header and div. We remove the former (to
+// be compatible with the behavior of Pandoc < 2.8).
+document.addEventListener('DOMContentLoaded', function(e) {
+  var hs = document.querySelectorAll("div.section[class*='level'] > :first-child");
+  var i, h, a;
+  for (i = 0; i < hs.length; i++) {
+    h = hs[i];
+    if (!/^h[1-6]$/i.test(h.tagName)) continue;  // it should be a header h1-h6
+    a = h.attributes;
+    while (a.length > 0) h.removeAttribute(a[0].name);
+  }
+});
+</script>
+
+<style type="text/css">
+code{white-space: pre-wrap;}
+span.smallcaps{font-variant: small-caps;}
+span.underline{text-decoration: underline;}
+div.column{display: inline-block; vertical-align: top; width: 50%;}
+div.hanging-indent{margin-left: 1.5em; text-indent: -1.5em;}
+ul.task-list{list-style: none;}
+</style>
+
+
+
+<style type="text/css">
+code {
+white-space: pre;
+}
+.sourceCode {
+overflow: visible;
+}
+</style>
+<style type="text/css" data-origin="pandoc">
+html { -webkit-text-size-adjust: 100%; }
+pre > code.sourceCode { white-space: pre; position: relative; }
+pre > code.sourceCode > span { display: inline-block; line-height: 1.25; }
+pre > code.sourceCode > span:empty { height: 1.2em; }
+.sourceCode { overflow: visible; }
+code.sourceCode > span { color: inherit; text-decoration: inherit; }
+div.sourceCode { margin: 1em 0; }
+pre.sourceCode { margin: 0; }
+@media screen {
+div.sourceCode { overflow: auto; }
+}
+@media print {
+pre > code.sourceCode { white-space: pre-wrap; }
+pre > code.sourceCode > span { text-indent: -5em; padding-left: 5em; }
+}
+pre.numberSource code
+{ counter-reset: source-line 0; }
+pre.numberSource code > span
+{ position: relative; left: -4em; counter-increment: source-line; }
+pre.numberSource code > span > a:first-child::before
+{ content: counter(source-line);
+position: relative; left: -1em; text-align: right; vertical-align: baseline;
+border: none; display: inline-block;
+-webkit-touch-callout: none; -webkit-user-select: none;
+-khtml-user-select: none; -moz-user-select: none;
+-ms-user-select: none; user-select: none;
+padding: 0 4px; width: 4em;
+color: #aaaaaa;
+}
+pre.numberSource { margin-left: 3em; border-left: 1px solid #aaaaaa; padding-left: 4px; }
+div.sourceCode
+{ }
+@media screen {
+pre > code.sourceCode > span > a:first-child::before { text-decoration: underline; }
+}
+code span.al { color: #ff0000; font-weight: bold; } 
+code span.an { color: #60a0b0; font-weight: bold; font-style: italic; } 
+code span.at { color: #7d9029; } 
+code span.bn { color: #40a070; } 
+code span.bu { color: #008000; } 
+code span.cf { color: #007020; font-weight: bold; } 
+code span.ch { color: #4070a0; } 
+code span.cn { color: #880000; } 
+code span.co { color: #60a0b0; font-style: italic; } 
+code span.cv { color: #60a0b0; font-weight: bold; font-style: italic; } 
+code span.do { color: #ba2121; font-style: italic; } 
+code span.dt { color: #902000; } 
+code span.dv { color: #40a070; } 
+code span.er { color: #ff0000; font-weight: bold; } 
+code span.ex { } 
+code span.fl { color: #40a070; } 
+code span.fu { color: #06287e; } 
+code span.im { color: #008000; font-weight: bold; } 
+code span.in { color: #60a0b0; font-weight: bold; font-style: italic; } 
+code span.kw { color: #007020; font-weight: bold; } 
+code span.op { color: #666666; } 
+code span.ot { color: #007020; } 
+code span.pp { color: #bc7a00; } 
+code span.sc { color: #4070a0; } 
+code span.ss { color: #bb6688; } 
+code span.st { color: #4070a0; } 
+code span.va { color: #19177c; } 
+code span.vs { color: #4070a0; } 
+code span.wa { color: #60a0b0; font-weight: bold; font-style: italic; } 
+</style>
+<script>
+// apply pandoc div.sourceCode style to pre.sourceCode instead
+(function() {
+  var sheets = document.styleSheets;
+  for (var i = 0; i < sheets.length; i++) {
+    if (sheets[i].ownerNode.dataset["origin"] !== "pandoc") continue;
+    try { var rules = sheets[i].cssRules; } catch (e) { continue; }
+    var j = 0;
+    while (j < rules.length) {
+      var rule = rules[j];
+      // check if there is a div.sourceCode rule
+      if (rule.type !== rule.STYLE_RULE || rule.selectorText !== "div.sourceCode") {
+        j++;
+        continue;
+      }
+      var style = rule.style.cssText;
+      // check if color or background-color is set
+      if (rule.style.color === '' && rule.style.backgroundColor === '') {
+        j++;
+        continue;
+      }
+      // replace div.sourceCode by a pre.sourceCode rule
+      sheets[i].deleteRule(j);
+      sheets[i].insertRule('pre.sourceCode{' + style + '}', j);
+    }
+  }
+})();
+</script>
+
+
+
+
+<style type="text/css">body {
+background-color: #fff;
+margin: 1em auto;
+max-width: 700px;
+overflow: visible;
+padding-left: 2em;
+padding-right: 2em;
+font-family: "Open Sans", "Helvetica Neue", Helvetica, Arial, sans-serif;
+font-size: 14px;
+line-height: 1.35;
+}
+#TOC {
+clear: both;
+margin: 0 0 10px 10px;
+padding: 4px;
+width: 400px;
+border: 1px solid #CCCCCC;
+border-radius: 5px;
+background-color: #f6f6f6;
+font-size: 13px;
+line-height: 1.3;
+}
+#TOC .toctitle {
+font-weight: bold;
+font-size: 15px;
+margin-left: 5px;
+}
+#TOC ul {
+padding-left: 40px;
+margin-left: -1.5em;
+margin-top: 5px;
+margin-bottom: 5px;
+}
+#TOC ul ul {
+margin-left: -2em;
+}
+#TOC li {
+line-height: 16px;
+}
+table {
+margin: 1em auto;
+border-width: 1px;
+border-color: #DDDDDD;
+border-style: outset;
+border-collapse: collapse;
+}
+table th {
+border-width: 2px;
+padding: 5px;
+border-style: inset;
+}
+table td {
+border-width: 1px;
+border-style: inset;
+line-height: 18px;
+padding: 5px 5px;
+}
+table, table th, table td {
+border-left-style: none;
+border-right-style: none;
+}
+table thead, table tr.even {
+background-color: #f7f7f7;
+}
+p {
+margin: 0.5em 0;
+}
+blockquote {
+background-color: #f6f6f6;
+padding: 0.25em 0.75em;
+}
+hr {
+border-style: solid;
+border: none;
+border-top: 1px solid #777;
+margin: 28px 0;
+}
+dl {
+margin-left: 0;
+}
+dl dd {
+margin-bottom: 13px;
+margin-left: 13px;
+}
+dl dt {
+font-weight: bold;
+}
+ul {
+margin-top: 0;
+}
+ul li {
+list-style: circle outside;
+}
+ul ul {
+margin-bottom: 0;
+}
+pre, code {
+background-color: #f7f7f7;
+border-radius: 3px;
+color: #333;
+white-space: pre-wrap; 
+}
+pre {
+border-radius: 3px;
+margin: 5px 0px 10px 0px;
+padding: 10px;
+}
+pre:not([class]) {
+background-color: #f7f7f7;
+}
+code {
+font-family: Consolas, Monaco, 'Courier New', monospace;
+font-size: 85%;
+}
+p > code, li > code {
+padding: 2px 0px;
+}
+div.figure {
+text-align: center;
+}
+img {
+background-color: #FFFFFF;
+padding: 2px;
+border: 1px solid #DDDDDD;
+border-radius: 3px;
+border: 1px solid #CCCCCC;
+margin: 0 5px;
+}
+h1 {
+margin-top: 0;
+font-size: 35px;
+line-height: 40px;
+}
+h2 {
+border-bottom: 4px solid #f7f7f7;
+padding-top: 10px;
+padding-bottom: 2px;
+font-size: 145%;
+}
+h3 {
+border-bottom: 2px solid #f7f7f7;
+padding-top: 10px;
+font-size: 120%;
+}
+h4 {
+border-bottom: 1px solid #f7f7f7;
+margin-left: 8px;
+font-size: 105%;
+}
+h5, h6 {
+border-bottom: 1px solid #ccc;
+font-size: 105%;
+}
+a {
+color: #0033dd;
+text-decoration: none;
+}
+a:hover {
+color: #6666ff; }
+a:visited {
+color: #800080; }
+a:visited:hover {
+color: #BB00BB; }
+a[href^="http:"] {
+text-decoration: underline; }
+a[href^="https:"] {
+text-decoration: underline; }
+
+code > span.kw { color: #555; font-weight: bold; } 
+code > span.dt { color: #902000; } 
+code > span.dv { color: #40a070; } 
+code > span.bn { color: #d14; } 
+code > span.fl { color: #d14; } 
+code > span.ch { color: #d14; } 
+code > span.st { color: #d14; } 
+code > span.co { color: #888888; font-style: italic; } 
+code > span.ot { color: #007020; } 
+code > span.al { color: #ff0000; font-weight: bold; } 
+code > span.fu { color: #900; font-weight: bold; } 
+code > span.er { color: #a61717; background-color: #e3d2d2; } 
+</style>
+
+
+
+
+</head>
+
+<body>
+
+
+
+
+<h1 class="title toc-ignore">Using renv with Docker</h1>
+
+
+
+<p>While renv can help capture the state of your R library at some point
+in time, there are still other aspects of the system that can influence
+the runtime behavior of your R application. In particular, the same R
+code can produce different results depending on:</p>
+<ul>
+<li>The operating system in use,</li>
+<li>The compiler flags used when R and packages are built,</li>
+<li>The LAPACK / BLAS system(s) in use,</li>
+<li>The versions of system libraries installed and in use,</li>
+</ul>
+<p>And so on. <a href="https://www.docker.com/">Docker</a> is a tool
+that can help solve this problem through the use of
+<strong>containers</strong>. Very roughly speaking, one can think of a
+container as a small, self-contained system within which different
+applications can be run. Using Docker, one can declaratively state how a
+container should be built (what operating system it should use, and what
+system software should be installed within), and use that system to run
+applications. (For more details, please see <a href="https://environments.rstudio.com/docker" class="uri">https://environments.rstudio.com/docker</a>.)</p>
+<p>Using Docker and renv together, one can then ensure that both the
+underlying system, alongside the required R packages, are fixed and
+constant for a particular application.</p>
+<p>The main challenges in using Docker with renv are:</p>
+<ul>
+<li><p>Ensuring that the renv cache is visible to Docker containers,
+and</p></li>
+<li><p>Ensuring that required R package dependencies are available at
+runtime.</p></li>
+</ul>
+<p>This vignette will assume you are already familiar with Docker; if
+you are not yet familiar with Docker, the <a href="https://docs.docker.com/">Docker Documentation</a> provides a
+thorough introduction. To learn more about using Docker to manage R
+environments, visit <a href="https://environments.rstudio.com/docker.html">environments.rstudio.com</a>.</p>
+<p>We’ll discuss two strategies for using renv with Docker:</p>
+<ol style="list-style-type: decimal">
+<li>Using renv to install packages when the Docker image is
+generated;</li>
+<li>Using renv to install packages when Docker containers are run.</li>
+</ol>
+<p>We’ll also explore the pros and cons of each strategy.</p>
+<div id="creating-docker-images-with-renv" class="section level2">
+<h2>Creating Docker images with renv</h2>
+<p>With Docker, <a href="https://docs.docker.com/engine/reference/builder/">Dockerfiles</a>
+are used to define new images. Dockerfiles can be used to declaratively
+specify how a Docker image should be created. A Docker image captures
+the state of a machine at some point in time – e.g., a Linux operating
+system after downloading and installing R 4.5. Docker containers can be
+created using that image as a base, allowing different independent
+applications to run using the same pre-defined machine state.</p>
+<p>First, you’ll need to get renv installed on your Docker image. For
+example, you could install the latest release of renv from CRAN:</p>
+<div class="sourceCode" id="cb1"><pre class="sourceCode dockerfile"><code class="sourceCode dockerfile"><span id="cb1-1"><a href="#cb1-1" tabindex="-1"></a><span class="kw">RUN</span> <span class="ex">R</span> <span class="at">-e</span> <span class="st">&quot;install.packages(&#39;renv&#39;, repos = c(CRAN = &#39;https://cloud.r-project.org&#39;))&quot;</span></span></code></pre></div>
+<p>Alternatively, if you need to use the development version of renv,
+you could use:</p>
+<div class="sourceCode" id="cb2"><pre class="sourceCode dockerfile"><code class="sourceCode dockerfile"><span id="cb2-1"><a href="#cb2-1" tabindex="-1"></a><span class="kw">RUN</span> <span class="ex">R</span> <span class="at">-e</span> <span class="st">&quot;install.packages(&#39;renv&#39;, repos = &#39;https://rstudio.r-universe.dev&#39;)&quot;</span></span></code></pre></div>
+<p>Next, we’ll copy <code>renv.lock</code> into the container:</p>
+<div class="sourceCode" id="cb3"><pre class="sourceCode dockerfile"><code class="sourceCode dockerfile"><span id="cb3-1"><a href="#cb3-1" tabindex="-1"></a><span class="kw">WORKDIR</span> /project</span>
+<span id="cb3-2"><a href="#cb3-2" tabindex="-1"></a><span class="kw">COPY</span> renv.lock renv.lock</span></code></pre></div>
+<p>Now, we <code>renv::restore()</code> to install those packages. At
+this stage, you’ll need to decide which of R’s library paths you’d like
+to use for pacakge installation. (See <code>?.libPaths</code> for more
+information.) There are a couple of options available:</p>
+<div id="use-the-default-library-paths" class="section level3">
+<h3>Use the default library paths</h3>
+<p>This method is appropriate if you’d like these packages to be visible
+to all R processes launched using this image, and can be done via:</p>
+<div class="sourceCode" id="cb4"><pre class="sourceCode dockerfile"><code class="sourceCode dockerfile"><span id="cb4-1"><a href="#cb4-1" tabindex="-1"></a><span class="kw">RUN</span> <span class="ex">R</span> <span class="at">-e</span> <span class="st">&quot;renv::restore()&quot;</span></span></code></pre></div>
+<p>Note that this method may fail if R’s default library paths are not
+on a writable volume in the Docker image. If this is the case, consider
+one of the alternatives below.</p>
+</div>
+<div id="use-the-default-project-library-path" class="section level3">
+<h3>Use the default project library path</h3>
+<p>If you want to use renv’s default project-local library path, you’ll
+need to initialize the project within the Docker container as an renv
+project. This can be done with:</p>
+<div class="sourceCode" id="cb5"><pre class="sourceCode dockerfile"><code class="sourceCode dockerfile"><span id="cb5-1"><a href="#cb5-1" tabindex="-1"></a><span class="kw">RUN</span> <span class="ex">R</span> <span class="at">-s</span> <span class="at">-e</span> <span class="st">&quot;renv::init(bare = TRUE)&quot;</span></span>
+<span id="cb5-2"><a href="#cb5-2" tabindex="-1"></a><span class="kw">RUN</span> <span class="ex">R</span> <span class="at">-s</span> <span class="at">-e</span> <span class="st">&quot;renv::restore()&quot;</span></span></code></pre></div>
+<p>Or, alternatively, if you already have a project autoloader +
+settings available – e.g. because you’re creating a Docker image from an
+existing renv project – you could use:</p>
+<div class="sourceCode" id="cb6"><pre class="sourceCode dockerfile"><code class="sourceCode dockerfile"><span id="cb6-1"><a href="#cb6-1" tabindex="-1"></a><span class="kw">RUN</span> <span class="fu">mkdir</span> <span class="at">-p</span> renv</span>
+<span id="cb6-2"><a href="#cb6-2" tabindex="-1"></a><span class="kw">COPY</span> .Rprofile .Rprofile</span>
+<span id="cb6-3"><a href="#cb6-3" tabindex="-1"></a><span class="kw">COPY</span> renv/activate.R renv/activate.R</span>
+<span id="cb6-4"><a href="#cb6-4" tabindex="-1"></a><span class="kw">COPY</span> renv/settings.json renv/settings.json</span>
+<span id="cb6-5"><a href="#cb6-5" tabindex="-1"></a><span class="kw">RUN</span> <span class="ex">R</span> <span class="at">-s</span> <span class="at">-e</span> <span class="st">&quot;renv::restore()&quot;</span></span></code></pre></div>
+<p>Note that in this mode, the installed packages would only be visible
+to R sessions launched using <code>/project</code> as the working
+directory. This will be the default behavior as long as
+<code>WORKDIR</code> is not changed, but it’s important to keep this in
+mind.</p>
+</div>
+<div id="use-a-custom-library-path" class="section level3">
+<h3>Use a custom library path</h3>
+<p>If you’d like to fully customize the library path used, the simplest
+approach is likely to use the <code>RENV_PATHS_LIBRARY</code>
+environment variable. This mimics the above approach, but customizes the
+library paths used by renv. For example:</p>
+<div class="sourceCode" id="cb7"><pre class="sourceCode dockerfile"><code class="sourceCode dockerfile"><span id="cb7-1"><a href="#cb7-1" tabindex="-1"></a><span class="kw">ENV</span> RENV_PATHS_LIBRARY=renv/library</span>
+<span id="cb7-2"><a href="#cb7-2" tabindex="-1"></a><span class="kw">RUN</span> <span class="ex">R</span> <span class="at">-s</span> <span class="at">-e</span> <span class="st">&quot;renv::init(bare = TRUE)&quot;</span></span>
+<span id="cb7-3"><a href="#cb7-3" tabindex="-1"></a><span class="kw">RUN</span> <span class="ex">R</span> <span class="at">-s</span> <span class="at">-e</span> <span class="st">&quot;renv::restore()&quot;</span></span></code></pre></div>
+<p>Alternatively, you could manage the library paths yourself via
+<code>.libPaths()</code> – see <code>?.libPaths</code> in R for more
+inforamtion.</p>
+</div>
+</div>
+<div id="speeding-up-package-installations" class="section level2">
+<h2>Speeding up package installations</h2>
+<p>The previously-described approaches are useful if you have multiple
+applications with identical package requirements. In this case, a single
+image containing this identical package library could serve as the
+parent image for several containerized applications.</p>
+<p>However, <code>renv::restore()</code> is slow – it needs to download
+and install packages, which can take some time. Thus, some care is
+required to efficiently make use of the renv cache for projects that
+require:</p>
+<ol style="list-style-type: decimal">
+<li><p>Building an image multiple times (e.g., to debug the production
+application as source code is updated), or</p></li>
+<li><p>Calling <code>renv::restore()</code> each time the container is
+run.</p></li>
+</ol>
+<p>The former process can be sped up using multi-stage builds, the
+latter by dynamically provisioning R Libraries, as described below.</p>
+<div id="multi-stage-builds" class="section level3">
+<h3>Multi-stage builds</h3>
+<p>For projects that require repeatedly building an image, <a href="https://docs.docker.com/build/building/multi-stage/">multi-stage
+builds</a> can be used to speed up the build process. With multi-stage
+builds, multiple FROM statements are used in the Dockerfile and files
+can be copied across build stages.</p>
+<p>This approach can be leveraged to generate more efficient builds by
+dedicating a first stage build to package synchronization and a second
+stage build to copying files and executing code that may need to be
+updated often across builds (e.g., code that needs to be debugged in the
+container).</p>
+<p>To implement a two stage build, the following code could be used as
+part of a Dockerfile.</p>
+<div class="sourceCode" id="cb8"><pre class="sourceCode dockerfile"><code class="sourceCode dockerfile"><span id="cb8-1"><a href="#cb8-1" tabindex="-1"></a><span class="kw">FROM</span> &lt;parent-image&gt; <span class="kw">AS</span> base</span>
+<span id="cb8-2"><a href="#cb8-2" tabindex="-1"></a></span>
+<span id="cb8-3"><a href="#cb8-3" tabindex="-1"></a><span class="co"># intialize the project; assuming renv infrastructure available</span></span>
+<span id="cb8-4"><a href="#cb8-4" tabindex="-1"></a><span class="kw">WORKDIR</span> /project</span>
+<span id="cb8-5"><a href="#cb8-5" tabindex="-1"></a><span class="kw">RUN</span> <span class="fu">mkdir</span> <span class="at">-p</span> renv</span>
+<span id="cb8-6"><a href="#cb8-6" tabindex="-1"></a><span class="kw">COPY</span> renv.lock renv.lock</span>
+<span id="cb8-7"><a href="#cb8-7" tabindex="-1"></a><span class="kw">COPY</span> .Rprofile .Rprofile</span>
+<span id="cb8-8"><a href="#cb8-8" tabindex="-1"></a><span class="kw">COPY</span> renv/activate.R renv/activate.R</span>
+<span id="cb8-9"><a href="#cb8-9" tabindex="-1"></a><span class="kw">COPY</span> renv/settings.dcf renv/settings.dcf</span>
+<span id="cb8-10"><a href="#cb8-10" tabindex="-1"></a></span>
+<span id="cb8-11"><a href="#cb8-11" tabindex="-1"></a><span class="co"># change default location of cache to project folder</span></span>
+<span id="cb8-12"><a href="#cb8-12" tabindex="-1"></a><span class="kw">RUN</span> <span class="fu">mkdir</span> renv/.cache</span>
+<span id="cb8-13"><a href="#cb8-13" tabindex="-1"></a><span class="kw">ENV</span> RENV_PATHS_CACHE=renv/.cache</span>
+<span id="cb8-14"><a href="#cb8-14" tabindex="-1"></a></span>
+<span id="cb8-15"><a href="#cb8-15" tabindex="-1"></a><span class="co"># restore </span></span>
+<span id="cb8-16"><a href="#cb8-16" tabindex="-1"></a><span class="kw">RUN</span> <span class="ex">R</span> <span class="at">-s</span> <span class="at">-e</span> <span class="st">&quot;renv::restore()&quot;</span></span></code></pre></div>
+<p>The above code uses
+<code>FROM &lt;parent-image&gt; AS &lt;name&gt;</code> to name the first
+stage of the build <code>base</code>. Here,
+<code>&lt;parent-image&gt;</code> should be replaced with an appropriate
+image name.</p>
+<p>Subsequently, the code uses approach 2 (described above) to copy the
+auto-loader to the project directory in the image. It additionally
+creates the <code>renv/.cache</code> directory that is to be used as the
+renv cache.</p>
+<p>The second stage of the build is defined by adding the following code
+to the same Dockerfile, below the previous code chunk.</p>
+<div class="sourceCode" id="cb9"><pre class="sourceCode dockerfile"><code class="sourceCode dockerfile"><span id="cb9-1"><a href="#cb9-1" tabindex="-1"></a><span class="kw">FROM</span> &lt;parent-image&gt;</span>
+<span id="cb9-2"><a href="#cb9-2" tabindex="-1"></a></span>
+<span id="cb9-3"><a href="#cb9-3" tabindex="-1"></a><span class="kw">WORKDIR</span> /project</span>
+<span id="cb9-4"><a href="#cb9-4" tabindex="-1"></a><span class="kw">COPY</span> <span class="op">--from=base</span> /project .</span>
+<span id="cb9-5"><a href="#cb9-5" tabindex="-1"></a></span>
+<span id="cb9-6"><a href="#cb9-6" tabindex="-1"></a><span class="co"># add commands that need to be debugged below</span></span></code></pre></div>
+<p>Here, <code>&lt;parent-image&gt;</code> could be the same as the
+parent image of <code>base</code>, but does not have to be (see <a href="https://docs.docker.com/build/building/multi-stage/">documentation</a>
+for more details).</p>
+<p>The key line is the <code>COPY</code> command, which specifies that
+the contents of <code>/project</code> directory from the
+<code>base</code> image are copied into the <code>/project</code>
+directory of this image.</p>
+<p>Any commands that will change frequently across builds could be
+included below the <code>COPY</code> command. If only this code
+associated with the second stage build is updated then
+<code>renv::restore()</code> will not be called again at build time.
+Instead, the layers associated with the <code>base</code> image will be
+loaded from Docker’s cache, thereby saving significant time in build
+process.</p>
+<p>In fact, <code>renv::restore()</code> will only be called when the
+<code>base</code> image needs to be rebuilt (e.g., when changes are made
+to <code>renv.lock</code>). Docker’s cache system is generally good at
+understanding the dependencies of images. However, if you find that the
+<code>base</code> image is not updating as expected, it is possible to
+manually enforce a clean build by including the <code>--no-cache</code>
+option in the call to <code>docker build</code>.</p>
+</div>
+<div id="dynamically-provisioning-r-libraries-with-renv" class="section level3">
+<h3>Dynamically Provisioning R Libraries with renv</h3>
+<p>However, on occasion, one will have multiple applications built from
+a single base image, but each application will have its own independent
+R package requirements. In this case, rather than including the package
+dependencies in the image itself, it would be preferable for each
+container to provision its own library at runtime, based on that
+application’s <code>renv.lock</code> lockfile.</p>
+<p>In effect, this is as simple as ensuring that
+<code>renv::restore()</code> happens at container runtime, rather than
+image build time. However, on its own, <code>renv::restore()</code> is
+slow – it needs to download and install packages, which could take
+prohibitively long if an application needs to be run repeatedly.</p>
+<p>The renv package cache can be used to help ameliorate this issue.
+When the cache is enabled, whenever renv attempts to install or restore
+an R package, it first checks to see whether that package is already
+available within the renv cache. If it is, that instance of the package
+is linked into the project library. Otherwise, the package is first
+installed into the renv cache, and then that newly-installed copy is
+linked for use in the project.</p>
+<p>In effect, if the renv cache is available, you should only need to
+pay the cost of package installation once – after that, the
+newly-installed package will be available for re-use across different
+projects. At the same time, each project’s library will remain
+independent and isolated from one another, so installing a package
+within one container won’t affect another container.</p>
+<p>However, by default, each Docker container will have its own
+independent filesystem. Ideally, we’d like for <em>all</em> containers
+launched from a particular image to have access to the same renv cache.
+To accomplish this, we’ll have to tell each container to use an renv
+cache located on a shared mount.</p>
+<p>In sum, if we’d like to allow for runtime provisioning of R package
+dependencies, we will need to ensure the renv cache is located on a
+shared volume, which is visible to any containers launched. We will
+accomplish this by:</p>
+<ol style="list-style-type: decimal">
+<li><p>Setting the <code>RENV_PATHS_CACHE</code> environment variable,
+to tell the instance of renv running in each container where the global
+cache lives;</p></li>
+<li><p>Telling Docker to mount some filesystem location from the host
+filesystem, at some location (<code>RENV_PATHS_CACHE_HOST</code>), to a
+container-specific location
+(<code>RENV_PATHS_CACHE_CONTAINER</code>).</p></li>
+</ol>
+<p>For example, if you had a container running a Shiny application:</p>
+<div class="sourceCode" id="cb10"><pre class="sourceCode dockerfile"><code class="sourceCode dockerfile"><span id="cb10-1"><a href="#cb10-1" tabindex="-1"></a><span class="co"># the location of the renv cache on the host machine</span></span>
+<span id="cb10-2"><a href="#cb10-2" tabindex="-1"></a>RENV_PATHS_CACHE_HOST=/opt/local/renv/cache</span>
+<span id="cb10-3"><a href="#cb10-3" tabindex="-1"></a></span>
+<span id="cb10-4"><a href="#cb10-4" tabindex="-1"></a><span class="co"># where the cache should be mounted in the container</span></span>
+<span id="cb10-5"><a href="#cb10-5" tabindex="-1"></a>RENV_PATHS_CACHE_CONTAINER=/renv/cache</span>
+<span id="cb10-6"><a href="#cb10-6" tabindex="-1"></a></span>
+<span id="cb10-7"><a href="#cb10-7" tabindex="-1"></a><span class="co"># run the container with the host cache mounted in the container</span></span>
+<span id="cb10-8"><a href="#cb10-8" tabindex="-1"></a>docker run --rm <span class="op">\</span></span>
+<span id="cb10-9"><a href="#cb10-9" tabindex="-1"></a>    -e <span class="st">&quot;RENV_PATHS_CACHE=${RENV_PATHS_CACHE_CONTAINER}&quot;</span> <span class="op">\</span></span>
+<span id="cb10-10"><a href="#cb10-10" tabindex="-1"></a>    -v <span class="st">&quot;${RENV_PATHS_CACHE_HOST}:${RENV_PATHS_CACHE_CONTAINER}&quot;</span> <span class="op">\</span></span>
+<span id="cb10-11"><a href="#cb10-11" tabindex="-1"></a>    -p 14618:14618 <span class="op">\</span></span>
+<span id="cb10-12"><a href="#cb10-12" tabindex="-1"></a>    R -s -e <span class="st">&#39;renv::restore(); shiny::runApp(host = &quot;0.0.0.0&quot;, port = 14618)&#39;</span></span></code></pre></div>
+<p>Note that the invocation above assumes that the project has already
+been initialized either via calling <code>renv::init()</code> or by
+copying the requisite <code>renv</code> project infrastructure. With
+this, any calls to renv APIs within the created docker container will
+have access to the mounted cache. The first time you run a container,
+renv will likely need to populate the cache, and so some time will be
+spent downloading and installing the required packages. Subsequent runs
+will be much faster, as renv will be able to reuse the global package
+cache.</p>
+<p>The primary downside with this approach compared to the image-based
+approach is that it requires you to modify how containers are created,
+and requires a bit of extra orchestration in how containers are
+launched. However, once the renv cache is active, newly-created
+containers will launch very quickly, and a single image can then be used
+as a base for a myriad of different containers and applications, each
+with their own independent package dependencies.</p>
+</div>
+</div>
+<div id="handling-the-renv-autoloader" class="section level2">
+<h2>Handling the renv autoloader</h2>
+<p>When <code>R</code> is launched within a project folder, the renv
+auto-loader (if present) will attempt to download and install renv into
+the project library if it’s not available. Depending on how your Docker
+container is configured, this could fail. For example:</p>
+<div class="sourceCode" id="cb11"><pre class="sourceCode sh"><code class="sourceCode bash"><span id="cb11-1"><a href="#cb11-1" tabindex="-1"></a><span class="ex">Error</span> installing renv:</span>
+<span id="cb11-2"><a href="#cb11-2" tabindex="-1"></a><span class="ex">======================</span></span>
+<span id="cb11-3"><a href="#cb11-3" tabindex="-1"></a><span class="ex">ERROR:</span> unable to create <span class="st">&#39;/usr/local/pipe/renv/library/master/R-4.0/x86_64-pc-linux-gnu/renv&#39;</span></span>
+<span id="cb11-4"><a href="#cb11-4" tabindex="-1"></a><span class="ex">Warning</span> messages:</span>
+<span id="cb11-5"><a href="#cb11-5" tabindex="-1"></a><span class="ex">1:</span> In system2<span class="er">(</span><span class="ex">r,</span> args, stdout = TRUE, stderr = TRUE<span class="kw">)</span> <span class="bu">:</span></span>
+<span id="cb11-6"><a href="#cb11-6" tabindex="-1"></a>  <span class="ex">running</span> command <span class="st">&#39;&#39;</span>/usr/lib/R/bin/R<span class="st">&#39; --vanilla CMD INSTALL -l &#39;</span>renv/library/master/R-4.0/x86_64-pc-linux-gnu<span class="st">&#39; &#39;</span>/tmp/RtmpwM7ooh/renv_0.12.2.tar.gz<span class="st">&#39; 2&gt;&amp;1&#39;</span> had status 1</span>
+<span id="cb11-7"><a href="#cb11-7" tabindex="-1"></a><span class="ex">2:</span> Failed to find an renv installation: the project will not be loaded.</span>
+<span id="cb11-8"><a href="#cb11-8" tabindex="-1"></a><span class="ex">Use</span> <span class="kw">`</span><span class="fu">renv::activate()</span><span class="kw">`</span> to re-initialize the project.</span></code></pre></div>
+<p>Bootstrapping renv into the project library might be unnecessary for
+you. If that is the case, then you can avoid this behavior by launching
+R with the <code>--vanilla</code> flag set; for example:</p>
+<div class="sourceCode" id="cb12"><pre class="sourceCode sh"><code class="sourceCode bash"><span id="cb12-1"><a href="#cb12-1" tabindex="-1"></a><span class="ex">R</span> <span class="at">--vanilla</span> <span class="at">-s</span> <span class="at">-e</span> <span class="st">&#39;renv::restore()&#39;</span></span></code></pre></div>
+</div>
+
+
+
+<!-- code folding -->
+
+
+<!-- dynamically load mathjax for compatibility with self-contained -->
+<script>
+  (function () {
+    var script = document.createElement("script");
+    script.type = "text/javascript";
+    script.src  = "https://mathjax.rstudio.com/latest/MathJax.js?config=TeX-AMS-MML_HTMLorMML";
+    document.getElementsByTagName("head")[0].appendChild(script);
+  })();
+</script>
+
+</body>
+</html>

renv/library/windows/R-4.5/x86_64-w64-mingw32/renv/doc/faq.R

@@ -0,0 +1,19 @@
+## ----include=FALSE------------------------------------------------------------
+knitr::opts_chunk$set(
+  collapse = TRUE,
+  comment = "#>",
+  eval = FALSE
+)
+
+## -----------------------------------------------------------------------------
+# renv::settings$snapshot.type("all")
+
+## -----------------------------------------------------------------------------
+# renv::settings$ignored.packages("<package>")
+
+## -----------------------------------------------------------------------------
+# renv::settings$snapshot.type("explicit")
+
+## -----------------------------------------------------------------------------
+# renv::install()
+

renv/library/windows/R-4.5/x86_64-w64-mingw32/renv/doc/faq.Rmd

@@ -0,0 +1,122 @@
+---
+title: "Frequently asked questions"
+output: rmarkdown::html_vignette
+vignette: >
+  %\VignetteIndexEntry{Frequently asked questions}
+  %\VignetteEngine{knitr::rmarkdown}
+  %\VignetteEncoding{UTF-8}
+---
+
+```{r, include=FALSE}
+knitr::opts_chunk$set(
+  collapse = TRUE,
+  comment = "#>",
+  eval = FALSE
+)
+```
+
+## Why isn't my package being snapshotted into the lockfile?
+
+For a package to be recorded in the lockfile, it must be both:
+
+1.  Installed your project library, *and*
+
+2.  Used by the project, as determined by `renv::dependencies()`.
+
+This ensures that only the packages you truly require for your project will enter the lockfile; development dependencies (e.g. `devtools`) normally should not.
+
+So if you find a package is not entering the lockfile, check the output of `renv::dependencies()`.
+If an expected package is not listed, it's likely because `dependencies()` uses static analysis and does not understand all of the different ways in which a package might be used in a project.
+See the docs for more details.
+
+### Capturing all dependencies
+
+If you'd instead prefer to capture *all* packages installed into your project library (and eschew dependency discovery altogether), you can do so with:
+
+```{r}
+renv::settings$snapshot.type("all")
+```
+
+Packages can also be explicitly ignored through a project setting, e.g. with:
+
+```{r}
+renv::settings$ignored.packages("<package>")
+```
+
+You might also want to double-check the set of ignored packages (`renv::settings$ignored.packages()`) and confirm that you aren't unintentionally ignoring a package you actually require.
+
+See the documentation in `?snapshot` for more details.
+
+### Capturing explicit dependencies
+
+If you'd like to explicitly declare which packages your project depends on, you can do so by telling renv to form "explicit" snapshots:
+
+```{r}
+renv::settings$snapshot.type("explicit")
+```
+
+In this mode, renv will only include packages which are explicitly listed in the project's `DESCRIPTION` file as dependencies.
+
+## How do I update the lockfile?
+
+The most important thing to remember is that `renv::snapshot()` captures the state of your project at the point in time when `renv::snapshot()` was called.
+In that sense, the "right" way to update the lockfile is to:
+
+1.  Load the renv project,
+2.  Make the changes you want; e.g. install packages; call `options(repos = <...>)`; ...
+3.  Call `renv::snapshot()` to update the lockfile.
+
+That said, you are also free to modify the `renv.lock` lockfile by hand if necessary; e.g. if you want to manually add / change repositories, change the version of a package used, and so on.
+The `renv.lock` lockfile is a [JSON](https://www.json.org/json-en.html) file. A [JSON schema](https://json-schema.org/) is provided in the [renv repository](https://github.com/rstudio/renv/tree/main/inst/schema).
+
+The main downside to editing a package record in the lockfile directly is that you won't be able to provide a `Hash` for that package, and so renv won't be able to use its global package cache when installing that package.
+
+## How should I handle development dependencies?
+
+This is related to the above question: by design, `renv.lock` normally only captures build-time or deploy-time dependencies; it may not capture the packages that you use in iterative workflows (e.g. `devtools`).
+However, you may want some way of still ensuring these development dependencies get installed when trying to restore a project library.
+
+For cases like these, we recommend tracking these packages in a project DESCRIPTION file; typically, within the `Suggests:` field.
+Then, you can execute:
+
+```{r}
+renv::install()
+```
+
+to request that renv install the packages as described in the DESCRIPTION file.
+In addition, the `Remotes:` fields will be parsed and used, to ensure packages are installed from their declared remote source as appropriate.
+
+## I'm returning to an older renv project. What do I do?
+
+Suppose you were using renv to manage an older project's dependencies.
+You have an older lockfile, capturing the dependencies in use when you were last working with that project.
+You now need to resume work on this project -- what do you do?
+
+The answer depends on how exactly you want to use the project.
+Do you want to treat it as a "time capsule", with dependencies frozen in time?
+Or are the dependencies in this project fluid, and you are primarily using renv just for isolation of project dependencies?
+
+For time capsules, use `renv::restore()` to reinstall the exact packages as declared in the project lockfile `renv.lock`.
+You may also need to find and install the older version of R used previously with that project, unless your intention is to upgrade R.
+
+For projects with fluid dependencies, call `renv::update()` to get the latest versions of the dependencies.
+Once you've verified that the code still works (or made the changes needed to get it working), call `renv::snapshot()` to record the latest versions.
+
+You can also take a more managed approach, that's somewhat in between the two extremes:
+
+1.  Use `renv::restore()` to restore the project state as defined in the lockfile.
+
+2.  Install and update packages deliberately with `renv::install()` and friends.
+
+3.  Verify your code works, then call `renv::snapshot()` to update the new lockfile.
+
+## Why are package downloads failing?
+
+Some issues ultimately boil down to a lack of connectivity between your machine and the R package repositories and remote sources you are trying to use.
+If you are working in a corporate environment, it may be worth confirming whether you have a corporate proxy in place inhibiting internet access, or whether R and renv need to be configured in a way compatible with your working environment.
+This is often true on Windows machines in enterprise environments, where the default "wininet" download method may work more reliably than others.
+Learn more in `vignette("package-install")`.
+
+In addition, note that renv places shims on the R search path that re-routes calls from `install.packages()` to `renv::install()`.
+If you need to bypass these shims, you can use `utils::install.packages(<...>)`; that is, with the call to `install.packages()` explicitly qualified with the package `utils::`.
+See `?renv::load` more details.

renv/library/windows/R-4.5/x86_64-w64-mingw32/renv/doc/faq.html

@@ -0,0 +1,491 @@
+<!DOCTYPE html>
+
+<html>
+
+<head>
+
+<meta charset="utf-8" />
+<meta name="generator" content="pandoc" />
+<meta http-equiv="X-UA-Compatible" content="IE=EDGE" />
+
+<meta name="viewport" content="width=device-width, initial-scale=1" />
+
+
+
+<title>Frequently asked questions</title>
+
+<script>// Pandoc 2.9 adds attributes on both header and div. We remove the former (to
+// be compatible with the behavior of Pandoc < 2.8).
+document.addEventListener('DOMContentLoaded', function(e) {
+  var hs = document.querySelectorAll("div.section[class*='level'] > :first-child");
+  var i, h, a;
+  for (i = 0; i < hs.length; i++) {
+    h = hs[i];
+    if (!/^h[1-6]$/i.test(h.tagName)) continue;  // it should be a header h1-h6
+    a = h.attributes;
+    while (a.length > 0) h.removeAttribute(a[0].name);
+  }
+});
+</script>
+
+<style type="text/css">
+code{white-space: pre-wrap;}
+span.smallcaps{font-variant: small-caps;}
+span.underline{text-decoration: underline;}
+div.column{display: inline-block; vertical-align: top; width: 50%;}
+div.hanging-indent{margin-left: 1.5em; text-indent: -1.5em;}
+ul.task-list{list-style: none;}
+</style>
+
+
+
+<style type="text/css">
+code {
+white-space: pre;
+}
+.sourceCode {
+overflow: visible;
+}
+</style>
+<style type="text/css" data-origin="pandoc">
+html { -webkit-text-size-adjust: 100%; }
+pre > code.sourceCode { white-space: pre; position: relative; }
+pre > code.sourceCode > span { display: inline-block; line-height: 1.25; }
+pre > code.sourceCode > span:empty { height: 1.2em; }
+.sourceCode { overflow: visible; }
+code.sourceCode > span { color: inherit; text-decoration: inherit; }
+div.sourceCode { margin: 1em 0; }
+pre.sourceCode { margin: 0; }
+@media screen {
+div.sourceCode { overflow: auto; }
+}
+@media print {
+pre > code.sourceCode { white-space: pre-wrap; }
+pre > code.sourceCode > span { text-indent: -5em; padding-left: 5em; }
+}
+pre.numberSource code
+{ counter-reset: source-line 0; }
+pre.numberSource code > span
+{ position: relative; left: -4em; counter-increment: source-line; }
+pre.numberSource code > span > a:first-child::before
+{ content: counter(source-line);
+position: relative; left: -1em; text-align: right; vertical-align: baseline;
+border: none; display: inline-block;
+-webkit-touch-callout: none; -webkit-user-select: none;
+-khtml-user-select: none; -moz-user-select: none;
+-ms-user-select: none; user-select: none;
+padding: 0 4px; width: 4em;
+color: #aaaaaa;
+}
+pre.numberSource { margin-left: 3em; border-left: 1px solid #aaaaaa; padding-left: 4px; }
+div.sourceCode
+{ }
+@media screen {
+pre > code.sourceCode > span > a:first-child::before { text-decoration: underline; }
+}
+code span.al { color: #ff0000; font-weight: bold; } 
+code span.an { color: #60a0b0; font-weight: bold; font-style: italic; } 
+code span.at { color: #7d9029; } 
+code span.bn { color: #40a070; } 
+code span.bu { color: #008000; } 
+code span.cf { color: #007020; font-weight: bold; } 
+code span.ch { color: #4070a0; } 
+code span.cn { color: #880000; } 
+code span.co { color: #60a0b0; font-style: italic; } 
+code span.cv { color: #60a0b0; font-weight: bold; font-style: italic; } 
+code span.do { color: #ba2121; font-style: italic; } 
+code span.dt { color: #902000; } 
+code span.dv { color: #40a070; } 
+code span.er { color: #ff0000; font-weight: bold; } 
+code span.ex { } 
+code span.fl { color: #40a070; } 
+code span.fu { color: #06287e; } 
+code span.im { color: #008000; font-weight: bold; } 
+code span.in { color: #60a0b0; font-weight: bold; font-style: italic; } 
+code span.kw { color: #007020; font-weight: bold; } 
+code span.op { color: #666666; } 
+code span.ot { color: #007020; } 
+code span.pp { color: #bc7a00; } 
+code span.sc { color: #4070a0; } 
+code span.ss { color: #bb6688; } 
+code span.st { color: #4070a0; } 
+code span.va { color: #19177c; } 
+code span.vs { color: #4070a0; } 
+code span.wa { color: #60a0b0; font-weight: bold; font-style: italic; } 
+</style>
+<script>
+// apply pandoc div.sourceCode style to pre.sourceCode instead
+(function() {
+  var sheets = document.styleSheets;
+  for (var i = 0; i < sheets.length; i++) {
+    if (sheets[i].ownerNode.dataset["origin"] !== "pandoc") continue;
+    try { var rules = sheets[i].cssRules; } catch (e) { continue; }
+    var j = 0;
+    while (j < rules.length) {
+      var rule = rules[j];
+      // check if there is a div.sourceCode rule
+      if (rule.type !== rule.STYLE_RULE || rule.selectorText !== "div.sourceCode") {
+        j++;
+        continue;
+      }
+      var style = rule.style.cssText;
+      // check if color or background-color is set
+      if (rule.style.color === '' && rule.style.backgroundColor === '') {
+        j++;
+        continue;
+      }
+      // replace div.sourceCode by a pre.sourceCode rule
+      sheets[i].deleteRule(j);
+      sheets[i].insertRule('pre.sourceCode{' + style + '}', j);
+    }
+  }
+})();
+</script>
+
+
+
+
+<style type="text/css">body {
+background-color: #fff;
+margin: 1em auto;
+max-width: 700px;
+overflow: visible;
+padding-left: 2em;
+padding-right: 2em;
+font-family: "Open Sans", "Helvetica Neue", Helvetica, Arial, sans-serif;
+font-size: 14px;
+line-height: 1.35;
+}
+#TOC {
+clear: both;
+margin: 0 0 10px 10px;
+padding: 4px;
+width: 400px;
+border: 1px solid #CCCCCC;
+border-radius: 5px;
+background-color: #f6f6f6;
+font-size: 13px;
+line-height: 1.3;
+}
+#TOC .toctitle {
+font-weight: bold;
+font-size: 15px;
+margin-left: 5px;
+}
+#TOC ul {
+padding-left: 40px;
+margin-left: -1.5em;
+margin-top: 5px;
+margin-bottom: 5px;
+}
+#TOC ul ul {
+margin-left: -2em;
+}
+#TOC li {
+line-height: 16px;
+}
+table {
+margin: 1em auto;
+border-width: 1px;
+border-color: #DDDDDD;
+border-style: outset;
+border-collapse: collapse;
+}
+table th {
+border-width: 2px;
+padding: 5px;
+border-style: inset;
+}
+table td {
+border-width: 1px;
+border-style: inset;
+line-height: 18px;
+padding: 5px 5px;
+}
+table, table th, table td {
+border-left-style: none;
+border-right-style: none;
+}
+table thead, table tr.even {
+background-color: #f7f7f7;
+}
+p {
+margin: 0.5em 0;
+}
+blockquote {
+background-color: #f6f6f6;
+padding: 0.25em 0.75em;
+}
+hr {
+border-style: solid;
+border: none;
+border-top: 1px solid #777;
+margin: 28px 0;
+}
+dl {
+margin-left: 0;
+}
+dl dd {
+margin-bottom: 13px;
+margin-left: 13px;
+}
+dl dt {
+font-weight: bold;
+}
+ul {
+margin-top: 0;
+}
+ul li {
+list-style: circle outside;
+}
+ul ul {
+margin-bottom: 0;
+}
+pre, code {
+background-color: #f7f7f7;
+border-radius: 3px;
+color: #333;
+white-space: pre-wrap; 
+}
+pre {
+border-radius: 3px;
+margin: 5px 0px 10px 0px;
+padding: 10px;
+}
+pre:not([class]) {
+background-color: #f7f7f7;
+}
+code {
+font-family: Consolas, Monaco, 'Courier New', monospace;
+font-size: 85%;
+}
+p > code, li > code {
+padding: 2px 0px;
+}
+div.figure {
+text-align: center;
+}
+img {
+background-color: #FFFFFF;
+padding: 2px;
+border: 1px solid #DDDDDD;
+border-radius: 3px;
+border: 1px solid #CCCCCC;
+margin: 0 5px;
+}
+h1 {
+margin-top: 0;
+font-size: 35px;
+line-height: 40px;
+}
+h2 {
+border-bottom: 4px solid #f7f7f7;
+padding-top: 10px;
+padding-bottom: 2px;
+font-size: 145%;
+}
+h3 {
+border-bottom: 2px solid #f7f7f7;
+padding-top: 10px;
+font-size: 120%;
+}
+h4 {
+border-bottom: 1px solid #f7f7f7;
+margin-left: 8px;
+font-size: 105%;
+}
+h5, h6 {
+border-bottom: 1px solid #ccc;
+font-size: 105%;
+}
+a {
+color: #0033dd;
+text-decoration: none;
+}
+a:hover {
+color: #6666ff; }
+a:visited {
+color: #800080; }
+a:visited:hover {
+color: #BB00BB; }
+a[href^="http:"] {
+text-decoration: underline; }
+a[href^="https:"] {
+text-decoration: underline; }
+
+code > span.kw { color: #555; font-weight: bold; } 
+code > span.dt { color: #902000; } 
+code > span.dv { color: #40a070; } 
+code > span.bn { color: #d14; } 
+code > span.fl { color: #d14; } 
+code > span.ch { color: #d14; } 
+code > span.st { color: #d14; } 
+code > span.co { color: #888888; font-style: italic; } 
+code > span.ot { color: #007020; } 
+code > span.al { color: #ff0000; font-weight: bold; } 
+code > span.fu { color: #900; font-weight: bold; } 
+code > span.er { color: #a61717; background-color: #e3d2d2; } 
+</style>
+
+
+
+
+</head>
+
+<body>
+
+
+
+
+<h1 class="title toc-ignore">Frequently asked questions</h1>
+
+
+
+<div id="why-isnt-my-package-being-snapshotted-into-the-lockfile" class="section level2">
+<h2>Why isn’t my package being snapshotted into the lockfile?</h2>
+<p>For a package to be recorded in the lockfile, it must be both:</p>
+<ol style="list-style-type: decimal">
+<li><p>Installed your project library, <em>and</em></p></li>
+<li><p>Used by the project, as determined by
+<code>renv::dependencies()</code>.</p></li>
+</ol>
+<p>This ensures that only the packages you truly require for your
+project will enter the lockfile; development dependencies
+(e.g. <code>devtools</code>) normally should not.</p>
+<p>So if you find a package is not entering the lockfile, check the
+output of <code>renv::dependencies()</code>. If an expected package is
+not listed, it’s likely because <code>dependencies()</code> uses static
+analysis and does not understand all of the different ways in which a
+package might be used in a project. See the docs for more details.</p>
+<div id="capturing-all-dependencies" class="section level3">
+<h3>Capturing all dependencies</h3>
+<p>If you’d instead prefer to capture <em>all</em> packages installed
+into your project library (and eschew dependency discovery altogether),
+you can do so with:</p>
+<div class="sourceCode" id="cb1"><pre class="sourceCode r"><code class="sourceCode r"><span id="cb1-1"><a href="#cb1-1" tabindex="-1"></a>renv<span class="sc">::</span>settings<span class="sc">$</span><span class="fu">snapshot.type</span>(<span class="st">&quot;all&quot;</span>)</span></code></pre></div>
+<p>Packages can also be explicitly ignored through a project setting,
+e.g. with:</p>
+<div class="sourceCode" id="cb2"><pre class="sourceCode r"><code class="sourceCode r"><span id="cb2-1"><a href="#cb2-1" tabindex="-1"></a>renv<span class="sc">::</span>settings<span class="sc">$</span><span class="fu">ignored.packages</span>(<span class="st">&quot;&lt;package&gt;&quot;</span>)</span></code></pre></div>
+<p>You might also want to double-check the set of ignored packages
+(<code>renv::settings$ignored.packages()</code>) and confirm that you
+aren’t unintentionally ignoring a package you actually require.</p>
+<p>See the documentation in <code>?snapshot</code> for more details.</p>
+</div>
+<div id="capturing-explicit-dependencies" class="section level3">
+<h3>Capturing explicit dependencies</h3>
+<p>If you’d like to explicitly declare which packages your project
+depends on, you can do so by telling renv to form “explicit”
+snapshots:</p>
+<div class="sourceCode" id="cb3"><pre class="sourceCode r"><code class="sourceCode r"><span id="cb3-1"><a href="#cb3-1" tabindex="-1"></a>renv<span class="sc">::</span>settings<span class="sc">$</span><span class="fu">snapshot.type</span>(<span class="st">&quot;explicit&quot;</span>)</span></code></pre></div>
+<p>In this mode, renv will only include packages which are explicitly
+listed in the project’s <code>DESCRIPTION</code> file as
+dependencies.</p>
+</div>
+</div>
+<div id="how-do-i-update-the-lockfile" class="section level2">
+<h2>How do I update the lockfile?</h2>
+<p>The most important thing to remember is that
+<code>renv::snapshot()</code> captures the state of your project at the
+point in time when <code>renv::snapshot()</code> was called. In that
+sense, the “right” way to update the lockfile is to:</p>
+<ol style="list-style-type: decimal">
+<li>Load the renv project,</li>
+<li>Make the changes you want; e.g. install packages; call
+<code>options(repos = &lt;...&gt;)</code>; …</li>
+<li>Call <code>renv::snapshot()</code> to update the lockfile.</li>
+</ol>
+<p>That said, you are also free to modify the <code>renv.lock</code>
+lockfile by hand if necessary; e.g. if you want to manually add / change
+repositories, change the version of a package used, and so on. The
+<code>renv.lock</code> lockfile is a <a href="https://www.json.org/json-en.html">JSON</a> file. A <a href="https://json-schema.org/">JSON schema</a> is provided in the <a href="https://github.com/rstudio/renv/tree/main/inst/schema">renv
+repository</a>.</p>
+<p>The main downside to editing a package record in the lockfile
+directly is that you won’t be able to provide a <code>Hash</code> for
+that package, and so renv won’t be able to use its global package cache
+when installing that package.</p>
+</div>
+<div id="how-should-i-handle-development-dependencies" class="section level2">
+<h2>How should I handle development dependencies?</h2>
+<p>This is related to the above question: by design,
+<code>renv.lock</code> normally only captures build-time or deploy-time
+dependencies; it may not capture the packages that you use in iterative
+workflows (e.g. <code>devtools</code>). However, you may want some way
+of still ensuring these development dependencies get installed when
+trying to restore a project library.</p>
+<p>For cases like these, we recommend tracking these packages in a
+project DESCRIPTION file; typically, within the <code>Suggests:</code>
+field. Then, you can execute:</p>
+<div class="sourceCode" id="cb4"><pre class="sourceCode r"><code class="sourceCode r"><span id="cb4-1"><a href="#cb4-1" tabindex="-1"></a>renv<span class="sc">::</span><span class="fu">install</span>()</span></code></pre></div>
+<p>to request that renv install the packages as described in the
+DESCRIPTION file. In addition, the <code>Remotes:</code> fields will be
+parsed and used, to ensure packages are installed from their declared
+remote source as appropriate.</p>
+</div>
+<div id="im-returning-to-an-older-renv-project.-what-do-i-do" class="section level2">
+<h2>I’m returning to an older renv project. What do I do?</h2>
+<p>Suppose you were using renv to manage an older project’s
+dependencies. You have an older lockfile, capturing the dependencies in
+use when you were last working with that project. You now need to resume
+work on this project – what do you do?</p>
+<p>The answer depends on how exactly you want to use the project. Do you
+want to treat it as a “time capsule”, with dependencies frozen in time?
+Or are the dependencies in this project fluid, and you are primarily
+using renv just for isolation of project dependencies?</p>
+<p>For time capsules, use <code>renv::restore()</code> to reinstall the
+exact packages as declared in the project lockfile
+<code>renv.lock</code>. You may also need to find and install the older
+version of R used previously with that project, unless your intention is
+to upgrade R.</p>
+<p>For projects with fluid dependencies, call
+<code>renv::update()</code> to get the latest versions of the
+dependencies. Once you’ve verified that the code still works (or made
+the changes needed to get it working), call
+<code>renv::snapshot()</code> to record the latest versions.</p>
+<p>You can also take a more managed approach, that’s somewhat in between
+the two extremes:</p>
+<ol style="list-style-type: decimal">
+<li><p>Use <code>renv::restore()</code> to restore the project state as
+defined in the lockfile.</p></li>
+<li><p>Install and update packages deliberately with
+<code>renv::install()</code> and friends.</p></li>
+<li><p>Verify your code works, then call <code>renv::snapshot()</code>
+to update the new lockfile.</p></li>
+</ol>
+</div>
+<div id="why-are-package-downloads-failing" class="section level2">
+<h2>Why are package downloads failing?</h2>
+<p>Some issues ultimately boil down to a lack of connectivity between
+your machine and the R package repositories and remote sources you are
+trying to use. If you are working in a corporate environment, it may be
+worth confirming whether you have a corporate proxy in place inhibiting
+internet access, or whether R and renv need to be configured in a way
+compatible with your working environment. This is often true on Windows
+machines in enterprise environments, where the default “wininet”
+download method may work more reliably than others. Learn more in
+<code>vignette(&quot;package-install&quot;)</code>.</p>
+<p>In addition, note that renv places shims on the R search path that
+re-routes calls from <code>install.packages()</code> to
+<code>renv::install()</code>. If you need to bypass these shims, you can
+use <code>utils::install.packages(&lt;...&gt;)</code>; that is, with the
+call to <code>install.packages()</code> explicitly qualified with the
+package <code>utils::</code>. See <code>?renv::load</code> more
+details.</p>
+</div>
+
+
+
+<!-- code folding -->
+
+
+<!-- dynamically load mathjax for compatibility with self-contained -->
+<script>
+  (function () {
+    var script = document.createElement("script");
+    script.type = "text/javascript";
+    script.src  = "https://mathjax.rstudio.com/latest/MathJax.js?config=TeX-AMS-MML_HTMLorMML";
+    document.getElementsByTagName("head")[0].appendChild(script);
+  })();
+</script>
+
+</body>
+</html>

renv/library/windows/R-4.5/x86_64-w64-mingw32/renv/doc/index.html

@@ -0,0 +1,79 @@
+<!DOCTYPE html>
+<html>
+<head><title>R: Vignettes and other documentation</title>
+<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+<meta name="viewport" content="width=device-width, initial-scale=1.0, user-scalable=yes" />
+<link rel="stylesheet" type="text/css" href="/doc/html/R.css" />
+</head><body><div class="container">
+<h1> Vignettes and other documentation
+<img class="toplogo" src="/doc/html/Rlogo.svg" alt="[R logo]" />
+</h1>
+<hr/>
+<div style="text-align: center;">
+<a href="/doc/html/index.html"><img class="arrow" src="/doc/html/up.jpg" alt="[Top]" /></a>
+</div>
+<h2>Vignettes from package 'renv'</h2>
+<table style="width: 100%;">
+<col style="width: 22%;" />
+<col style="width:  2%;" />
+<col style="width: 50%;" />
+<col style="width:  8%;" />
+<col style="width:  8%;" />
+<col style="width:  8%;" />
+<tr><td style="text-align: right; vertical-align: top;"><a href="../../../library/renv/doc/ci.html">renv::ci</a></td>
+<td></td><td style="vertical-align: top;">Using renv with continuous integration</td>
+<td style="vertical-align: top;"><a href="../../../library/renv/doc/ci.html">HTML</a></td>
+<td style="vertical-align: top;"><a href="../../../library/renv/doc/ci.Rmd">source</a></td>
+<td style="vertical-align: top; white-space: nowrap"><a href="../../../library/renv/doc/ci.R">R code</a></td></tr>
+<tr><td style="text-align: right; vertical-align: top;"><a href="../../../library/renv/doc/docker.html">renv::docker</a></td>
+<td></td><td style="vertical-align: top;">Using renv with Docker</td>
+<td style="vertical-align: top;"><a href="../../../library/renv/doc/docker.html">HTML</a></td>
+<td style="vertical-align: top;"><a href="../../../library/renv/doc/docker.Rmd">source</a></td>
+<td style="vertical-align: top; white-space: nowrap"><a href="../../../library/renv/doc/docker.R">R code</a></td></tr>
+<tr><td style="text-align: right; vertical-align: top;"><a href="../../../library/renv/doc/faq.html">renv::faq</a></td>
+<td></td><td style="vertical-align: top;">Frequently asked questions</td>
+<td style="vertical-align: top;"><a href="../../../library/renv/doc/faq.html">HTML</a></td>
+<td style="vertical-align: top;"><a href="../../../library/renv/doc/faq.Rmd">source</a></td>
+<td style="vertical-align: top; white-space: nowrap"><a href="../../../library/renv/doc/faq.R">R code</a></td></tr>
+<tr><td style="text-align: right; vertical-align: top;"><a href="../../../library/renv/doc/package-install.html">renv::package-install</a></td>
+<td></td><td style="vertical-align: top;">Installing packages</td>
+<td style="vertical-align: top;"><a href="../../../library/renv/doc/package-install.html">HTML</a></td>
+<td style="vertical-align: top;"><a href="../../../library/renv/doc/package-install.Rmd">source</a></td>
+<td style="vertical-align: top; white-space: nowrap"><a href="../../../library/renv/doc/package-install.R">R code</a></td></tr>
+<tr><td style="text-align: right; vertical-align: top;"><a href="../../../library/renv/doc/package-sources.html">renv::package-sources</a></td>
+<td></td><td style="vertical-align: top;">Package sources</td>
+<td style="vertical-align: top;"><a href="../../../library/renv/doc/package-sources.html">HTML</a></td>
+<td style="vertical-align: top;"><a href="../../../library/renv/doc/package-sources.Rmd">source</a></td>
+<td style="vertical-align: top; white-space: nowrap"><a href="../../../library/renv/doc/package-sources.R">R code</a></td></tr>
+<tr><td style="text-align: right; vertical-align: top;"><a href="../../../library/renv/doc/packages.html">renv::packages</a></td>
+<td></td><td style="vertical-align: top;">Package development</td>
+<td style="vertical-align: top;"><a href="../../../library/renv/doc/packages.html">HTML</a></td>
+<td style="vertical-align: top;"><a href="../../../library/renv/doc/packages.Rmd">source</a></td>
+<td style="vertical-align: top; white-space: nowrap"><a href="../../../library/renv/doc/packages.R">R code</a></td></tr>
+<tr><td style="text-align: right; vertical-align: top;"><a href="../../../library/renv/doc/packrat.html">renv::packrat</a></td>
+<td></td><td style="vertical-align: top;">packrat vs. renv</td>
+<td style="vertical-align: top;"><a href="../../../library/renv/doc/packrat.html">HTML</a></td>
+<td style="vertical-align: top;"><a href="../../../library/renv/doc/packrat.Rmd">source</a></td>
+<td style="vertical-align: top; white-space: nowrap"><a href="../../../library/renv/doc/packrat.R">R code</a></td></tr>
+<tr><td style="text-align: right; vertical-align: top;"><a href="../../../library/renv/doc/profiles.html">renv::profiles</a></td>
+<td></td><td style="vertical-align: top;">Project profiles</td>
+<td style="vertical-align: top;"><a href="../../../library/renv/doc/profiles.html">HTML</a></td>
+<td style="vertical-align: top;"><a href="../../../library/renv/doc/profiles.Rmd">source</a></td>
+<td style="vertical-align: top; white-space: nowrap"><a href="../../../library/renv/doc/profiles.R">R code</a></td></tr>
+<tr><td style="text-align: right; vertical-align: top;"><a href="../../../library/renv/doc/python.html">renv::python</a></td>
+<td></td><td style="vertical-align: top;">Using Python with renv</td>
+<td style="vertical-align: top;"><a href="../../../library/renv/doc/python.html">HTML</a></td>
+<td style="vertical-align: top;"><a href="../../../library/renv/doc/python.Rmd">source</a></td>
+<td style="vertical-align: top; white-space: nowrap"><a href="../../../library/renv/doc/python.R">R code</a></td></tr>
+<tr><td style="text-align: right; vertical-align: top;"><a href="../../../library/renv/doc/renv.html">renv::renv</a></td>
+<td></td><td style="vertical-align: top;">Introduction to renv</td>
+<td style="vertical-align: top;"><a href="../../../library/renv/doc/renv.html">HTML</a></td>
+<td style="vertical-align: top;"><a href="../../../library/renv/doc/renv.Rmd">source</a></td>
+<td style="vertical-align: top; white-space: nowrap"><a href="../../../library/renv/doc/renv.R">R code</a></td></tr>
+<tr><td style="text-align: right; vertical-align: top;"><a href="../../../library/renv/doc/rsconnect.html">renv::rsconnect</a></td>
+<td></td><td style="vertical-align: top;">Using renv with Posit Connect</td>
+<td style="vertical-align: top;"><a href="../../../library/renv/doc/rsconnect.html">HTML</a></td>
+<td style="vertical-align: top;"><a href="../../../library/renv/doc/rsconnect.Rmd">source</a></td>
+<td style="vertical-align: top; white-space: nowrap"><a href="../../../library/renv/doc/rsconnect.R">R code</a></td></tr>
+</table>
+</div></body></html>

renv/library/windows/R-4.5/x86_64-w64-mingw32/renv/doc/package-install.R

@@ -0,0 +1,93 @@
+## ----include=FALSE------------------------------------------------------------
+knitr::opts_chunk$set(
+  collapse = TRUE,
+  comment = "#>",
+  eval = FALSE
+)
+
+## -----------------------------------------------------------------------------
+# # restore packages from the lockfile, bypassing the cache
+# renv::restore(rebuild = TRUE)
+# 
+# # re-install a package
+# renv::install("<package>", rebuild = TRUE)
+# 
+# # rebuild all packages in the project
+# renv::rebuild()
+
+## -----------------------------------------------------------------------------
+# # installation of RNetCDF may require us to set include paths for netcdf
+# configure.args = c(RNetCDF = "--with-netcdf-include=/usr/include/udunits2")
+# options(configure.args = configure.args)
+# renv::install("RNetCDF")
+
+## -----------------------------------------------------------------------------
+# options(
+#   configure.args.RNetCDF = "--with-netcdf-include=/usr/include/udunits2"
+# )
+# renv::install("RNetCDF")
+
+## -----------------------------------------------------------------------------
+# # installation of R packages using the Windows Subsystem for Linux
+# # may require the `--no-lock` flag to be set during install
+# options(install.opts = "--no-lock")
+# renv::install("xml2")
+# 
+# # alternatively, you can set such options for specific packages with e.g.
+# options(install.opts = list(xml2 = "--no-lock"))
+# renv::install("xml2")
+
+## -----------------------------------------------------------------------------
+# options(renv.download.override = utils::download.file)
+
+## -----------------------------------------------------------------------------
+# # use Windows' internal download machinery
+# Sys.setenv(RENV_DOWNLOAD_METHOD = "wininet")
+# 
+# # use R's bundled libcurl implementation
+# Sys.setenv(RENV_DOWNLOAD_METHOD = "libcurl")
+
+## -----------------------------------------------------------------------------
+# getOption("download.file.method")
+
+## -----------------------------------------------------------------------------
+# renv:::renv_download_method()
+
+## -----------------------------------------------------------------------------
+# Sys.setenv(RENV_DOWNLOAD_METHOD = getOption("download.file.method"))
+
+## -----------------------------------------------------------------------------
+# curl::ie_get_proxy_for_url()
+
+## -----------------------------------------------------------------------------
+# # define a function providing authentication
+# options(renv.auth = function(package, record) {
+#   if (package == "MyPackage")
+#     return(list(GITHUB_PAT = "<pat>"))
+# })
+# 
+# # use a named list directly
+# options(renv.auth = list(
+#   MyPackage = list(GITHUB_PAT = "<pat>")
+# ))
+# 
+# # alternatively, set package-specific option
+# # as a list
+# options(renv.auth.MyPackage = list(GITHUB_PAT = "<pat>"))
+# # as a function
+# options(renv.auth.MyPackage = function(record) {
+#    list(GITHUB_PAT = "<pat>")
+# })
+
+## -----------------------------------------------------------------------------
+# renv::install("igraph=igraph/rigraph")
+
+## -----------------------------------------------------------------------------
+# options(renv.download.headers = function(url) {
+#   if (grepl("^https://my/repository", url))
+#     return(c(Authorization = Sys.getenv("AUTH_HEADER")))
+# })
+
+## -----------------------------------------------------------------------------
+# options(renv.download.trace = TRUE)
+

renv/library/windows/R-4.5/x86_64-w64-mingw32/renv/doc/package-install.Rmd

@@ -0,0 +1,372 @@
+---
+title: "Installing packages"
+output: rmarkdown::html_vignette
+vignette: >
+  %\VignetteIndexEntry{Installing packages}
+  %\VignetteEngine{knitr::rmarkdown}
+  %\VignetteEncoding{UTF-8}
+---
+
+```{r, include=FALSE}
+knitr::opts_chunk$set(
+  collapse = TRUE,
+  comment = "#>",
+  eval = FALSE
+)
+```
+
+Package installation is an important part of renv.
+This vignette gives you the details, starting with an overview of renv's cache, before going into various installation challenges around building from source and downloading with proxies or authentication.
+
+## Cache
+
+One of renv's primary features is the global package cache, which shared across all projects.
+The renv package cache provides two primary benefits:
+
+1.  Installing and restoring packages is much faster, as renv can find and re-use previously installed packages from the cache.
+
+2.  Projects take up less disk space, because each project doesn't need to contain it's own copy of every package.
+
+When installing a package, renv installs into the global cache and then adds a symlink[^1] to that directory in the project library.
+That way each renv project remains isolated from other projects on your system, but they can still re-use the same installed packages.
+
+[^1]: Or junction points, on Windows.
+    Junction points are unfortunately not supported on Windows network shares; see [Hard links and junctions](https://learn.microsoft.com/en-us/windows/win32/fileio/hard-links-and-junctions) for more details.
+
+The process by which packages enter the cache is roughly as follows:
+
+1.  Package installation is requested via e.g. `install.packages()`, or `renv::install()`, or as part of `renv::restore()`.
+
+2.  If renv is able to find the requested version of the package in the cache, then that package is linked into the project library, and installation is complete.
+
+3.  Otherwise, the package is downloaded and installed into the project library.
+
+4.  After installation of the package has successfully completed, the package is then copied into the global package cache, and then symlinked into the project library.
+
+In some cases, renv will be unable to directly link from the global package cache to your project library, e.g. if the package cache and your project library live on different disk volumes.
+In such a case, renv will instead copy the package from the cache into the project library.
+This is much slower, so is worth avoiding.
+
+### Cache location
+
+You can find the location of the current cache with `renv::paths$cache()`.
+By default, it will be in one of the following folders:
+
+-   Linux:   `~/.cache/R/renv/cache`
+-   macOS:   `~/Library/Caches/org.R-project.R/R/renv/cache`
+-   Windows: `%LOCALAPPDATA%/renv/cache`
+
+If you'd like to share the package cache across multiple users, you can do so by setting the `RENV_PATHS_CACHE` environment variable to a shared path.
+This variable should be set in an R startup file to make it apply to all R sessions.
+While you can set it in a project-local `.Renviron`, or the user-level `~/.Renviron`, we generally recommend using the R installation's site-wide `Renviron.site` if you'd like to ensure the same cache path is visible to all users of R on a system.
+
+You may also want to set `RENV_PATHS_CACHE` so that the global package cache can be stored on the same volume as the projects you normally work on.
+This is especially important when working projects stored on a networked filesystem.
+
+### Multiple caches
+
+It is also possible to configure renv to use multiple cache locations.
+For example, you might want to make both a user-local package cache, as well as a global administrator-managed cache, visible within an renv project.
+To do so, you can specify the paths to the cache separated with a `;` (or `:` on Unix if preferred).
+For example:
+
+```sh
+RENV_PATHS_CACHE=/path/to/local/cache;/path/to/global/cache
+```
+
+In such a case, renv will iterate over the cache locations in order when trying to find a package, and newly-installed packages will enter the first writable cache path listed in `RENV_PATHS_CACHE`.
+
+### Shared cache locations
+
+When the renv cache is enabled, if that cache is shared and visible to multiple users, then each of those users will have an opportunity to install packages into the renv cache.
+However, some care must be taken to ensure that these packages can be used by different users in your environment:
+
+1.  Packages copied into the cache may have [Access-control Lists](https://en.wikipedia.org/wiki/Access-control_list) (ACLs), which might prevent others from using packages that have been installed into the cache.
+    If this is the case, it's important that ACLs be set (or updated) on cache entries so that the cache is accessible to each user requiring access.
+    When deploying renv in an enterprise environment, the system administrator should take care to ensure ACLs (if any) allow users access to packages within the renv cache.
+
+2.  By default, packages copied into the cache will remain "owned" by the user that requested installation of that package.
+    If you'd like renv to instead re-assign ownership of the cached package to a separate user account, you can set the `RENV_CACHE_USER` environment variable.
+    When set, renv will attempt to run `chown -R <package> <user>` to update cache ownership after the package has been copied into the cache.
+
+### Caveats
+
+While we recommend enabling the cache by default, if you're having trouble with it, you can disable it by setting the project setting `renv::settings$use.cache(FALSE)`.
+Doing this will ensure that packages are then installed into your project library directly, without attempting to link and use packages from the renv cache.
+
+If you find a problematic package has entered the cache (for example, an installed package has become corrupted), that package can be removed with the `renv::purge()` function.
+See the `?purge` documentation for caveats and things to be aware of when removing packages from the cache.
+
+You can also force a package to be re-installed and re-cached with the following functions:
+
+```{r}
+# restore packages from the lockfile, bypassing the cache
+renv::restore(rebuild = TRUE)
+
+# re-install a package
+renv::install("<package>", rebuild = TRUE)
+
+# rebuild all packages in the project
+renv::rebuild()
+```
+
+See each function's respective documentation for more details.
+
+## Building from source
+
+Where possible, renv will install package binaries, but sometimes a binary is not available and you have to build from source.
+Installation from source can be challenging for a few reasons:
+
+1.  Your system will need to have a compatible compiler toolchain available.
+    In some cases, R packages may depend on C / C++ features that aren't available in an older system toolchain, especially in some older Linux enterprise environments.
+
+2.  Your system will need requisite system libraries, as many R packages contain compiled C / C++ code that depend on and link to these packages.
+
+<!-- TODO: renv::equip() for Linux + macOS; use sysreqsdb -->
+
+### Configure flags
+
+Many `R` packages have a `configure` script that needs to be run to prepare the package for installation.
+Arguments and environment variables can be passed through to those scripts in a manner similar to `install.packages()`.
+In particular, the `R` options `configure.args` and `configure.vars` can be used to map package names to their appropriate configuration.
+For example:
+
+```{r}
+# installation of RNetCDF may require us to set include paths for netcdf
+configure.args = c(RNetCDF = "--with-netcdf-include=/usr/include/udunits2")
+options(configure.args = configure.args)
+renv::install("RNetCDF")
+```
+
+This could also be specified as, for example,
+
+```{r}
+options(
+  configure.args.RNetCDF = "--with-netcdf-include=/usr/include/udunits2"
+)
+renv::install("RNetCDF")
+```
+
+### Install flags
+
+Similarly, additional flags that should be passed to `R CMD INSTALL` can be set via the `install.opts` `R` option:
+
+```{r}
+# installation of R packages using the Windows Subsystem for Linux
+# may require the `--no-lock` flag to be set during install
+options(install.opts = "--no-lock")
+renv::install("xml2")
+
+# alternatively, you can set such options for specific packages with e.g.
+options(install.opts = list(xml2 = "--no-lock"))
+renv::install("xml2")
+```
+
+### Vignettes
+
+renv does not build vignettes when installing a package from source.
+This is because vignettes often require suggested packages, and installing all suggested packages (particularly from source) can be arduous.
+
+If you want to distribute vignettes for your own packages, we suggest creating your own repository of binaries, either with [R Universe](https://r-universe.dev/) (for publicly hosted packages on GitHub), with [Posit Package Manager](https://posit.co/products/enterprise/package-manager/), or with [drat](https://eddelbuettel.github.io/drat/).
+
+## Downloads
+
+By default, renv uses [curl](https://curl.se/) for file downloads when available.
+This allows renv to support a number of download features across multiple versions of R, including:
+
+-   Custom headers (used especially for authentication),
+-   Connection timeouts,
+-   Download retries on transient errors.
+
+If `curl` is not available on your machine, it is highly recommended that you install it.
+Newer versions of Windows 10 come with a bundled version of `curl.exe`; other users on Windows can use `renv::equip()` to download and install a recent copy of `curl`.
+Newer versions of macOS come with a bundled version of `curl` that is adequate for usage with renv, and most Linux package managers have a modern version of `curl` available in their package repositories.
+You can also configure which `curl` executable is used by setting the `RENV_CURL_EXECUTABLE` environment variable, if necessary.
+
+`curl` downloads can be configured through renv's configuration settings -- see `?renv::config` for more details.
+
+### Alternative downloaders
+
+If you've already configured R's downloader and would like to bypass renv's attempts to use `curl`, you can use the R option `renv.download.override`.
+For example, executing:
+
+```{r}
+options(renv.download.override = utils::download.file)
+```
+
+would instruct renv to use R's own download machinery when attempting to download files from the internet (respecting the R options `download.file.method` and `download.file.extra` as appropriate).
+Advanced users can also provide their own download function, provided its signature matches that of `utils::download.file()`.
+
+You can also instruct renv to use a different download method by setting the `RENV_DOWNLOAD_METHOD` environment variable.
+For example:
+
+```{r}
+# use Windows' internal download machinery
+Sys.setenv(RENV_DOWNLOAD_METHOD = "wininet")
+
+# use R's bundled libcurl implementation
+Sys.setenv(RENV_DOWNLOAD_METHOD = "libcurl")
+```
+
+If you find that downloads work outside of renv projects, but not within renv projects, you may need to tell renv to use the same download file method that R has been configured to use.
+You can check which download method R is currently configured to use with:
+
+```{r}
+getOption("download.file.method")
+```
+
+And the downloader currently used by renv can be queried with:
+
+```{r}
+renv:::renv_download_method()
+```
+
+You can force renv to use the same download method as R by setting:
+
+```{r}
+Sys.setenv(RENV_DOWNLOAD_METHOD = getOption("download.file.method"))
+```
+
+and, if necessary, you could also set this environment variable within e.g. your `~/.Renviron`, so that it is visible to all R sessions.
+See `?Startup` for more details.
+
+Note that other features (e.g. authentication) may not be supported when using an alternative download file method -- you will have to configure the downloader yourself if that is required.
+See `?download.file` for more details.
+
+### Proxies
+
+If your downloads need to go through a proxy server, then there are a variety of approaches you can take to make this work:
+
+1.  Set the `http_proxy` and / or `https_proxy` environment variables.
+    These environment variables can contain the full URL to your proxy server, including a username + password if necessary.
+
+2.  You can use a `.curlrc` (`_curlrc` on Windows) to provide information about the proxy server to be used.
+    This file should be placed in your home folder (see `Sys.getenv("HOME")`, or `Sys.getenv("R_USER")` on Windows); alternatively, you can set the `CURL_HOME` environment variable to point to a custom 'home' folder to be used by `curl` when resolving the runtime configuration file.
+    On Windows, you can also place your `_curlrc` in the same directory where the `curl.exe` binary is located.
+
+See the curl documentation on [proxies](https://ec.haxx.se/usingcurl/proxies/) and [config files](https://ec.haxx.se/cmdline/configfile.html) for more details.
+
+As an [example](https://github.com/rstudio/renv/issues/146), the following `_curlrc` works when using authentication with NTLM and SSPI on Windows:
+
+```sh
+--proxy "your.proxy.dns:port"
+--proxy-ntlm
+--proxy-user ":"
+--insecure
+```
+
+The [curl](https://cran.r-project.org/package=curl) R package also has a helper:
+
+```{r}
+curl::ie_get_proxy_for_url()
+```
+
+which may be useful when attempting to discover this proxy address.
+
+### Authentication
+
+Your project may make use of packages which are available from remote sources requiring some form of authentication to access -- for example, a GitHub enterprise server.
+Usually, either a personal access token (PAT) or username + password combination is required for authentication.
+renv is able to authenticate when downloading from such sources, using the same system as the [remotes](https://cran.r-project.org/package=remotes) package.
+In particular, environment variables are used to record and transfer the required authentication information.
+
+| **Remote Source** | **Authentication**                      |
+|-------------------|-----------------------------------------|
+| GitHub            | `GITHUB_PAT`                            |
+| GitLab            | `GITLAB_PAT`                            |
+| Bitbucket         | `BITBUCKET_USER` + `BITBUCKET_PASSWORD` |
+| Git Remotes       | `GIT_PAT` / `GIT_USER` + `GIT_PASSWORD` |
+
+These credentials can be stored in e.g. `.Renviron`, or can be set in your R session through other means as appropriate.
+
+If you require custom authentication for different packages (for example, your project makes use of packages available on different GitHub enterprise servers), you can use the `renv.auth` R option to provide package-specific authentication settings.
+`renv.auth` can either be a a named list associating package names with environment variables, or a function accepting a package name + record, and returning a list of environment variables.
+For example:
+
+```{r}
+# define a function providing authentication
+options(renv.auth = function(package, record) {
+  if (package == "MyPackage")
+    return(list(GITHUB_PAT = "<pat>"))
+})
+
+# use a named list directly
+options(renv.auth = list(
+  MyPackage = list(GITHUB_PAT = "<pat>")
+))
+
+# alternatively, set package-specific option
+# as a list
+options(renv.auth.MyPackage = list(GITHUB_PAT = "<pat>"))
+# as a function
+options(renv.auth.MyPackage = function(record) {
+   list(GITHUB_PAT = "<pat>")
+})
+```
+
+For packages installed from Git remotes, renv will attempt to use `git` from the command line to download and restore the associated package.
+Hence, it is recommended that authentication is done through SSH keys when possible.
+
+Authentication may be required when resolving a package from a remote specification.
+If the package name cannot be inferred directly from the remote, it can be supplied with a prefix of the form `<package>=`.
+For example, the igraph package on GitHub at <https://github.com/igraph/rigraph> could be installed with:
+
+```{r}
+renv::install("igraph=igraph/rigraph")
+```
+
+
+#### Azure DevOps
+
+Authentication with Azure DevOps may require credentials to be set in a slightly different way. In particular, you can use:
+
+```sh
+GITHUB_USER = <username>
+GITHUB_PASS = <password>
+```
+
+replacing `<username>` and `<password>` as appropriate -- for example, your password may just be a PAT. See https://github.com/rstudio/renv/issues/1751 for more details.
+
+
+#### Git and Personal Access Tokens
+
+Rather than username + password, some remote Git repositories might require Personal Access Tokens (PATs) for authentication. Typically, such servers expect authentication credentials where:
+
+- Your PAT is supplied as the username,
+- Either an empty response, or the string `x-oauth-basic`, is provided as the password.
+
+To help facilitate this, you can set:
+
+```sh
+GIT_USER = <pat>
+GIT_PASS = x-oauth-basic
+```
+
+in an appropriate startup R file.
+
+
+### Custom headers
+
+If you want to set arbitrary headers when downloading files using renv, you can do so using the `renv.download.headers` R option.
+It should be a function that accepts a URL, and returns a named character vector indicating the headers which should be supplied when accessing that URL.
+
+For example, suppose you have a package repository hosted at `https://my/repository`, and the credentials required to access that repository are stored in the `AUTH_HEADER` environment variable.
+You could define `renv.download.headers` like so:
+
+```{r}
+options(renv.download.headers = function(url) {
+  if (grepl("^https://my/repository", url))
+    return(c(Authorization = Sys.getenv("AUTH_HEADER")))
+})
+```
+
+With the above, renv will set the `Authorization` header whenever it attempts to download files from the repository at URL `https://my/repository`.
+
+### Debugging
+
+If having problems with downloads, you can get more debugging information (including raw requests and responses) by setting:
+
+```{r}
+options(renv.download.trace = TRUE) 
+```
+

renv/library/windows/R-4.5/x86_64-w64-mingw32/renv/doc/package-install.html

@@ -0,0 +1,782 @@
+<!DOCTYPE html>
+
+<html>
+
+<head>
+
+<meta charset="utf-8" />
+<meta name="generator" content="pandoc" />
+<meta http-equiv="X-UA-Compatible" content="IE=EDGE" />
+
+<meta name="viewport" content="width=device-width, initial-scale=1" />
+
+
+
+<title>Installing packages</title>
+
+<script>// Pandoc 2.9 adds attributes on both header and div. We remove the former (to
+// be compatible with the behavior of Pandoc < 2.8).
+document.addEventListener('DOMContentLoaded', function(e) {
+  var hs = document.querySelectorAll("div.section[class*='level'] > :first-child");
+  var i, h, a;
+  for (i = 0; i < hs.length; i++) {
+    h = hs[i];
+    if (!/^h[1-6]$/i.test(h.tagName)) continue;  // it should be a header h1-h6
+    a = h.attributes;
+    while (a.length > 0) h.removeAttribute(a[0].name);
+  }
+});
+</script>
+
+<style type="text/css">
+code{white-space: pre-wrap;}
+span.smallcaps{font-variant: small-caps;}
+span.underline{text-decoration: underline;}
+div.column{display: inline-block; vertical-align: top; width: 50%;}
+div.hanging-indent{margin-left: 1.5em; text-indent: -1.5em;}
+ul.task-list{list-style: none;}
+</style>
+
+
+
+<style type="text/css">
+code {
+white-space: pre;
+}
+.sourceCode {
+overflow: visible;
+}
+</style>
+<style type="text/css" data-origin="pandoc">
+html { -webkit-text-size-adjust: 100%; }
+pre > code.sourceCode { white-space: pre; position: relative; }
+pre > code.sourceCode > span { display: inline-block; line-height: 1.25; }
+pre > code.sourceCode > span:empty { height: 1.2em; }
+.sourceCode { overflow: visible; }
+code.sourceCode > span { color: inherit; text-decoration: inherit; }
+div.sourceCode { margin: 1em 0; }
+pre.sourceCode { margin: 0; }
+@media screen {
+div.sourceCode { overflow: auto; }
+}
+@media print {
+pre > code.sourceCode { white-space: pre-wrap; }
+pre > code.sourceCode > span { text-indent: -5em; padding-left: 5em; }
+}
+pre.numberSource code
+{ counter-reset: source-line 0; }
+pre.numberSource code > span
+{ position: relative; left: -4em; counter-increment: source-line; }
+pre.numberSource code > span > a:first-child::before
+{ content: counter(source-line);
+position: relative; left: -1em; text-align: right; vertical-align: baseline;
+border: none; display: inline-block;
+-webkit-touch-callout: none; -webkit-user-select: none;
+-khtml-user-select: none; -moz-user-select: none;
+-ms-user-select: none; user-select: none;
+padding: 0 4px; width: 4em;
+color: #aaaaaa;
+}
+pre.numberSource { margin-left: 3em; border-left: 1px solid #aaaaaa; padding-left: 4px; }
+div.sourceCode
+{ }
+@media screen {
+pre > code.sourceCode > span > a:first-child::before { text-decoration: underline; }
+}
+code span.al { color: #ff0000; font-weight: bold; } 
+code span.an { color: #60a0b0; font-weight: bold; font-style: italic; } 
+code span.at { color: #7d9029; } 
+code span.bn { color: #40a070; } 
+code span.bu { color: #008000; } 
+code span.cf { color: #007020; font-weight: bold; } 
+code span.ch { color: #4070a0; } 
+code span.cn { color: #880000; } 
+code span.co { color: #60a0b0; font-style: italic; } 
+code span.cv { color: #60a0b0; font-weight: bold; font-style: italic; } 
+code span.do { color: #ba2121; font-style: italic; } 
+code span.dt { color: #902000; } 
+code span.dv { color: #40a070; } 
+code span.er { color: #ff0000; font-weight: bold; } 
+code span.ex { } 
+code span.fl { color: #40a070; } 
+code span.fu { color: #06287e; } 
+code span.im { color: #008000; font-weight: bold; } 
+code span.in { color: #60a0b0; font-weight: bold; font-style: italic; } 
+code span.kw { color: #007020; font-weight: bold; } 
+code span.op { color: #666666; } 
+code span.ot { color: #007020; } 
+code span.pp { color: #bc7a00; } 
+code span.sc { color: #4070a0; } 
+code span.ss { color: #bb6688; } 
+code span.st { color: #4070a0; } 
+code span.va { color: #19177c; } 
+code span.vs { color: #4070a0; } 
+code span.wa { color: #60a0b0; font-weight: bold; font-style: italic; } 
+</style>
+<script>
+// apply pandoc div.sourceCode style to pre.sourceCode instead
+(function() {
+  var sheets = document.styleSheets;
+  for (var i = 0; i < sheets.length; i++) {
+    if (sheets[i].ownerNode.dataset["origin"] !== "pandoc") continue;
+    try { var rules = sheets[i].cssRules; } catch (e) { continue; }
+    var j = 0;
+    while (j < rules.length) {
+      var rule = rules[j];
+      // check if there is a div.sourceCode rule
+      if (rule.type !== rule.STYLE_RULE || rule.selectorText !== "div.sourceCode") {
+        j++;
+        continue;
+      }
+      var style = rule.style.cssText;
+      // check if color or background-color is set
+      if (rule.style.color === '' && rule.style.backgroundColor === '') {
+        j++;
+        continue;
+      }
+      // replace div.sourceCode by a pre.sourceCode rule
+      sheets[i].deleteRule(j);
+      sheets[i].insertRule('pre.sourceCode{' + style + '}', j);
+    }
+  }
+})();
+</script>
+
+
+
+
+<style type="text/css">body {
+background-color: #fff;
+margin: 1em auto;
+max-width: 700px;
+overflow: visible;
+padding-left: 2em;
+padding-right: 2em;
+font-family: "Open Sans", "Helvetica Neue", Helvetica, Arial, sans-serif;
+font-size: 14px;
+line-height: 1.35;
+}
+#TOC {
+clear: both;
+margin: 0 0 10px 10px;
+padding: 4px;
+width: 400px;
+border: 1px solid #CCCCCC;
+border-radius: 5px;
+background-color: #f6f6f6;
+font-size: 13px;
+line-height: 1.3;
+}
+#TOC .toctitle {
+font-weight: bold;
+font-size: 15px;
+margin-left: 5px;
+}
+#TOC ul {
+padding-left: 40px;
+margin-left: -1.5em;
+margin-top: 5px;
+margin-bottom: 5px;
+}
+#TOC ul ul {
+margin-left: -2em;
+}
+#TOC li {
+line-height: 16px;
+}
+table {
+margin: 1em auto;
+border-width: 1px;
+border-color: #DDDDDD;
+border-style: outset;
+border-collapse: collapse;
+}
+table th {
+border-width: 2px;
+padding: 5px;
+border-style: inset;
+}
+table td {
+border-width: 1px;
+border-style: inset;
+line-height: 18px;
+padding: 5px 5px;
+}
+table, table th, table td {
+border-left-style: none;
+border-right-style: none;
+}
+table thead, table tr.even {
+background-color: #f7f7f7;
+}
+p {
+margin: 0.5em 0;
+}
+blockquote {
+background-color: #f6f6f6;
+padding: 0.25em 0.75em;
+}
+hr {
+border-style: solid;
+border: none;
+border-top: 1px solid #777;
+margin: 28px 0;
+}
+dl {
+margin-left: 0;
+}
+dl dd {
+margin-bottom: 13px;
+margin-left: 13px;
+}
+dl dt {
+font-weight: bold;
+}
+ul {
+margin-top: 0;
+}
+ul li {
+list-style: circle outside;
+}
+ul ul {
+margin-bottom: 0;
+}
+pre, code {
+background-color: #f7f7f7;
+border-radius: 3px;
+color: #333;
+white-space: pre-wrap; 
+}
+pre {
+border-radius: 3px;
+margin: 5px 0px 10px 0px;
+padding: 10px;
+}
+pre:not([class]) {
+background-color: #f7f7f7;
+}
+code {
+font-family: Consolas, Monaco, 'Courier New', monospace;
+font-size: 85%;
+}
+p > code, li > code {
+padding: 2px 0px;
+}
+div.figure {
+text-align: center;
+}
+img {
+background-color: #FFFFFF;
+padding: 2px;
+border: 1px solid #DDDDDD;
+border-radius: 3px;
+border: 1px solid #CCCCCC;
+margin: 0 5px;
+}
+h1 {
+margin-top: 0;
+font-size: 35px;
+line-height: 40px;
+}
+h2 {
+border-bottom: 4px solid #f7f7f7;
+padding-top: 10px;
+padding-bottom: 2px;
+font-size: 145%;
+}
+h3 {
+border-bottom: 2px solid #f7f7f7;
+padding-top: 10px;
+font-size: 120%;
+}
+h4 {
+border-bottom: 1px solid #f7f7f7;
+margin-left: 8px;
+font-size: 105%;
+}
+h5, h6 {
+border-bottom: 1px solid #ccc;
+font-size: 105%;
+}
+a {
+color: #0033dd;
+text-decoration: none;
+}
+a:hover {
+color: #6666ff; }
+a:visited {
+color: #800080; }
+a:visited:hover {
+color: #BB00BB; }
+a[href^="http:"] {
+text-decoration: underline; }
+a[href^="https:"] {
+text-decoration: underline; }
+
+code > span.kw { color: #555; font-weight: bold; } 
+code > span.dt { color: #902000; } 
+code > span.dv { color: #40a070; } 
+code > span.bn { color: #d14; } 
+code > span.fl { color: #d14; } 
+code > span.ch { color: #d14; } 
+code > span.st { color: #d14; } 
+code > span.co { color: #888888; font-style: italic; } 
+code > span.ot { color: #007020; } 
+code > span.al { color: #ff0000; font-weight: bold; } 
+code > span.fu { color: #900; font-weight: bold; } 
+code > span.er { color: #a61717; background-color: #e3d2d2; } 
+</style>
+
+
+
+
+</head>
+
+<body>
+
+
+
+
+<h1 class="title toc-ignore">Installing packages</h1>
+
+
+
+<p>Package installation is an important part of renv. This vignette
+gives you the details, starting with an overview of renv’s cache, before
+going into various installation challenges around building from source
+and downloading with proxies or authentication.</p>
+<div id="cache" class="section level2">
+<h2>Cache</h2>
+<p>One of renv’s primary features is the global package cache, which
+shared across all projects. The renv package cache provides two primary
+benefits:</p>
+<ol style="list-style-type: decimal">
+<li><p>Installing and restoring packages is much faster, as renv can
+find and re-use previously installed packages from the cache.</p></li>
+<li><p>Projects take up less disk space, because each project doesn’t
+need to contain it’s own copy of every package.</p></li>
+</ol>
+<p>When installing a package, renv installs into the global cache and
+then adds a symlink<a href="#fn1" class="footnote-ref" id="fnref1"><sup>1</sup></a> to that directory in the project library.
+That way each renv project remains isolated from other projects on your
+system, but they can still re-use the same installed packages.</p>
+<p>The process by which packages enter the cache is roughly as
+follows:</p>
+<ol style="list-style-type: decimal">
+<li><p>Package installation is requested via
+e.g. <code>install.packages()</code>, or <code>renv::install()</code>,
+or as part of <code>renv::restore()</code>.</p></li>
+<li><p>If renv is able to find the requested version of the package in
+the cache, then that package is linked into the project library, and
+installation is complete.</p></li>
+<li><p>Otherwise, the package is downloaded and installed into the
+project library.</p></li>
+<li><p>After installation of the package has successfully completed, the
+package is then copied into the global package cache, and then symlinked
+into the project library.</p></li>
+</ol>
+<p>In some cases, renv will be unable to directly link from the global
+package cache to your project library, e.g. if the package cache and
+your project library live on different disk volumes. In such a case,
+renv will instead copy the package from the cache into the project
+library. This is much slower, so is worth avoiding.</p>
+<div id="cache-location" class="section level3">
+<h3>Cache location</h3>
+<p>You can find the location of the current cache with
+<code>renv::paths$cache()</code>. By default, it will be in one of the
+following folders:</p>
+<ul>
+<li>Linux: <code>~/.cache/R/renv/cache</code></li>
+<li>macOS:
+<code>~/Library/Caches/org.R-project.R/R/renv/cache</code></li>
+<li>Windows: <code>%LOCALAPPDATA%/renv/cache</code></li>
+</ul>
+<p>If you’d like to share the package cache across multiple users, you
+can do so by setting the <code>RENV_PATHS_CACHE</code> environment
+variable to a shared path. This variable should be set in an R startup
+file to make it apply to all R sessions. While you can set it in a
+project-local <code>.Renviron</code>, or the user-level
+<code>~/.Renviron</code>, we generally recommend using the R
+installation’s site-wide <code>Renviron.site</code> if you’d like to
+ensure the same cache path is visible to all users of R on a system.</p>
+<p>You may also want to set <code>RENV_PATHS_CACHE</code> so that the
+global package cache can be stored on the same volume as the projects
+you normally work on. This is especially important when working projects
+stored on a networked filesystem.</p>
+</div>
+<div id="multiple-caches" class="section level3">
+<h3>Multiple caches</h3>
+<p>It is also possible to configure renv to use multiple cache
+locations. For example, you might want to make both a user-local package
+cache, as well as a global administrator-managed cache, visible within
+an renv project. To do so, you can specify the paths to the cache
+separated with a <code>;</code> (or <code>:</code> on Unix if
+preferred). For example:</p>
+<div class="sourceCode" id="cb1"><pre class="sourceCode sh"><code class="sourceCode bash"><span id="cb1-1"><a href="#cb1-1" tabindex="-1"></a><span class="va">RENV_PATHS_CACHE</span><span class="op">=</span>/path/to/local/cache<span class="kw">;</span><span class="ex">/path/to/global/cache</span></span></code></pre></div>
+<p>In such a case, renv will iterate over the cache locations in order
+when trying to find a package, and newly-installed packages will enter
+the first writable cache path listed in
+<code>RENV_PATHS_CACHE</code>.</p>
+</div>
+<div id="shared-cache-locations" class="section level3">
+<h3>Shared cache locations</h3>
+<p>When the renv cache is enabled, if that cache is shared and visible
+to multiple users, then each of those users will have an opportunity to
+install packages into the renv cache. However, some care must be taken
+to ensure that these packages can be used by different users in your
+environment:</p>
+<ol style="list-style-type: decimal">
+<li><p>Packages copied into the cache may have <a href="https://en.wikipedia.org/wiki/Access-control_list">Access-control
+Lists</a> (ACLs), which might prevent others from using packages that
+have been installed into the cache. If this is the case, it’s important
+that ACLs be set (or updated) on cache entries so that the cache is
+accessible to each user requiring access. When deploying renv in an
+enterprise environment, the system administrator should take care to
+ensure ACLs (if any) allow users access to packages within the renv
+cache.</p></li>
+<li><p>By default, packages copied into the cache will remain “owned” by
+the user that requested installation of that package. If you’d like renv
+to instead re-assign ownership of the cached package to a separate user
+account, you can set the <code>RENV_CACHE_USER</code> environment
+variable. When set, renv will attempt to run
+<code>chown -R &lt;package&gt; &lt;user&gt;</code> to update cache
+ownership after the package has been copied into the cache.</p></li>
+</ol>
+</div>
+<div id="caveats" class="section level3">
+<h3>Caveats</h3>
+<p>While we recommend enabling the cache by default, if you’re having
+trouble with it, you can disable it by setting the project setting
+<code>renv::settings$use.cache(FALSE)</code>. Doing this will ensure
+that packages are then installed into your project library directly,
+without attempting to link and use packages from the renv cache.</p>
+<p>If you find a problematic package has entered the cache (for example,
+an installed package has become corrupted), that package can be removed
+with the <code>renv::purge()</code> function. See the
+<code>?purge</code> documentation for caveats and things to be aware of
+when removing packages from the cache.</p>
+<p>You can also force a package to be re-installed and re-cached with
+the following functions:</p>
+<div class="sourceCode" id="cb2"><pre class="sourceCode r"><code class="sourceCode r"><span id="cb2-1"><a href="#cb2-1" tabindex="-1"></a><span class="co"># restore packages from the lockfile, bypassing the cache</span></span>
+<span id="cb2-2"><a href="#cb2-2" tabindex="-1"></a>renv<span class="sc">::</span><span class="fu">restore</span>(<span class="at">rebuild =</span> <span class="cn">TRUE</span>)</span>
+<span id="cb2-3"><a href="#cb2-3" tabindex="-1"></a></span>
+<span id="cb2-4"><a href="#cb2-4" tabindex="-1"></a><span class="co"># re-install a package</span></span>
+<span id="cb2-5"><a href="#cb2-5" tabindex="-1"></a>renv<span class="sc">::</span><span class="fu">install</span>(<span class="st">&quot;&lt;package&gt;&quot;</span>, <span class="at">rebuild =</span> <span class="cn">TRUE</span>)</span>
+<span id="cb2-6"><a href="#cb2-6" tabindex="-1"></a></span>
+<span id="cb2-7"><a href="#cb2-7" tabindex="-1"></a><span class="co"># rebuild all packages in the project</span></span>
+<span id="cb2-8"><a href="#cb2-8" tabindex="-1"></a>renv<span class="sc">::</span><span class="fu">rebuild</span>()</span></code></pre></div>
+<p>See each function’s respective documentation for more details.</p>
+</div>
+</div>
+<div id="building-from-source" class="section level2">
+<h2>Building from source</h2>
+<p>Where possible, renv will install package binaries, but sometimes a
+binary is not available and you have to build from source. Installation
+from source can be challenging for a few reasons:</p>
+<ol style="list-style-type: decimal">
+<li><p>Your system will need to have a compatible compiler toolchain
+available. In some cases, R packages may depend on C / C++ features that
+aren’t available in an older system toolchain, especially in some older
+Linux enterprise environments.</p></li>
+<li><p>Your system will need requisite system libraries, as many R
+packages contain compiled C / C++ code that depend on and link to these
+packages.</p></li>
+</ol>
+<!-- TODO: renv::equip() for Linux + macOS; use sysreqsdb -->
+<div id="configure-flags" class="section level3">
+<h3>Configure flags</h3>
+<p>Many <code>R</code> packages have a <code>configure</code> script
+that needs to be run to prepare the package for installation. Arguments
+and environment variables can be passed through to those scripts in a
+manner similar to <code>install.packages()</code>. In particular, the
+<code>R</code> options <code>configure.args</code> and
+<code>configure.vars</code> can be used to map package names to their
+appropriate configuration. For example:</p>
+<div class="sourceCode" id="cb3"><pre class="sourceCode r"><code class="sourceCode r"><span id="cb3-1"><a href="#cb3-1" tabindex="-1"></a><span class="co"># installation of RNetCDF may require us to set include paths for netcdf</span></span>
+<span id="cb3-2"><a href="#cb3-2" tabindex="-1"></a>configure.args <span class="ot">=</span> <span class="fu">c</span>(<span class="at">RNetCDF =</span> <span class="st">&quot;--with-netcdf-include=/usr/include/udunits2&quot;</span>)</span>
+<span id="cb3-3"><a href="#cb3-3" tabindex="-1"></a><span class="fu">options</span>(<span class="at">configure.args =</span> configure.args)</span>
+<span id="cb3-4"><a href="#cb3-4" tabindex="-1"></a>renv<span class="sc">::</span><span class="fu">install</span>(<span class="st">&quot;RNetCDF&quot;</span>)</span></code></pre></div>
+<p>This could also be specified as, for example,</p>
+<div class="sourceCode" id="cb4"><pre class="sourceCode r"><code class="sourceCode r"><span id="cb4-1"><a href="#cb4-1" tabindex="-1"></a><span class="fu">options</span>(</span>
+<span id="cb4-2"><a href="#cb4-2" tabindex="-1"></a>  <span class="at">configure.args.RNetCDF =</span> <span class="st">&quot;--with-netcdf-include=/usr/include/udunits2&quot;</span></span>
+<span id="cb4-3"><a href="#cb4-3" tabindex="-1"></a>)</span>
+<span id="cb4-4"><a href="#cb4-4" tabindex="-1"></a>renv<span class="sc">::</span><span class="fu">install</span>(<span class="st">&quot;RNetCDF&quot;</span>)</span></code></pre></div>
+</div>
+<div id="install-flags" class="section level3">
+<h3>Install flags</h3>
+<p>Similarly, additional flags that should be passed to
+<code>R CMD INSTALL</code> can be set via the <code>install.opts</code>
+<code>R</code> option:</p>
+<div class="sourceCode" id="cb5"><pre class="sourceCode r"><code class="sourceCode r"><span id="cb5-1"><a href="#cb5-1" tabindex="-1"></a><span class="co"># installation of R packages using the Windows Subsystem for Linux</span></span>
+<span id="cb5-2"><a href="#cb5-2" tabindex="-1"></a><span class="co"># may require the `--no-lock` flag to be set during install</span></span>
+<span id="cb5-3"><a href="#cb5-3" tabindex="-1"></a><span class="fu">options</span>(<span class="at">install.opts =</span> <span class="st">&quot;--no-lock&quot;</span>)</span>
+<span id="cb5-4"><a href="#cb5-4" tabindex="-1"></a>renv<span class="sc">::</span><span class="fu">install</span>(<span class="st">&quot;xml2&quot;</span>)</span>
+<span id="cb5-5"><a href="#cb5-5" tabindex="-1"></a></span>
+<span id="cb5-6"><a href="#cb5-6" tabindex="-1"></a><span class="co"># alternatively, you can set such options for specific packages with e.g.</span></span>
+<span id="cb5-7"><a href="#cb5-7" tabindex="-1"></a><span class="fu">options</span>(<span class="at">install.opts =</span> <span class="fu">list</span>(<span class="at">xml2 =</span> <span class="st">&quot;--no-lock&quot;</span>))</span>
+<span id="cb5-8"><a href="#cb5-8" tabindex="-1"></a>renv<span class="sc">::</span><span class="fu">install</span>(<span class="st">&quot;xml2&quot;</span>)</span></code></pre></div>
+</div>
+<div id="vignettes" class="section level3">
+<h3>Vignettes</h3>
+<p>renv does not build vignettes when installing a package from source.
+This is because vignettes often require suggested packages, and
+installing all suggested packages (particularly from source) can be
+arduous.</p>
+<p>If you want to distribute vignettes for your own packages, we suggest
+creating your own repository of binaries, either with <a href="https://r-universe.dev/">R Universe</a> (for publicly hosted
+packages on GitHub), with <a href="https://posit.co/products/enterprise/package-manager/">Posit
+Package Manager</a>, or with <a href="https://eddelbuettel.github.io/drat/">drat</a>.</p>
+</div>
+</div>
+<div id="downloads" class="section level2">
+<h2>Downloads</h2>
+<p>By default, renv uses <a href="https://curl.se/">curl</a> for file
+downloads when available. This allows renv to support a number of
+download features across multiple versions of R, including:</p>
+<ul>
+<li>Custom headers (used especially for authentication),</li>
+<li>Connection timeouts,</li>
+<li>Download retries on transient errors.</li>
+</ul>
+<p>If <code>curl</code> is not available on your machine, it is highly
+recommended that you install it. Newer versions of Windows 10 come with
+a bundled version of <code>curl.exe</code>; other users on Windows can
+use <code>renv::equip()</code> to download and install a recent copy of
+<code>curl</code>. Newer versions of macOS come with a bundled version
+of <code>curl</code> that is adequate for usage with renv, and most
+Linux package managers have a modern version of <code>curl</code>
+available in their package repositories. You can also configure which
+<code>curl</code> executable is used by setting the
+<code>RENV_CURL_EXECUTABLE</code> environment variable, if
+necessary.</p>
+<p><code>curl</code> downloads can be configured through renv’s
+configuration settings – see <code>?renv::config</code> for more
+details.</p>
+<div id="alternative-downloaders" class="section level3">
+<h3>Alternative downloaders</h3>
+<p>If you’ve already configured R’s downloader and would like to bypass
+renv’s attempts to use <code>curl</code>, you can use the R option
+<code>renv.download.override</code>. For example, executing:</p>
+<div class="sourceCode" id="cb6"><pre class="sourceCode r"><code class="sourceCode r"><span id="cb6-1"><a href="#cb6-1" tabindex="-1"></a><span class="fu">options</span>(<span class="at">renv.download.override =</span> utils<span class="sc">::</span>download.file)</span></code></pre></div>
+<p>would instruct renv to use R’s own download machinery when attempting
+to download files from the internet (respecting the R options
+<code>download.file.method</code> and <code>download.file.extra</code>
+as appropriate). Advanced users can also provide their own download
+function, provided its signature matches that of
+<code>utils::download.file()</code>.</p>
+<p>You can also instruct renv to use a different download method by
+setting the <code>RENV_DOWNLOAD_METHOD</code> environment variable. For
+example:</p>
+<div class="sourceCode" id="cb7"><pre class="sourceCode r"><code class="sourceCode r"><span id="cb7-1"><a href="#cb7-1" tabindex="-1"></a><span class="co"># use Windows&#39; internal download machinery</span></span>
+<span id="cb7-2"><a href="#cb7-2" tabindex="-1"></a><span class="fu">Sys.setenv</span>(<span class="at">RENV_DOWNLOAD_METHOD =</span> <span class="st">&quot;wininet&quot;</span>)</span>
+<span id="cb7-3"><a href="#cb7-3" tabindex="-1"></a></span>
+<span id="cb7-4"><a href="#cb7-4" tabindex="-1"></a><span class="co"># use R&#39;s bundled libcurl implementation</span></span>
+<span id="cb7-5"><a href="#cb7-5" tabindex="-1"></a><span class="fu">Sys.setenv</span>(<span class="at">RENV_DOWNLOAD_METHOD =</span> <span class="st">&quot;libcurl&quot;</span>)</span></code></pre></div>
+<p>If you find that downloads work outside of renv projects, but not
+within renv projects, you may need to tell renv to use the same download
+file method that R has been configured to use. You can check which
+download method R is currently configured to use with:</p>
+<div class="sourceCode" id="cb8"><pre class="sourceCode r"><code class="sourceCode r"><span id="cb8-1"><a href="#cb8-1" tabindex="-1"></a><span class="fu">getOption</span>(<span class="st">&quot;download.file.method&quot;</span>)</span></code></pre></div>
+<p>And the downloader currently used by renv can be queried with:</p>
+<div class="sourceCode" id="cb9"><pre class="sourceCode r"><code class="sourceCode r"><span id="cb9-1"><a href="#cb9-1" tabindex="-1"></a>renv<span class="sc">:::</span><span class="fu">renv_download_method</span>()</span></code></pre></div>
+<p>You can force renv to use the same download method as R by
+setting:</p>
+<div class="sourceCode" id="cb10"><pre class="sourceCode r"><code class="sourceCode r"><span id="cb10-1"><a href="#cb10-1" tabindex="-1"></a><span class="fu">Sys.setenv</span>(<span class="at">RENV_DOWNLOAD_METHOD =</span> <span class="fu">getOption</span>(<span class="st">&quot;download.file.method&quot;</span>))</span></code></pre></div>
+<p>and, if necessary, you could also set this environment variable
+within e.g. your <code>~/.Renviron</code>, so that it is visible to all
+R sessions. See <code>?Startup</code> for more details.</p>
+<p>Note that other features (e.g. authentication) may not be supported
+when using an alternative download file method – you will have to
+configure the downloader yourself if that is required. See
+<code>?download.file</code> for more details.</p>
+</div>
+<div id="proxies" class="section level3">
+<h3>Proxies</h3>
+<p>If your downloads need to go through a proxy server, then there are a
+variety of approaches you can take to make this work:</p>
+<ol style="list-style-type: decimal">
+<li><p>Set the <code>http_proxy</code> and / or <code>https_proxy</code>
+environment variables. These environment variables can contain the full
+URL to your proxy server, including a username + password if
+necessary.</p></li>
+<li><p>You can use a <code>.curlrc</code> (<code>_curlrc</code> on
+Windows) to provide information about the proxy server to be used. This
+file should be placed in your home folder (see
+<code>Sys.getenv(&quot;HOME&quot;)</code>, or <code>Sys.getenv(&quot;R_USER&quot;)</code> on
+Windows); alternatively, you can set the <code>CURL_HOME</code>
+environment variable to point to a custom ‘home’ folder to be used by
+<code>curl</code> when resolving the runtime configuration file. On
+Windows, you can also place your <code>_curlrc</code> in the same
+directory where the <code>curl.exe</code> binary is located.</p></li>
+</ol>
+<p>See the curl documentation on <a href="https://ec.haxx.se/usingcurl/proxies/">proxies</a> and <a href="https://ec.haxx.se/cmdline/configfile.html">config files</a> for
+more details.</p>
+<p>As an <a href="https://github.com/rstudio/renv/issues/146">example</a>, the
+following <code>_curlrc</code> works when using authentication with NTLM
+and SSPI on Windows:</p>
+<div class="sourceCode" id="cb11"><pre class="sourceCode sh"><code class="sourceCode bash"><span id="cb11-1"><a href="#cb11-1" tabindex="-1"></a><span class="ex">--proxy</span> <span class="st">&quot;your.proxy.dns:port&quot;</span></span>
+<span id="cb11-2"><a href="#cb11-2" tabindex="-1"></a><span class="ex">--proxy-ntlm</span></span>
+<span id="cb11-3"><a href="#cb11-3" tabindex="-1"></a><span class="ex">--proxy-user</span> <span class="st">&quot;:&quot;</span></span>
+<span id="cb11-4"><a href="#cb11-4" tabindex="-1"></a><span class="ex">--insecure</span></span></code></pre></div>
+<p>The <a href="https://cran.r-project.org/package=curl">curl</a> R
+package also has a helper:</p>
+<div class="sourceCode" id="cb12"><pre class="sourceCode r"><code class="sourceCode r"><span id="cb12-1"><a href="#cb12-1" tabindex="-1"></a>curl<span class="sc">::</span><span class="fu">ie_get_proxy_for_url</span>()</span></code></pre></div>
+<p>which may be useful when attempting to discover this proxy
+address.</p>
+</div>
+<div id="authentication" class="section level3">
+<h3>Authentication</h3>
+<p>Your project may make use of packages which are available from remote
+sources requiring some form of authentication to access – for example, a
+GitHub enterprise server. Usually, either a personal access token (PAT)
+or username + password combination is required for authentication. renv
+is able to authenticate when downloading from such sources, using the
+same system as the <a href="https://cran.r-project.org/package=remotes">remotes</a> package.
+In particular, environment variables are used to record and transfer the
+required authentication information.</p>
+<table>
+<thead>
+<tr class="header">
+<th><strong>Remote Source</strong></th>
+<th><strong>Authentication</strong></th>
+</tr>
+</thead>
+<tbody>
+<tr class="odd">
+<td>GitHub</td>
+<td><code>GITHUB_PAT</code></td>
+</tr>
+<tr class="even">
+<td>GitLab</td>
+<td><code>GITLAB_PAT</code></td>
+</tr>
+<tr class="odd">
+<td>Bitbucket</td>
+<td><code>BITBUCKET_USER</code> + <code>BITBUCKET_PASSWORD</code></td>
+</tr>
+<tr class="even">
+<td>Git Remotes</td>
+<td><code>GIT_PAT</code> / <code>GIT_USER</code> +
+<code>GIT_PASSWORD</code></td>
+</tr>
+</tbody>
+</table>
+<p>These credentials can be stored in e.g. <code>.Renviron</code>, or
+can be set in your R session through other means as appropriate.</p>
+<p>If you require custom authentication for different packages (for
+example, your project makes use of packages available on different
+GitHub enterprise servers), you can use the <code>renv.auth</code> R
+option to provide package-specific authentication settings.
+<code>renv.auth</code> can either be a a named list associating package
+names with environment variables, or a function accepting a package name
++ record, and returning a list of environment variables. For
+example:</p>
+<div class="sourceCode" id="cb13"><pre class="sourceCode r"><code class="sourceCode r"><span id="cb13-1"><a href="#cb13-1" tabindex="-1"></a><span class="co"># define a function providing authentication</span></span>
+<span id="cb13-2"><a href="#cb13-2" tabindex="-1"></a><span class="fu">options</span>(<span class="at">renv.auth =</span> <span class="cf">function</span>(package, record) {</span>
+<span id="cb13-3"><a href="#cb13-3" tabindex="-1"></a>  <span class="cf">if</span> (package <span class="sc">==</span> <span class="st">&quot;MyPackage&quot;</span>)</span>
+<span id="cb13-4"><a href="#cb13-4" tabindex="-1"></a>    <span class="fu">return</span>(<span class="fu">list</span>(<span class="at">GITHUB_PAT =</span> <span class="st">&quot;&lt;pat&gt;&quot;</span>))</span>
+<span id="cb13-5"><a href="#cb13-5" tabindex="-1"></a>})</span>
+<span id="cb13-6"><a href="#cb13-6" tabindex="-1"></a></span>
+<span id="cb13-7"><a href="#cb13-7" tabindex="-1"></a><span class="co"># use a named list directly</span></span>
+<span id="cb13-8"><a href="#cb13-8" tabindex="-1"></a><span class="fu">options</span>(<span class="at">renv.auth =</span> <span class="fu">list</span>(</span>
+<span id="cb13-9"><a href="#cb13-9" tabindex="-1"></a>  <span class="at">MyPackage =</span> <span class="fu">list</span>(<span class="at">GITHUB_PAT =</span> <span class="st">&quot;&lt;pat&gt;&quot;</span>)</span>
+<span id="cb13-10"><a href="#cb13-10" tabindex="-1"></a>))</span>
+<span id="cb13-11"><a href="#cb13-11" tabindex="-1"></a></span>
+<span id="cb13-12"><a href="#cb13-12" tabindex="-1"></a><span class="co"># alternatively, set package-specific option</span></span>
+<span id="cb13-13"><a href="#cb13-13" tabindex="-1"></a><span class="co"># as a list</span></span>
+<span id="cb13-14"><a href="#cb13-14" tabindex="-1"></a><span class="fu">options</span>(<span class="at">renv.auth.MyPackage =</span> <span class="fu">list</span>(<span class="at">GITHUB_PAT =</span> <span class="st">&quot;&lt;pat&gt;&quot;</span>))</span>
+<span id="cb13-15"><a href="#cb13-15" tabindex="-1"></a><span class="co"># as a function</span></span>
+<span id="cb13-16"><a href="#cb13-16" tabindex="-1"></a><span class="fu">options</span>(<span class="at">renv.auth.MyPackage =</span> <span class="cf">function</span>(record) {</span>
+<span id="cb13-17"><a href="#cb13-17" tabindex="-1"></a>   <span class="fu">list</span>(<span class="at">GITHUB_PAT =</span> <span class="st">&quot;&lt;pat&gt;&quot;</span>)</span>
+<span id="cb13-18"><a href="#cb13-18" tabindex="-1"></a>})</span></code></pre></div>
+<p>For packages installed from Git remotes, renv will attempt to use
+<code>git</code> from the command line to download and restore the
+associated package. Hence, it is recommended that authentication is done
+through SSH keys when possible.</p>
+<p>Authentication may be required when resolving a package from a remote
+specification. If the package name cannot be inferred directly from the
+remote, it can be supplied with a prefix of the form
+<code>&lt;package&gt;=</code>. For example, the igraph package on GitHub
+at <a href="https://github.com/igraph/rigraph" class="uri">https://github.com/igraph/rigraph</a> could be installed
+with:</p>
+<div class="sourceCode" id="cb14"><pre class="sourceCode r"><code class="sourceCode r"><span id="cb14-1"><a href="#cb14-1" tabindex="-1"></a>renv<span class="sc">::</span><span class="fu">install</span>(<span class="st">&quot;igraph=igraph/rigraph&quot;</span>)</span></code></pre></div>
+<div id="azure-devops" class="section level4">
+<h4>Azure DevOps</h4>
+<p>Authentication with Azure DevOps may require credentials to be set in
+a slightly different way. In particular, you can use:</p>
+<div class="sourceCode" id="cb15"><pre class="sourceCode sh"><code class="sourceCode bash"><span id="cb15-1"><a href="#cb15-1" tabindex="-1"></a><span class="ex">GITHUB_USER</span> = <span class="op">&lt;</span>username<span class="op">&gt;</span></span>
+<span id="cb15-2"><a href="#cb15-2" tabindex="-1"></a><span class="ex">GITHUB_PASS</span> = <span class="op">&lt;</span>password<span class="op">&gt;</span></span></code></pre></div>
+<p>replacing <code>&lt;username&gt;</code> and
+<code>&lt;password&gt;</code> as appropriate – for example, your
+password may just be a PAT. See <a href="https://github.com/rstudio/renv/issues/1751" class="uri">https://github.com/rstudio/renv/issues/1751</a> for more
+details.</p>
+</div>
+<div id="git-and-personal-access-tokens" class="section level4">
+<h4>Git and Personal Access Tokens</h4>
+<p>Rather than username + password, some remote Git repositories might
+require Personal Access Tokens (PATs) for authentication. Typically,
+such servers expect authentication credentials where:</p>
+<ul>
+<li>Your PAT is supplied as the username,</li>
+<li>Either an empty response, or the string <code>x-oauth-basic</code>,
+is provided as the password.</li>
+</ul>
+<p>To help facilitate this, you can set:</p>
+<div class="sourceCode" id="cb16"><pre class="sourceCode sh"><code class="sourceCode bash"><span id="cb16-1"><a href="#cb16-1" tabindex="-1"></a><span class="ex">GIT_USER</span> = <span class="op">&lt;</span>pat<span class="op">&gt;</span></span>
+<span id="cb16-2"><a href="#cb16-2" tabindex="-1"></a><span class="ex">GIT_PASS</span> = x-oauth-basic</span></code></pre></div>
+<p>in an appropriate startup R file.</p>
+</div>
+</div>
+<div id="custom-headers" class="section level3">
+<h3>Custom headers</h3>
+<p>If you want to set arbitrary headers when downloading files using
+renv, you can do so using the <code>renv.download.headers</code> R
+option. It should be a function that accepts a URL, and returns a named
+character vector indicating the headers which should be supplied when
+accessing that URL.</p>
+<p>For example, suppose you have a package repository hosted at
+<code>https://my/repository</code>, and the credentials required to
+access that repository are stored in the <code>AUTH_HEADER</code>
+environment variable. You could define
+<code>renv.download.headers</code> like so:</p>
+<div class="sourceCode" id="cb17"><pre class="sourceCode r"><code class="sourceCode r"><span id="cb17-1"><a href="#cb17-1" tabindex="-1"></a><span class="fu">options</span>(<span class="at">renv.download.headers =</span> <span class="cf">function</span>(url) {</span>
+<span id="cb17-2"><a href="#cb17-2" tabindex="-1"></a>  <span class="cf">if</span> (<span class="fu">grepl</span>(<span class="st">&quot;^https://my/repository&quot;</span>, url))</span>
+<span id="cb17-3"><a href="#cb17-3" tabindex="-1"></a>    <span class="fu">return</span>(<span class="fu">c</span>(<span class="at">Authorization =</span> <span class="fu">Sys.getenv</span>(<span class="st">&quot;AUTH_HEADER&quot;</span>)))</span>
+<span id="cb17-4"><a href="#cb17-4" tabindex="-1"></a>})</span></code></pre></div>
+<p>With the above, renv will set the <code>Authorization</code> header
+whenever it attempts to download files from the repository at URL
+<code>https://my/repository</code>.</p>
+</div>
+<div id="debugging" class="section level3">
+<h3>Debugging</h3>
+<p>If having problems with downloads, you can get more debugging
+information (including raw requests and responses) by setting:</p>
+<div class="sourceCode" id="cb18"><pre class="sourceCode r"><code class="sourceCode r"><span id="cb18-1"><a href="#cb18-1" tabindex="-1"></a><span class="fu">options</span>(<span class="at">renv.download.trace =</span> <span class="cn">TRUE</span>) </span></code></pre></div>
+</div>
+</div>
+<div class="footnotes footnotes-end-of-document">
+<hr />
+<ol>
+<li id="fn1"><p>Or junction points, on Windows. Junction points are
+unfortunately not supported on Windows network shares; see <a href="https://learn.microsoft.com/en-us/windows/win32/fileio/hard-links-and-junctions">Hard
+links and junctions</a> for more details.<a href="#fnref1" class="footnote-back">↩︎</a></p></li>
+</ol>
+</div>
+
+
+
+<!-- code folding -->
+
+
+<!-- dynamically load mathjax for compatibility with self-contained -->
+<script>
+  (function () {
+    var script = document.createElement("script");
+    script.type = "text/javascript";
+    script.src  = "https://mathjax.rstudio.com/latest/MathJax.js?config=TeX-AMS-MML_HTMLorMML";
+    document.getElementsByTagName("head")[0].appendChild(script);
+  })();
+</script>
+
+</body>
+</html>

renv/library/windows/R-4.5/x86_64-w64-mingw32/renv/doc/package-sources.R

@@ -0,0 +1,34 @@
+## ----include=FALSE------------------------------------------------------------
+knitr::opts_chunk$set(
+  collapse = TRUE,
+  comment = "#>",
+  eval = FALSE
+)
+
+## ----setup--------------------------------------------------------------------
+# library(renv)
+
+## -----------------------------------------------------------------------------
+# repos <- c(CRAN = "https://cloud.r-project.org", WORK = "https://work.example.org")
+# options(repos = repos)
+
+## -----------------------------------------------------------------------------
+# # use the latest-available Bioconductor release
+# renv::init(bioconductor = TRUE)
+# 
+# # use a specific version of Bioconductor
+# renv::init(bioconductor = "3.14")
+
+## -----------------------------------------------------------------------------
+# renv::settings$bioconductor.version("3.14")
+
+## -----------------------------------------------------------------------------
+# options(renv.bioconductor.repos = c(...))
+
+## -----------------------------------------------------------------------------
+# renv:::renv_paths_cellar()
+
+## -----------------------------------------------------------------------------
+# # please don't do this!
+# `%>%` <- magrittr::`%>%`
+

renv/library/windows/R-4.5/x86_64-w64-mingw32/renv/doc/package-sources.Rmd

@@ -0,0 +1,260 @@
+---
+title: "Package sources"
+output: rmarkdown::html_vignette
+vignette: >
+  %\VignetteIndexEntry{Package sources}
+  %\VignetteEngine{knitr::rmarkdown}
+  %\VignetteEncoding{UTF-8}
+---
+
+```{r, include=FALSE}
+knitr::opts_chunk$set(
+  collapse = TRUE,
+  comment = "#>",
+  eval = FALSE
+)
+```
+
+```{r setup}
+library(renv)
+```
+
+
+# Package sources
+
+renv uses an installed package's `DESCRIPTION` file to infer its source. For
+example, packages installed from the CRAN repositories typically have the field:
+
+```sh
+Repository: CRAN
+```
+
+set, and renv takes this as a signal that the package was retrieved from CRAN.
+
+## Inferring package sources
+
+The following fields are checked, in order, when inferring a package's source:
+
+1. The `RemoteType` field; typically written for packages installed by the
+  devtools, remotes and pak packages,
+
+1. The `Repository` field; for example, packages retrieved from CRAN will
+   typically have the `Repository: CRAN` field,
+   
+1. The `biocViews` field; typically present for packages installed from the
+   Bioconductor repositories,
+
+As a fallback, if renv is unable to determine a package's source from the
+`DESCRIPTION` file directly, but a package of the same name is available in the
+active R repositories (as specified in `getOption("repos")`), then the package
+will be treated as though it was installed from an R package repository.
+
+If all of the above methods fail, renv will finally check for a package
+available from the _cellar_. The package cellar is typically used as an escape
+hatch, for packages which do not have a well-defined remote source, or for
+packages which might not be remotely accessible from your machine.
+
+
+## Unknown sources
+
+If renv is unable to infer a package's source, it will inform you during
+`renv::snapshot()` -- for example, if we attempted to snapshot a package
+called `skeleton` with no known source:
+
+```r
+> renv::snapshot()
+The following package(s) were installed from an unknown source:
+
+        skeleton
+
+renv may be unable to restore these packages in the future.
+Consider reinstalling these packages from a known source (e.g. CRAN).
+
+Do you want to proceed? [y/N]:
+```
+
+While you can still create a lockfile with such packages, `restore()` will
+likely fail unless you can ensure this package is installed through some
+other mechanism.
+
+
+## Custom R package repositories
+
+Custom and local R package repositories are supported as well. The only
+requirement is that these repositories are set as part of the `repos` R
+option, and that these repositories are named. For example, you might use:
+
+```{r}
+repos <- c(CRAN = "https://cloud.r-project.org", WORK = "https://work.example.org")
+options(repos = repos)
+```
+
+to tell renv to work with both the official CRAN package repository, as well
+as a package repository you have hosted and set up in your work environment.
+
+## Bioconductor
+
+
+renv has been designed to work together as seamlessly as possible with
+the [Bioconductor](https://bioconductor.org/) project. This vignette outlines
+some of the extra steps that may be required when using renv with packages
+obtained from Bioconductor.
+
+
+## Initializing a project
+
+To initialize renv in a project using Bioconductor, you can pass the
+`bioconductor` argument to `renv::init()`:
+
+```{r}
+# use the latest-available Bioconductor release
+renv::init(bioconductor = TRUE)
+
+# use a specific version of Bioconductor
+renv::init(bioconductor = "3.14")
+```
+
+This will tell renv to activate the appropriate Bioconductor repositories,
+and to use those repositories when attempting to restore packages.
+
+### Bioconductor releases
+
+Bioconductor prepares different versions of its package repositories, for use
+with different versions of R. The version of Bioconductor used within a
+particular renv project is stored both as a project setting, and also within
+the project lockfile. This allows you to "lock" a particular project to a
+particular Bioconductor release, even as new Bioconductor releases are made
+available for newer versions of R.
+
+To set the version of Bioconductor used in a project, you can use:
+
+```{r}
+renv::settings$bioconductor.version("3.14")
+```
+
+If you later choose to upgrade R, you may need to upgrade the version
+of Bioconductor used as well.
+
+If you want to override the Bioconductor repositories used by renv, you can
+also explicitly set the following option:
+
+```{r}
+options(renv.bioconductor.repos = c(...))
+```
+
+
+## The package cellar
+
+In some cases, your project may depend on R packages which are not available
+from any external source, or that external source may not be accessible from the
+machine calling `renv::restore()`. To help accommodate these scenarios, renv
+allows you to prepare a package "cellar", to be used as an ad-hoc repository of
+packages during restore. This allows you to provide package tarballs that can be
+used to restore packages which cannot be retrieved from any other source.
+
+The environment variable `RENV_PATHS_CELLAR` can be used to customize the
+package cellar location.  It should point to a directory containing package
+binaries and sources, with a structure of the form:
+
+- `${RENV_PATHS_CELLAR}/<package>_<version>.tar.gz`; or
+- `${RENV_PATHS_CELLAR}/<package>/<package>_<version>.tar.gz`
+
+Alternatively, you can also use a project-local cellar by placing your
+packages within a folder located at `<project>/renv/cellar`. Note that this
+folder does not exist by default; you must create it to opt-in.
+
+- `<project>/renv/cellar/<package>_<version>.tar.gz`; or
+- `<project>/renv/cellar/<package>/<package>_<version>.tar.gz`
+
+As an example, if your project depended on a package `skeleton 1.0.0`, you could
+place a tarball for this package in one of the following locations:
+
+- `${RENV_PATHS_CELLAR}/skeleton_1.0.0.tar.gz`
+- `${RENV_PATHS_CELLAR}/skeleton/skeleton_1.0.0.tar.gz`
+- `<project>/renv/cellar/skeleton_1.0.0.tar.gz`; or
+- `<project>/renv/cellar/skeleton/skeleton_1.0.0.tar.gz`
+
+Once this is done, renv will consult these directories during future attempts
+to restore your packages.
+
+You can install a package from the cellar like any other package, i.e. `renv::install("skeleton")`.
+
+During restore, if a compatible package is located within the cellar, that copy
+of the package will be preferred even if that package might otherwise be
+accessible from its associated remote source. For example, if `skeleton 1.0.0`
+was also available on CRAN, `renv::restore()` would still use the tarball
+available in the cellar rather than the version available from CRAN.
+
+If you want to see what paths renv is using for the cellar, you can use:
+
+```{r}
+renv:::renv_paths_cellar()
+```
+
+See `?paths` for more details.
+
+### Explicit sources
+
+You can also provide explicit source paths in the lockfile if desired. This is
+most useful if you are building an renv lockfile "by hand", or need to tweak
+an existing lockfile to point at a separate package for installation. For
+example, you could have a package record in `renv.lock` of the form:
+
+```json
+{
+  "Package": "skeleton",
+  "Version": "1.0.1",
+  "Source": "/mnt/r/pkg/skeleton_1.0.1.tar.gz"
+}
+```
+
+Packages should have the following extensions, depending on whether the archive
+contains a binary copy of the package or the package sources:
+
+| **Platform** | **Binary** | **Sources** |
+| ------------ | ---------- | ----------- |
+| Windows      | `.zip`     | `.tar.gz`   |
+| macOS        | `.tgz`     | `.tar.gz`   |
+| Linux        | `.tar.gz`  | `.tar.gz`   |
+
+Note that on Linux, both binaries and sources should have the `.tar.gz`
+extension, but R and renv will handle this as appropriate during installation.
+
+
+## ABI compatibility
+
+ABI compatibility issues can arise if different packages were built against
+different versions of a shared dependency. For example, one package may have
+been built against Rcpp 1.0.6, and another package might have been built against
+Rcpp 1.0.7. However, because only one version of the Rcpp package can be loaded
+at a time within an R session, mixing of these two packages might cause issues
+either on load or at runtime depending on the version of Rcpp available.
+
+It's worth emphasizing that this is not Rcpp's fault; a package built against
+Rcpp 1.0.7 would reasonably expect newer APIs made available by that version of
+the package would be available at runtime, and that contract would be violated
+if an older version of Rcpp were installed in the project library. The challenge
+for renv is that this build-time dependency is not clearly communicated to
+renv; in general, it is not possible to know what packages (and their
+versions) a particular package was built against.
+
+
+## Build-time dependencies
+
+R packages might occasionally (and unintentionally) take a build-time
+dependency on another R package -- for example, a package with the code:
+
+```{r}
+# please don't do this!
+`%>%` <- magrittr::`%>%`
+```
+
+would take the version of `%>%` that was available from the version of magrittr
+that was available at _build_ time, not the one available at _run_ time. This
+could be problematic if, for example, an update to the magrittr package
+changed in a way that made old definitions of `%>%` incompatible with newer
+internal functions.
+
+In general, it is a mistake for packages to take a build-time dependency on
+exported objects from another package; rather, such objects should be imported
+at runtime (using e.g. `importFrom()` in the package `NAMESPACE` file).

renv/library/windows/R-4.5/x86_64-w64-mingw32/renv/doc/package-sources.html

@@ -0,0 +1,597 @@
+<!DOCTYPE html>
+
+<html>
+
+<head>
+
+<meta charset="utf-8" />
+<meta name="generator" content="pandoc" />
+<meta http-equiv="X-UA-Compatible" content="IE=EDGE" />
+
+<meta name="viewport" content="width=device-width, initial-scale=1" />
+
+
+
+<title>Package sources</title>
+
+<script>// Pandoc 2.9 adds attributes on both header and div. We remove the former (to
+// be compatible with the behavior of Pandoc < 2.8).
+document.addEventListener('DOMContentLoaded', function(e) {
+  var hs = document.querySelectorAll("div.section[class*='level'] > :first-child");
+  var i, h, a;
+  for (i = 0; i < hs.length; i++) {
+    h = hs[i];
+    if (!/^h[1-6]$/i.test(h.tagName)) continue;  // it should be a header h1-h6
+    a = h.attributes;
+    while (a.length > 0) h.removeAttribute(a[0].name);
+  }
+});
+</script>
+
+<style type="text/css">
+code{white-space: pre-wrap;}
+span.smallcaps{font-variant: small-caps;}
+span.underline{text-decoration: underline;}
+div.column{display: inline-block; vertical-align: top; width: 50%;}
+div.hanging-indent{margin-left: 1.5em; text-indent: -1.5em;}
+ul.task-list{list-style: none;}
+</style>
+
+
+
+<style type="text/css">
+code {
+white-space: pre;
+}
+.sourceCode {
+overflow: visible;
+}
+</style>
+<style type="text/css" data-origin="pandoc">
+html { -webkit-text-size-adjust: 100%; }
+pre > code.sourceCode { white-space: pre; position: relative; }
+pre > code.sourceCode > span { display: inline-block; line-height: 1.25; }
+pre > code.sourceCode > span:empty { height: 1.2em; }
+.sourceCode { overflow: visible; }
+code.sourceCode > span { color: inherit; text-decoration: inherit; }
+div.sourceCode { margin: 1em 0; }
+pre.sourceCode { margin: 0; }
+@media screen {
+div.sourceCode { overflow: auto; }
+}
+@media print {
+pre > code.sourceCode { white-space: pre-wrap; }
+pre > code.sourceCode > span { text-indent: -5em; padding-left: 5em; }
+}
+pre.numberSource code
+{ counter-reset: source-line 0; }
+pre.numberSource code > span
+{ position: relative; left: -4em; counter-increment: source-line; }
+pre.numberSource code > span > a:first-child::before
+{ content: counter(source-line);
+position: relative; left: -1em; text-align: right; vertical-align: baseline;
+border: none; display: inline-block;
+-webkit-touch-callout: none; -webkit-user-select: none;
+-khtml-user-select: none; -moz-user-select: none;
+-ms-user-select: none; user-select: none;
+padding: 0 4px; width: 4em;
+color: #aaaaaa;
+}
+pre.numberSource { margin-left: 3em; border-left: 1px solid #aaaaaa; padding-left: 4px; }
+div.sourceCode
+{ }
+@media screen {
+pre > code.sourceCode > span > a:first-child::before { text-decoration: underline; }
+}
+code span.al { color: #ff0000; font-weight: bold; } 
+code span.an { color: #60a0b0; font-weight: bold; font-style: italic; } 
+code span.at { color: #7d9029; } 
+code span.bn { color: #40a070; } 
+code span.bu { color: #008000; } 
+code span.cf { color: #007020; font-weight: bold; } 
+code span.ch { color: #4070a0; } 
+code span.cn { color: #880000; } 
+code span.co { color: #60a0b0; font-style: italic; } 
+code span.cv { color: #60a0b0; font-weight: bold; font-style: italic; } 
+code span.do { color: #ba2121; font-style: italic; } 
+code span.dt { color: #902000; } 
+code span.dv { color: #40a070; } 
+code span.er { color: #ff0000; font-weight: bold; } 
+code span.ex { } 
+code span.fl { color: #40a070; } 
+code span.fu { color: #06287e; } 
+code span.im { color: #008000; font-weight: bold; } 
+code span.in { color: #60a0b0; font-weight: bold; font-style: italic; } 
+code span.kw { color: #007020; font-weight: bold; } 
+code span.op { color: #666666; } 
+code span.ot { color: #007020; } 
+code span.pp { color: #bc7a00; } 
+code span.sc { color: #4070a0; } 
+code span.ss { color: #bb6688; } 
+code span.st { color: #4070a0; } 
+code span.va { color: #19177c; } 
+code span.vs { color: #4070a0; } 
+code span.wa { color: #60a0b0; font-weight: bold; font-style: italic; } 
+</style>
+<script>
+// apply pandoc div.sourceCode style to pre.sourceCode instead
+(function() {
+  var sheets = document.styleSheets;
+  for (var i = 0; i < sheets.length; i++) {
+    if (sheets[i].ownerNode.dataset["origin"] !== "pandoc") continue;
+    try { var rules = sheets[i].cssRules; } catch (e) { continue; }
+    var j = 0;
+    while (j < rules.length) {
+      var rule = rules[j];
+      // check if there is a div.sourceCode rule
+      if (rule.type !== rule.STYLE_RULE || rule.selectorText !== "div.sourceCode") {
+        j++;
+        continue;
+      }
+      var style = rule.style.cssText;
+      // check if color or background-color is set
+      if (rule.style.color === '' && rule.style.backgroundColor === '') {
+        j++;
+        continue;
+      }
+      // replace div.sourceCode by a pre.sourceCode rule
+      sheets[i].deleteRule(j);
+      sheets[i].insertRule('pre.sourceCode{' + style + '}', j);
+    }
+  }
+})();
+</script>
+
+
+
+
+<style type="text/css">body {
+background-color: #fff;
+margin: 1em auto;
+max-width: 700px;
+overflow: visible;
+padding-left: 2em;
+padding-right: 2em;
+font-family: "Open Sans", "Helvetica Neue", Helvetica, Arial, sans-serif;
+font-size: 14px;
+line-height: 1.35;
+}
+#TOC {
+clear: both;
+margin: 0 0 10px 10px;
+padding: 4px;
+width: 400px;
+border: 1px solid #CCCCCC;
+border-radius: 5px;
+background-color: #f6f6f6;
+font-size: 13px;
+line-height: 1.3;
+}
+#TOC .toctitle {
+font-weight: bold;
+font-size: 15px;
+margin-left: 5px;
+}
+#TOC ul {
+padding-left: 40px;
+margin-left: -1.5em;
+margin-top: 5px;
+margin-bottom: 5px;
+}
+#TOC ul ul {
+margin-left: -2em;
+}
+#TOC li {
+line-height: 16px;
+}
+table {
+margin: 1em auto;
+border-width: 1px;
+border-color: #DDDDDD;
+border-style: outset;
+border-collapse: collapse;
+}
+table th {
+border-width: 2px;
+padding: 5px;
+border-style: inset;
+}
+table td {
+border-width: 1px;
+border-style: inset;
+line-height: 18px;
+padding: 5px 5px;
+}
+table, table th, table td {
+border-left-style: none;
+border-right-style: none;
+}
+table thead, table tr.even {
+background-color: #f7f7f7;
+}
+p {
+margin: 0.5em 0;
+}
+blockquote {
+background-color: #f6f6f6;
+padding: 0.25em 0.75em;
+}
+hr {
+border-style: solid;
+border: none;
+border-top: 1px solid #777;
+margin: 28px 0;
+}
+dl {
+margin-left: 0;
+}
+dl dd {
+margin-bottom: 13px;
+margin-left: 13px;
+}
+dl dt {
+font-weight: bold;
+}
+ul {
+margin-top: 0;
+}
+ul li {
+list-style: circle outside;
+}
+ul ul {
+margin-bottom: 0;
+}
+pre, code {
+background-color: #f7f7f7;
+border-radius: 3px;
+color: #333;
+white-space: pre-wrap; 
+}
+pre {
+border-radius: 3px;
+margin: 5px 0px 10px 0px;
+padding: 10px;
+}
+pre:not([class]) {
+background-color: #f7f7f7;
+}
+code {
+font-family: Consolas, Monaco, 'Courier New', monospace;
+font-size: 85%;
+}
+p > code, li > code {
+padding: 2px 0px;
+}
+div.figure {
+text-align: center;
+}
+img {
+background-color: #FFFFFF;
+padding: 2px;
+border: 1px solid #DDDDDD;
+border-radius: 3px;
+border: 1px solid #CCCCCC;
+margin: 0 5px;
+}
+h1 {
+margin-top: 0;
+font-size: 35px;
+line-height: 40px;
+}
+h2 {
+border-bottom: 4px solid #f7f7f7;
+padding-top: 10px;
+padding-bottom: 2px;
+font-size: 145%;
+}
+h3 {
+border-bottom: 2px solid #f7f7f7;
+padding-top: 10px;
+font-size: 120%;
+}
+h4 {
+border-bottom: 1px solid #f7f7f7;
+margin-left: 8px;
+font-size: 105%;
+}
+h5, h6 {
+border-bottom: 1px solid #ccc;
+font-size: 105%;
+}
+a {
+color: #0033dd;
+text-decoration: none;
+}
+a:hover {
+color: #6666ff; }
+a:visited {
+color: #800080; }
+a:visited:hover {
+color: #BB00BB; }
+a[href^="http:"] {
+text-decoration: underline; }
+a[href^="https:"] {
+text-decoration: underline; }
+
+code > span.kw { color: #555; font-weight: bold; } 
+code > span.dt { color: #902000; } 
+code > span.dv { color: #40a070; } 
+code > span.bn { color: #d14; } 
+code > span.fl { color: #d14; } 
+code > span.ch { color: #d14; } 
+code > span.st { color: #d14; } 
+code > span.co { color: #888888; font-style: italic; } 
+code > span.ot { color: #007020; } 
+code > span.al { color: #ff0000; font-weight: bold; } 
+code > span.fu { color: #900; font-weight: bold; } 
+code > span.er { color: #a61717; background-color: #e3d2d2; } 
+</style>
+
+
+
+
+</head>
+
+<body>
+
+
+
+
+<h1 class="title toc-ignore">Package sources</h1>
+
+
+
+<div class="sourceCode" id="cb1"><pre class="sourceCode r"><code class="sourceCode r"><span id="cb1-1"><a href="#cb1-1" tabindex="-1"></a><span class="fu">library</span>(renv)</span></code></pre></div>
+<div id="package-sources" class="section level1">
+<h1>Package sources</h1>
+<p>renv uses an installed package’s <code>DESCRIPTION</code> file to
+infer its source. For example, packages installed from the CRAN
+repositories typically have the field:</p>
+<div class="sourceCode" id="cb2"><pre class="sourceCode sh"><code class="sourceCode bash"><span id="cb2-1"><a href="#cb2-1" tabindex="-1"></a><span class="ex">Repository:</span> CRAN</span></code></pre></div>
+<p>set, and renv takes this as a signal that the package was retrieved
+from CRAN.</p>
+<div id="inferring-package-sources" class="section level2">
+<h2>Inferring package sources</h2>
+<p>The following fields are checked, in order, when inferring a
+package’s source:</p>
+<ol style="list-style-type: decimal">
+<li><p>The <code>RemoteType</code> field; typically written for packages
+installed by the devtools, remotes and pak packages,</p></li>
+<li><p>The <code>Repository</code> field; for example, packages
+retrieved from CRAN will typically have the
+<code>Repository: CRAN</code> field,</p></li>
+<li><p>The <code>biocViews</code> field; typically present for packages
+installed from the Bioconductor repositories,</p></li>
+</ol>
+<p>As a fallback, if renv is unable to determine a package’s source from
+the <code>DESCRIPTION</code> file directly, but a package of the same
+name is available in the active R repositories (as specified in
+<code>getOption(&quot;repos&quot;)</code>), then the package will be treated as
+though it was installed from an R package repository.</p>
+<p>If all of the above methods fail, renv will finally check for a
+package available from the <em>cellar</em>. The package cellar is
+typically used as an escape hatch, for packages which do not have a
+well-defined remote source, or for packages which might not be remotely
+accessible from your machine.</p>
+</div>
+<div id="unknown-sources" class="section level2">
+<h2>Unknown sources</h2>
+<p>If renv is unable to infer a package’s source, it will inform you
+during <code>renv::snapshot()</code> – for example, if we attempted to
+snapshot a package called <code>skeleton</code> with no known
+source:</p>
+<div class="sourceCode" id="cb3"><pre class="sourceCode r"><code class="sourceCode r"><span id="cb3-1"><a href="#cb3-1" tabindex="-1"></a><span class="sc">&gt;</span> renv<span class="sc">::</span><span class="fu">snapshot</span>()</span>
+<span id="cb3-2"><a href="#cb3-2" tabindex="-1"></a>The following <span class="fu">package</span>(s) were installed from an unknown source<span class="sc">:</span></span>
+<span id="cb3-3"><a href="#cb3-3" tabindex="-1"></a></span>
+<span id="cb3-4"><a href="#cb3-4" tabindex="-1"></a>        skeleton</span>
+<span id="cb3-5"><a href="#cb3-5" tabindex="-1"></a></span>
+<span id="cb3-6"><a href="#cb3-6" tabindex="-1"></a>renv may be unable to restore these packages <span class="cf">in</span> the future.</span>
+<span id="cb3-7"><a href="#cb3-7" tabindex="-1"></a>Consider reinstalling these packages from a known <span class="fu">source</span> (e.g. CRAN).</span>
+<span id="cb3-8"><a href="#cb3-8" tabindex="-1"></a></span>
+<span id="cb3-9"><a href="#cb3-9" tabindex="-1"></a>Do you want to proceed? [y<span class="sc">/</span>N]<span class="sc">:</span></span></code></pre></div>
+<p>While you can still create a lockfile with such packages,
+<code>restore()</code> will likely fail unless you can ensure this
+package is installed through some other mechanism.</p>
+</div>
+<div id="custom-r-package-repositories" class="section level2">
+<h2>Custom R package repositories</h2>
+<p>Custom and local R package repositories are supported as well. The
+only requirement is that these repositories are set as part of the
+<code>repos</code> R option, and that these repositories are named. For
+example, you might use:</p>
+<div class="sourceCode" id="cb4"><pre class="sourceCode r"><code class="sourceCode r"><span id="cb4-1"><a href="#cb4-1" tabindex="-1"></a>repos <span class="ot">&lt;-</span> <span class="fu">c</span>(<span class="at">CRAN =</span> <span class="st">&quot;https://cloud.r-project.org&quot;</span>, <span class="at">WORK =</span> <span class="st">&quot;https://work.example.org&quot;</span>)</span>
+<span id="cb4-2"><a href="#cb4-2" tabindex="-1"></a><span class="fu">options</span>(<span class="at">repos =</span> repos)</span></code></pre></div>
+<p>to tell renv to work with both the official CRAN package repository,
+as well as a package repository you have hosted and set up in your work
+environment.</p>
+</div>
+<div id="bioconductor" class="section level2">
+<h2>Bioconductor</h2>
+<p>renv has been designed to work together as seamlessly as possible
+with the <a href="https://bioconductor.org/">Bioconductor</a> project.
+This vignette outlines some of the extra steps that may be required when
+using renv with packages obtained from Bioconductor.</p>
+</div>
+<div id="initializing-a-project" class="section level2">
+<h2>Initializing a project</h2>
+<p>To initialize renv in a project using Bioconductor, you can pass the
+<code>bioconductor</code> argument to <code>renv::init()</code>:</p>
+<div class="sourceCode" id="cb5"><pre class="sourceCode r"><code class="sourceCode r"><span id="cb5-1"><a href="#cb5-1" tabindex="-1"></a><span class="co"># use the latest-available Bioconductor release</span></span>
+<span id="cb5-2"><a href="#cb5-2" tabindex="-1"></a>renv<span class="sc">::</span><span class="fu">init</span>(<span class="at">bioconductor =</span> <span class="cn">TRUE</span>)</span>
+<span id="cb5-3"><a href="#cb5-3" tabindex="-1"></a></span>
+<span id="cb5-4"><a href="#cb5-4" tabindex="-1"></a><span class="co"># use a specific version of Bioconductor</span></span>
+<span id="cb5-5"><a href="#cb5-5" tabindex="-1"></a>renv<span class="sc">::</span><span class="fu">init</span>(<span class="at">bioconductor =</span> <span class="st">&quot;3.14&quot;</span>)</span></code></pre></div>
+<p>This will tell renv to activate the appropriate Bioconductor
+repositories, and to use those repositories when attempting to restore
+packages.</p>
+<div id="bioconductor-releases" class="section level3">
+<h3>Bioconductor releases</h3>
+<p>Bioconductor prepares different versions of its package repositories,
+for use with different versions of R. The version of Bioconductor used
+within a particular renv project is stored both as a project setting,
+and also within the project lockfile. This allows you to “lock” a
+particular project to a particular Bioconductor release, even as new
+Bioconductor releases are made available for newer versions of R.</p>
+<p>To set the version of Bioconductor used in a project, you can
+use:</p>
+<div class="sourceCode" id="cb6"><pre class="sourceCode r"><code class="sourceCode r"><span id="cb6-1"><a href="#cb6-1" tabindex="-1"></a>renv<span class="sc">::</span>settings<span class="sc">$</span><span class="fu">bioconductor.version</span>(<span class="st">&quot;3.14&quot;</span>)</span></code></pre></div>
+<p>If you later choose to upgrade R, you may need to upgrade the version
+of Bioconductor used as well.</p>
+<p>If you want to override the Bioconductor repositories used by renv,
+you can also explicitly set the following option:</p>
+<div class="sourceCode" id="cb7"><pre class="sourceCode r"><code class="sourceCode r"><span id="cb7-1"><a href="#cb7-1" tabindex="-1"></a><span class="fu">options</span>(<span class="at">renv.bioconductor.repos =</span> <span class="fu">c</span>(...))</span></code></pre></div>
+</div>
+</div>
+<div id="the-package-cellar" class="section level2">
+<h2>The package cellar</h2>
+<p>In some cases, your project may depend on R packages which are not
+available from any external source, or that external source may not be
+accessible from the machine calling <code>renv::restore()</code>. To
+help accommodate these scenarios, renv allows you to prepare a package
+“cellar”, to be used as an ad-hoc repository of packages during restore.
+This allows you to provide package tarballs that can be used to restore
+packages which cannot be retrieved from any other source.</p>
+<p>The environment variable <code>RENV_PATHS_CELLAR</code> can be used
+to customize the package cellar location. It should point to a directory
+containing package binaries and sources, with a structure of the
+form:</p>
+<ul>
+<li><code>${RENV_PATHS_CELLAR}/&lt;package&gt;_&lt;version&gt;.tar.gz</code>;
+or</li>
+<li><code>${RENV_PATHS_CELLAR}/&lt;package&gt;/&lt;package&gt;_&lt;version&gt;.tar.gz</code></li>
+</ul>
+<p>Alternatively, you can also use a project-local cellar by placing
+your packages within a folder located at
+<code>&lt;project&gt;/renv/cellar</code>. Note that this folder does not
+exist by default; you must create it to opt-in.</p>
+<ul>
+<li><code>&lt;project&gt;/renv/cellar/&lt;package&gt;_&lt;version&gt;.tar.gz</code>;
+or</li>
+<li><code>&lt;project&gt;/renv/cellar/&lt;package&gt;/&lt;package&gt;_&lt;version&gt;.tar.gz</code></li>
+</ul>
+<p>As an example, if your project depended on a package
+<code>skeleton 1.0.0</code>, you could place a tarball for this package
+in one of the following locations:</p>
+<ul>
+<li><code>${RENV_PATHS_CELLAR}/skeleton_1.0.0.tar.gz</code></li>
+<li><code>${RENV_PATHS_CELLAR}/skeleton/skeleton_1.0.0.tar.gz</code></li>
+<li><code>&lt;project&gt;/renv/cellar/skeleton_1.0.0.tar.gz</code>;
+or</li>
+<li><code>&lt;project&gt;/renv/cellar/skeleton/skeleton_1.0.0.tar.gz</code></li>
+</ul>
+<p>Once this is done, renv will consult these directories during future
+attempts to restore your packages.</p>
+<p>You can install a package from the cellar like any other package,
+i.e. <code>renv::install(&quot;skeleton&quot;)</code>.</p>
+<p>During restore, if a compatible package is located within the cellar,
+that copy of the package will be preferred even if that package might
+otherwise be accessible from its associated remote source. For example,
+if <code>skeleton 1.0.0</code> was also available on CRAN,
+<code>renv::restore()</code> would still use the tarball available in
+the cellar rather than the version available from CRAN.</p>
+<p>If you want to see what paths renv is using for the cellar, you can
+use:</p>
+<div class="sourceCode" id="cb8"><pre class="sourceCode r"><code class="sourceCode r"><span id="cb8-1"><a href="#cb8-1" tabindex="-1"></a>renv<span class="sc">:::</span><span class="fu">renv_paths_cellar</span>()</span></code></pre></div>
+<p>See <code>?paths</code> for more details.</p>
+<div id="explicit-sources" class="section level3">
+<h3>Explicit sources</h3>
+<p>You can also provide explicit source paths in the lockfile if
+desired. This is most useful if you are building an renv lockfile “by
+hand”, or need to tweak an existing lockfile to point at a separate
+package for installation. For example, you could have a package record
+in <code>renv.lock</code> of the form:</p>
+<div class="sourceCode" id="cb9"><pre class="sourceCode json"><code class="sourceCode json"><span id="cb9-1"><a href="#cb9-1" tabindex="-1"></a><span class="fu">{</span></span>
+<span id="cb9-2"><a href="#cb9-2" tabindex="-1"></a>  <span class="dt">&quot;Package&quot;</span><span class="fu">:</span> <span class="st">&quot;skeleton&quot;</span><span class="fu">,</span></span>
+<span id="cb9-3"><a href="#cb9-3" tabindex="-1"></a>  <span class="dt">&quot;Version&quot;</span><span class="fu">:</span> <span class="st">&quot;1.0.1&quot;</span><span class="fu">,</span></span>
+<span id="cb9-4"><a href="#cb9-4" tabindex="-1"></a>  <span class="dt">&quot;Source&quot;</span><span class="fu">:</span> <span class="st">&quot;/mnt/r/pkg/skeleton_1.0.1.tar.gz&quot;</span></span>
+<span id="cb9-5"><a href="#cb9-5" tabindex="-1"></a><span class="fu">}</span></span></code></pre></div>
+<p>Packages should have the following extensions, depending on whether
+the archive contains a binary copy of the package or the package
+sources:</p>
+<table>
+<thead>
+<tr class="header">
+<th><strong>Platform</strong></th>
+<th><strong>Binary</strong></th>
+<th><strong>Sources</strong></th>
+</tr>
+</thead>
+<tbody>
+<tr class="odd">
+<td>Windows</td>
+<td><code>.zip</code></td>
+<td><code>.tar.gz</code></td>
+</tr>
+<tr class="even">
+<td>macOS</td>
+<td><code>.tgz</code></td>
+<td><code>.tar.gz</code></td>
+</tr>
+<tr class="odd">
+<td>Linux</td>
+<td><code>.tar.gz</code></td>
+<td><code>.tar.gz</code></td>
+</tr>
+</tbody>
+</table>
+<p>Note that on Linux, both binaries and sources should have the
+<code>.tar.gz</code> extension, but R and renv will handle this as
+appropriate during installation.</p>
+</div>
+</div>
+<div id="abi-compatibility" class="section level2">
+<h2>ABI compatibility</h2>
+<p>ABI compatibility issues can arise if different packages were built
+against different versions of a shared dependency. For example, one
+package may have been built against Rcpp 1.0.6, and another package
+might have been built against Rcpp 1.0.7. However, because only one
+version of the Rcpp package can be loaded at a time within an R session,
+mixing of these two packages might cause issues either on load or at
+runtime depending on the version of Rcpp available.</p>
+<p>It’s worth emphasizing that this is not Rcpp’s fault; a package built
+against Rcpp 1.0.7 would reasonably expect newer APIs made available by
+that version of the package would be available at runtime, and that
+contract would be violated if an older version of Rcpp were installed in
+the project library. The challenge for renv is that this build-time
+dependency is not clearly communicated to renv; in general, it is not
+possible to know what packages (and their versions) a particular package
+was built against.</p>
+</div>
+<div id="build-time-dependencies" class="section level2">
+<h2>Build-time dependencies</h2>
+<p>R packages might occasionally (and unintentionally) take a build-time
+dependency on another R package – for example, a package with the
+code:</p>
+<div class="sourceCode" id="cb10"><pre class="sourceCode r"><code class="sourceCode r"><span id="cb10-1"><a href="#cb10-1" tabindex="-1"></a><span class="co"># please don&#39;t do this!</span></span>
+<span id="cb10-2"><a href="#cb10-2" tabindex="-1"></a><span class="st">`</span><span class="at">%&gt;%</span><span class="st">`</span> <span class="ot">&lt;-</span> magrittr<span class="sc">::</span><span class="st">`</span><span class="at">%&gt;%</span><span class="st">`</span></span></code></pre></div>
+<p>would take the version of <code>%&gt;%</code> that was available from
+the version of magrittr that was available at <em>build</em> time, not
+the one available at <em>run</em> time. This could be problematic if,
+for example, an update to the magrittr package changed in a way that
+made old definitions of <code>%&gt;%</code> incompatible with newer
+internal functions.</p>
+<p>In general, it is a mistake for packages to take a build-time
+dependency on exported objects from another package; rather, such
+objects should be imported at runtime (using
+e.g. <code>importFrom()</code> in the package <code>NAMESPACE</code>
+file).</p>
+</div>
+</div>
+
+
+
+<!-- code folding -->
+
+
+<!-- dynamically load mathjax for compatibility with self-contained -->
+<script>
+  (function () {
+    var script = document.createElement("script");
+    script.type = "text/javascript";
+    script.src  = "https://mathjax.rstudio.com/latest/MathJax.js?config=TeX-AMS-MML_HTMLorMML";
+    document.getElementsByTagName("head")[0].appendChild(script);
+  })();
+</script>
+
+</body>
+</html>

renv/library/windows/R-4.5/x86_64-w64-mingw32/renv/doc/packages.R

@@ -0,0 +1,13 @@
+## ----include=FALSE------------------------------------------------------------
+knitr::opts_chunk$set(
+  collapse = TRUE,
+  comment = "#>",
+  eval = FALSE
+)
+
+## -----------------------------------------------------------------------------
+# renv::install()
+
+## -----------------------------------------------------------------------------
+# renv::update()
+

renv/library/windows/R-4.5/x86_64-w64-mingw32/renv/doc/packages.Rmd

@@ -0,0 +1,137 @@
+---
+title: "Package development"
+output: rmarkdown::html_vignette
+vignette: >
+  %\VignetteIndexEntry{Package development}
+  %\VignetteEngine{knitr::rmarkdown}
+  %\VignetteEncoding{UTF-8}
+---
+
+```{r, include=FALSE}
+knitr::opts_chunk$set(
+  collapse = TRUE,
+  comment = "#>",
+  eval = FALSE
+)
+```
+
+
+## Development
+
+Often, R packages will have other R packages as dependencies. For this, one must
+declare their R package dependencies within the package `DESCRIPTION` file. If
+you want to prepare your environment for package development, you can use:
+
+```{r}
+renv::install()
+```
+
+to install the packages as declared in the package's `DESCRIPTION` file. This
+action is roughly analogous to `remotes::install_deps()`.
+
+If you're developing a package that you intend to release to CRAN, then you
+likely want to build and test your package against the latest versions of your
+dependencies as available on CRAN. For this, you should consider using:
+
+```{r}
+renv::update()
+```
+
+to ensure your package dependencies are up-to-date, as appropriate.
+
+
+## Isolation
+
+Normally, a package under development should be tested against the
+latest-available versions of its dependencies on CRAN. However, in some cases,
+you may need to ensure your package is compatible with other packages also
+currently under development.
+
+In these cases, the renv project library can be useful -- you can install the
+development version(s) of your dependencies into the project library, without
+worrying about clobbering any packages already installed in your system library.
+
+In these cases, you can declare your development dependencies using the
+`Remotes` field of the `DESCRIPTION` file; e.g.
+
+```sh
+Remotes:
+  r-lib/ggplot2
+```
+
+and `renv::install()` will parse that remotes declaration and retrieve the
+requested package. See the remotes vignette,
+[Dependency resolution for R package development][dependencies],
+for more details.
+
+
+## Library Paths
+
+For package projects using renv, a library path outside of the project
+directory will be used instead. As an example, on macOS, this might look like:
+
+```r
+> .libPaths()
+[1] "/Users/kevin/Library/Caches/org.R-project.R/R/renv/library/example-552f6e80/R-4.3/aarch64-apple-darwin20"
+[2] "/Users/kevin/Library/Caches/org.R-project.R/R/renv/sandbox/R-4.3/aarch64-apple-darwin20/ac5c2659"
+```
+
+This is done to avoid issues with `R CMD build`, which can become very slow if
+your project contains a large number of files -- as can happen if the project
+library is located in `renv/library` (the typical location). Note that even
+though the library is located outside of the project, the library path
+generated will still be unique to that project, and so the project is still
+effectively isolated in the same way as other renv projects normally are.
+
+If you want to customize the location where `renv` places project libraries in
+this scenario, you can use the `RENV_PATHS_LIBRARY_ROOT` environment variable.
+For example:
+
+```sh
+RENV_PATHS_LIBRARY_ROOT = ~/.renv/library
+```
+
+If you'd still prefer to keep your project library within the project directory,
+you can set:
+
+```sh
+RENV_PATHS_LIBRARY = renv/library
+```
+
+within an appropriate `.Renviron` start-up profile -- but please be aware of
+the caveats to doing this, as the performance of `R CMD build` will be affected.
+
+
+## Testing
+
+While developing your package, you may want to use a continuous integration
+service (such as [Travis CI](https://www.travis-ci.com)) to build and test
+your package remotely. You can use renv to help facilitate this testing --
+see the [Continuous Integration](ci.html) vignette for more information. In
+particular, clever use of the renv cache can help save time that might
+normally be spent on package installation. See
+<https://github.com/rstudio/renv/blob/main/.github/workflows/R-CMD-check.yaml>
+for an example of how renv uses itself for package management in its own
+CI tests.
+
+
+## Submitting to CRAN
+
+Note that packages submitted to CRAN should be designed to work with the other R
+packages currently available on CRAN. For that reason, when preparing your package
+for submission, you'll need to ensure your source package tarball does not
+include any `renv` infrastructure. `renv` makes this easy by automatically
+including
+
+```sh
+^renv$
+^renv\.lock$
+```
+
+in your package's `.Rbuildignore` file. This instructs `R CMD build` to not
+include these files and folders in the generated package tarball. Through this,
+even if `renv` is used during package development, it's still easy to build and
+publish your package to CRAN as you would when developing packages without `renv`.
+
+
+[dependencies]: https://remotes.r-lib.org/articles/dependencies.html

renv/library/windows/R-4.5/x86_64-w64-mingw32/renv/doc/packages.html

@@ -0,0 +1,454 @@
+<!DOCTYPE html>
+
+<html>
+
+<head>
+
+<meta charset="utf-8" />
+<meta name="generator" content="pandoc" />
+<meta http-equiv="X-UA-Compatible" content="IE=EDGE" />
+
+<meta name="viewport" content="width=device-width, initial-scale=1" />
+
+
+
+<title>Package development</title>
+
+<script>// Pandoc 2.9 adds attributes on both header and div. We remove the former (to
+// be compatible with the behavior of Pandoc < 2.8).
+document.addEventListener('DOMContentLoaded', function(e) {
+  var hs = document.querySelectorAll("div.section[class*='level'] > :first-child");
+  var i, h, a;
+  for (i = 0; i < hs.length; i++) {
+    h = hs[i];
+    if (!/^h[1-6]$/i.test(h.tagName)) continue;  // it should be a header h1-h6
+    a = h.attributes;
+    while (a.length > 0) h.removeAttribute(a[0].name);
+  }
+});
+</script>
+
+<style type="text/css">
+code{white-space: pre-wrap;}
+span.smallcaps{font-variant: small-caps;}
+span.underline{text-decoration: underline;}
+div.column{display: inline-block; vertical-align: top; width: 50%;}
+div.hanging-indent{margin-left: 1.5em; text-indent: -1.5em;}
+ul.task-list{list-style: none;}
+</style>
+
+
+
+<style type="text/css">
+code {
+white-space: pre;
+}
+.sourceCode {
+overflow: visible;
+}
+</style>
+<style type="text/css" data-origin="pandoc">
+html { -webkit-text-size-adjust: 100%; }
+pre > code.sourceCode { white-space: pre; position: relative; }
+pre > code.sourceCode > span { display: inline-block; line-height: 1.25; }
+pre > code.sourceCode > span:empty { height: 1.2em; }
+.sourceCode { overflow: visible; }
+code.sourceCode > span { color: inherit; text-decoration: inherit; }
+div.sourceCode { margin: 1em 0; }
+pre.sourceCode { margin: 0; }
+@media screen {
+div.sourceCode { overflow: auto; }
+}
+@media print {
+pre > code.sourceCode { white-space: pre-wrap; }
+pre > code.sourceCode > span { text-indent: -5em; padding-left: 5em; }
+}
+pre.numberSource code
+{ counter-reset: source-line 0; }
+pre.numberSource code > span
+{ position: relative; left: -4em; counter-increment: source-line; }
+pre.numberSource code > span > a:first-child::before
+{ content: counter(source-line);
+position: relative; left: -1em; text-align: right; vertical-align: baseline;
+border: none; display: inline-block;
+-webkit-touch-callout: none; -webkit-user-select: none;
+-khtml-user-select: none; -moz-user-select: none;
+-ms-user-select: none; user-select: none;
+padding: 0 4px; width: 4em;
+color: #aaaaaa;
+}
+pre.numberSource { margin-left: 3em; border-left: 1px solid #aaaaaa; padding-left: 4px; }
+div.sourceCode
+{ }
+@media screen {
+pre > code.sourceCode > span > a:first-child::before { text-decoration: underline; }
+}
+code span.al { color: #ff0000; font-weight: bold; } 
+code span.an { color: #60a0b0; font-weight: bold; font-style: italic; } 
+code span.at { color: #7d9029; } 
+code span.bn { color: #40a070; } 
+code span.bu { color: #008000; } 
+code span.cf { color: #007020; font-weight: bold; } 
+code span.ch { color: #4070a0; } 
+code span.cn { color: #880000; } 
+code span.co { color: #60a0b0; font-style: italic; } 
+code span.cv { color: #60a0b0; font-weight: bold; font-style: italic; } 
+code span.do { color: #ba2121; font-style: italic; } 
+code span.dt { color: #902000; } 
+code span.dv { color: #40a070; } 
+code span.er { color: #ff0000; font-weight: bold; } 
+code span.ex { } 
+code span.fl { color: #40a070; } 
+code span.fu { color: #06287e; } 
+code span.im { color: #008000; font-weight: bold; } 
+code span.in { color: #60a0b0; font-weight: bold; font-style: italic; } 
+code span.kw { color: #007020; font-weight: bold; } 
+code span.op { color: #666666; } 
+code span.ot { color: #007020; } 
+code span.pp { color: #bc7a00; } 
+code span.sc { color: #4070a0; } 
+code span.ss { color: #bb6688; } 
+code span.st { color: #4070a0; } 
+code span.va { color: #19177c; } 
+code span.vs { color: #4070a0; } 
+code span.wa { color: #60a0b0; font-weight: bold; font-style: italic; } 
+</style>
+<script>
+// apply pandoc div.sourceCode style to pre.sourceCode instead
+(function() {
+  var sheets = document.styleSheets;
+  for (var i = 0; i < sheets.length; i++) {
+    if (sheets[i].ownerNode.dataset["origin"] !== "pandoc") continue;
+    try { var rules = sheets[i].cssRules; } catch (e) { continue; }
+    var j = 0;
+    while (j < rules.length) {
+      var rule = rules[j];
+      // check if there is a div.sourceCode rule
+      if (rule.type !== rule.STYLE_RULE || rule.selectorText !== "div.sourceCode") {
+        j++;
+        continue;
+      }
+      var style = rule.style.cssText;
+      // check if color or background-color is set
+      if (rule.style.color === '' && rule.style.backgroundColor === '') {
+        j++;
+        continue;
+      }
+      // replace div.sourceCode by a pre.sourceCode rule
+      sheets[i].deleteRule(j);
+      sheets[i].insertRule('pre.sourceCode{' + style + '}', j);
+    }
+  }
+})();
+</script>
+
+
+
+
+<style type="text/css">body {
+background-color: #fff;
+margin: 1em auto;
+max-width: 700px;
+overflow: visible;
+padding-left: 2em;
+padding-right: 2em;
+font-family: "Open Sans", "Helvetica Neue", Helvetica, Arial, sans-serif;
+font-size: 14px;
+line-height: 1.35;
+}
+#TOC {
+clear: both;
+margin: 0 0 10px 10px;
+padding: 4px;
+width: 400px;
+border: 1px solid #CCCCCC;
+border-radius: 5px;
+background-color: #f6f6f6;
+font-size: 13px;
+line-height: 1.3;
+}
+#TOC .toctitle {
+font-weight: bold;
+font-size: 15px;
+margin-left: 5px;
+}
+#TOC ul {
+padding-left: 40px;
+margin-left: -1.5em;
+margin-top: 5px;
+margin-bottom: 5px;
+}
+#TOC ul ul {
+margin-left: -2em;
+}
+#TOC li {
+line-height: 16px;
+}
+table {
+margin: 1em auto;
+border-width: 1px;
+border-color: #DDDDDD;
+border-style: outset;
+border-collapse: collapse;
+}
+table th {
+border-width: 2px;
+padding: 5px;
+border-style: inset;
+}
+table td {
+border-width: 1px;
+border-style: inset;
+line-height: 18px;
+padding: 5px 5px;
+}
+table, table th, table td {
+border-left-style: none;
+border-right-style: none;
+}
+table thead, table tr.even {
+background-color: #f7f7f7;
+}
+p {
+margin: 0.5em 0;
+}
+blockquote {
+background-color: #f6f6f6;
+padding: 0.25em 0.75em;
+}
+hr {
+border-style: solid;
+border: none;
+border-top: 1px solid #777;
+margin: 28px 0;
+}
+dl {
+margin-left: 0;
+}
+dl dd {
+margin-bottom: 13px;
+margin-left: 13px;
+}
+dl dt {
+font-weight: bold;
+}
+ul {
+margin-top: 0;
+}
+ul li {
+list-style: circle outside;
+}
+ul ul {
+margin-bottom: 0;
+}
+pre, code {
+background-color: #f7f7f7;
+border-radius: 3px;
+color: #333;
+white-space: pre-wrap; 
+}
+pre {
+border-radius: 3px;
+margin: 5px 0px 10px 0px;
+padding: 10px;
+}
+pre:not([class]) {
+background-color: #f7f7f7;
+}
+code {
+font-family: Consolas, Monaco, 'Courier New', monospace;
+font-size: 85%;
+}
+p > code, li > code {
+padding: 2px 0px;
+}
+div.figure {
+text-align: center;
+}
+img {
+background-color: #FFFFFF;
+padding: 2px;
+border: 1px solid #DDDDDD;
+border-radius: 3px;
+border: 1px solid #CCCCCC;
+margin: 0 5px;
+}
+h1 {
+margin-top: 0;
+font-size: 35px;
+line-height: 40px;
+}
+h2 {
+border-bottom: 4px solid #f7f7f7;
+padding-top: 10px;
+padding-bottom: 2px;
+font-size: 145%;
+}
+h3 {
+border-bottom: 2px solid #f7f7f7;
+padding-top: 10px;
+font-size: 120%;
+}
+h4 {
+border-bottom: 1px solid #f7f7f7;
+margin-left: 8px;
+font-size: 105%;
+}
+h5, h6 {
+border-bottom: 1px solid #ccc;
+font-size: 105%;
+}
+a {
+color: #0033dd;
+text-decoration: none;
+}
+a:hover {
+color: #6666ff; }
+a:visited {
+color: #800080; }
+a:visited:hover {
+color: #BB00BB; }
+a[href^="http:"] {
+text-decoration: underline; }
+a[href^="https:"] {
+text-decoration: underline; }
+
+code > span.kw { color: #555; font-weight: bold; } 
+code > span.dt { color: #902000; } 
+code > span.dv { color: #40a070; } 
+code > span.bn { color: #d14; } 
+code > span.fl { color: #d14; } 
+code > span.ch { color: #d14; } 
+code > span.st { color: #d14; } 
+code > span.co { color: #888888; font-style: italic; } 
+code > span.ot { color: #007020; } 
+code > span.al { color: #ff0000; font-weight: bold; } 
+code > span.fu { color: #900; font-weight: bold; } 
+code > span.er { color: #a61717; background-color: #e3d2d2; } 
+</style>
+
+
+
+
+</head>
+
+<body>
+
+
+
+
+<h1 class="title toc-ignore">Package development</h1>
+
+
+
+<div id="development" class="section level2">
+<h2>Development</h2>
+<p>Often, R packages will have other R packages as dependencies. For
+this, one must declare their R package dependencies within the package
+<code>DESCRIPTION</code> file. If you want to prepare your environment
+for package development, you can use:</p>
+<div class="sourceCode" id="cb1"><pre class="sourceCode r"><code class="sourceCode r"><span id="cb1-1"><a href="#cb1-1" tabindex="-1"></a>renv<span class="sc">::</span><span class="fu">install</span>()</span></code></pre></div>
+<p>to install the packages as declared in the package’s
+<code>DESCRIPTION</code> file. This action is roughly analogous to
+<code>remotes::install_deps()</code>.</p>
+<p>If you’re developing a package that you intend to release to CRAN,
+then you likely want to build and test your package against the latest
+versions of your dependencies as available on CRAN. For this, you should
+consider using:</p>
+<div class="sourceCode" id="cb2"><pre class="sourceCode r"><code class="sourceCode r"><span id="cb2-1"><a href="#cb2-1" tabindex="-1"></a>renv<span class="sc">::</span><span class="fu">update</span>()</span></code></pre></div>
+<p>to ensure your package dependencies are up-to-date, as
+appropriate.</p>
+</div>
+<div id="isolation" class="section level2">
+<h2>Isolation</h2>
+<p>Normally, a package under development should be tested against the
+latest-available versions of its dependencies on CRAN. However, in some
+cases, you may need to ensure your package is compatible with other
+packages also currently under development.</p>
+<p>In these cases, the renv project library can be useful – you can
+install the development version(s) of your dependencies into the project
+library, without worrying about clobbering any packages already
+installed in your system library.</p>
+<p>In these cases, you can declare your development dependencies using
+the <code>Remotes</code> field of the <code>DESCRIPTION</code> file;
+e.g.</p>
+<div class="sourceCode" id="cb3"><pre class="sourceCode sh"><code class="sourceCode bash"><span id="cb3-1"><a href="#cb3-1" tabindex="-1"></a><span class="ex">Remotes:</span></span>
+<span id="cb3-2"><a href="#cb3-2" tabindex="-1"></a>  <span class="ex">r-lib/ggplot2</span></span></code></pre></div>
+<p>and <code>renv::install()</code> will parse that remotes declaration
+and retrieve the requested package. See the remotes vignette, <a href="https://remotes.r-lib.org/articles/dependencies.html">Dependency
+resolution for R package development</a>, for more details.</p>
+</div>
+<div id="library-paths" class="section level2">
+<h2>Library Paths</h2>
+<p>For package projects using renv, a library path outside of the
+project directory will be used instead. As an example, on macOS, this
+might look like:</p>
+<div class="sourceCode" id="cb4"><pre class="sourceCode r"><code class="sourceCode r"><span id="cb4-1"><a href="#cb4-1" tabindex="-1"></a><span class="sc">&gt;</span> <span class="fu">.libPaths</span>()</span>
+<span id="cb4-2"><a href="#cb4-2" tabindex="-1"></a>[<span class="dv">1</span>] <span class="st">&quot;/Users/kevin/Library/Caches/org.R-project.R/R/renv/library/example-552f6e80/R-4.3/aarch64-apple-darwin20&quot;</span></span>
+<span id="cb4-3"><a href="#cb4-3" tabindex="-1"></a>[<span class="dv">2</span>] <span class="st">&quot;/Users/kevin/Library/Caches/org.R-project.R/R/renv/sandbox/R-4.3/aarch64-apple-darwin20/ac5c2659&quot;</span></span></code></pre></div>
+<p>This is done to avoid issues with <code>R CMD build</code>, which can
+become very slow if your project contains a large number of files – as
+can happen if the project library is located in
+<code>renv/library</code> (the typical location). Note that even though
+the library is located outside of the project, the library path
+generated will still be unique to that project, and so the project is
+still effectively isolated in the same way as other renv projects
+normally are.</p>
+<p>If you want to customize the location where <code>renv</code> places
+project libraries in this scenario, you can use the
+<code>RENV_PATHS_LIBRARY_ROOT</code> environment variable. For
+example:</p>
+<div class="sourceCode" id="cb5"><pre class="sourceCode sh"><code class="sourceCode bash"><span id="cb5-1"><a href="#cb5-1" tabindex="-1"></a><span class="ex">RENV_PATHS_LIBRARY_ROOT</span> = ~/.renv/library</span></code></pre></div>
+<p>If you’d still prefer to keep your project library within the project
+directory, you can set:</p>
+<div class="sourceCode" id="cb6"><pre class="sourceCode sh"><code class="sourceCode bash"><span id="cb6-1"><a href="#cb6-1" tabindex="-1"></a><span class="ex">RENV_PATHS_LIBRARY</span> = renv/library</span></code></pre></div>
+<p>within an appropriate <code>.Renviron</code> start-up profile – but
+please be aware of the caveats to doing this, as the performance of
+<code>R CMD build</code> will be affected.</p>
+</div>
+<div id="testing" class="section level2">
+<h2>Testing</h2>
+<p>While developing your package, you may want to use a continuous
+integration service (such as <a href="https://www.travis-ci.com">Travis
+CI</a>) to build and test your package remotely. You can use renv to
+help facilitate this testing – see the <a href="ci.html">Continuous
+Integration</a> vignette for more information. In particular, clever use
+of the renv cache can help save time that might normally be spent on
+package installation. See <a href="https://github.com/rstudio/renv/blob/main/.github/workflows/R-CMD-check.yaml" class="uri">https://github.com/rstudio/renv/blob/main/.github/workflows/R-CMD-check.yaml</a>
+for an example of how renv uses itself for package management in its own
+CI tests.</p>
+</div>
+<div id="submitting-to-cran" class="section level2">
+<h2>Submitting to CRAN</h2>
+<p>Note that packages submitted to CRAN should be designed to work with
+the other R packages currently available on CRAN. For that reason, when
+preparing your package for submission, you’ll need to ensure your source
+package tarball does not include any <code>renv</code> infrastructure.
+<code>renv</code> makes this easy by automatically including</p>
+<div class="sourceCode" id="cb7"><pre class="sourceCode sh"><code class="sourceCode bash"><span id="cb7-1"><a href="#cb7-1" tabindex="-1"></a><span class="ex">^renv$</span></span>
+<span id="cb7-2"><a href="#cb7-2" tabindex="-1"></a><span class="ex">^renv\.lock$</span></span></code></pre></div>
+<p>in your package’s <code>.Rbuildignore</code> file. This instructs
+<code>R CMD build</code> to not include these files and folders in the
+generated package tarball. Through this, even if <code>renv</code> is
+used during package development, it’s still easy to build and publish
+your package to CRAN as you would when developing packages without
+<code>renv</code>.</p>
+</div>
+
+
+
+<!-- code folding -->
+
+
+<!-- dynamically load mathjax for compatibility with self-contained -->
+<script>
+  (function () {
+    var script = document.createElement("script");
+    script.type = "text/javascript";
+    script.src  = "https://mathjax.rstudio.com/latest/MathJax.js?config=TeX-AMS-MML_HTMLorMML";
+    document.getElementsByTagName("head")[0].appendChild(script);
+  })();
+</script>
+
+</body>
+</html>

renv/library/windows/R-4.5/x86_64-w64-mingw32/renv/doc/packrat.R

@@ -0,0 +1,10 @@
+## ----include=FALSE------------------------------------------------------------
+knitr::opts_chunk$set(
+  collapse = TRUE,
+  comment = "#>",
+  eval = FALSE
+)
+
+## ----setup--------------------------------------------------------------------
+# library(renv)
+

renv/library/windows/R-4.5/x86_64-w64-mingw32/renv/doc/packrat.Rmd

@@ -0,0 +1,43 @@
+---
+title: "packrat vs. renv"
+output: rmarkdown::html_vignette
+vignette: >
+  %\VignetteIndexEntry{packrat vs. renv}
+  %\VignetteEngine{knitr::rmarkdown}
+  %\VignetteEncoding{UTF-8}
+---
+
+```{r, include=FALSE}
+knitr::opts_chunk$set(
+  collapse = TRUE,
+  comment = "#>",
+  eval = FALSE
+)
+```
+
+```{r setup}
+library(renv)
+```
+
+Our first attempt at solving the problem of reproducible environments was [packrat](https://rstudio.github.io/packrat/).
+While we learned a lot from packrat, it ultimately proved challenging to use in ways that were difficult to fix.
+This led us to create renv, a system with fewer surprises and better defaults.
+If you're an existing packrat user, you can call `renv::migrate()` to switch renv, then read on to learn about the main differences:
+
+1.  The renv lockfile `renv.lock` is formatted as [JSON](https://www.json.org/).
+    This should make the lockfile easier to use and consume with other tools.
+
+2.  renv no longer attempts to explicitly download and track R package source tarballs within your project.
+    This was a frustrating default that operated under the assumption that you might later want to be able to restore a project's private library without access to a CRAN repository.
+    In practice, this is almost never the case, and the time spent downloading + storing the package sources seemed to outweigh the potential reproducibility benefits.
+
+3.  Packrat tried to maintain the distinction between so-called *stale* packages; that is, R packages which were installed by Packrat but were not recorded in the lockfile for some reason.
+    This distinction was (1) overall not useful, and (2) confusing.
+    renv no longer makes this distinction: `snapshot()` saves the state of your project library to `renv.lock`, `restore()` loads the state of your project library from `renv.lock`, and that's all.
+
+4.  In renv, the global package cache is enabled by default.
+    This should reduce overall disk-space usage as packages can effectively be shared across each project using renv.
+
+5.  renv's dependency discovery machinery is more configurable.
+    The function `renv::dependencies()` is exported, and users can create `.renvignore` files to instruct renv to ignore specific files and folders in their projects.
+    (See `?renv::dependencies` for more information.)

renv/library/windows/R-4.5/x86_64-w64-mingw32/renv/doc/packrat.html

@@ -0,0 +1,396 @@
+<!DOCTYPE html>
+
+<html>
+
+<head>
+
+<meta charset="utf-8" />
+<meta name="generator" content="pandoc" />
+<meta http-equiv="X-UA-Compatible" content="IE=EDGE" />
+
+<meta name="viewport" content="width=device-width, initial-scale=1" />
+
+
+
+<title>packrat vs. renv</title>
+
+<script>// Pandoc 2.9 adds attributes on both header and div. We remove the former (to
+// be compatible with the behavior of Pandoc < 2.8).
+document.addEventListener('DOMContentLoaded', function(e) {
+  var hs = document.querySelectorAll("div.section[class*='level'] > :first-child");
+  var i, h, a;
+  for (i = 0; i < hs.length; i++) {
+    h = hs[i];
+    if (!/^h[1-6]$/i.test(h.tagName)) continue;  // it should be a header h1-h6
+    a = h.attributes;
+    while (a.length > 0) h.removeAttribute(a[0].name);
+  }
+});
+</script>
+
+<style type="text/css">
+code{white-space: pre-wrap;}
+span.smallcaps{font-variant: small-caps;}
+span.underline{text-decoration: underline;}
+div.column{display: inline-block; vertical-align: top; width: 50%;}
+div.hanging-indent{margin-left: 1.5em; text-indent: -1.5em;}
+ul.task-list{list-style: none;}
+</style>
+
+
+
+<style type="text/css">
+code {
+white-space: pre;
+}
+.sourceCode {
+overflow: visible;
+}
+</style>
+<style type="text/css" data-origin="pandoc">
+html { -webkit-text-size-adjust: 100%; }
+pre > code.sourceCode { white-space: pre; position: relative; }
+pre > code.sourceCode > span { display: inline-block; line-height: 1.25; }
+pre > code.sourceCode > span:empty { height: 1.2em; }
+.sourceCode { overflow: visible; }
+code.sourceCode > span { color: inherit; text-decoration: inherit; }
+div.sourceCode { margin: 1em 0; }
+pre.sourceCode { margin: 0; }
+@media screen {
+div.sourceCode { overflow: auto; }
+}
+@media print {
+pre > code.sourceCode { white-space: pre-wrap; }
+pre > code.sourceCode > span { text-indent: -5em; padding-left: 5em; }
+}
+pre.numberSource code
+{ counter-reset: source-line 0; }
+pre.numberSource code > span
+{ position: relative; left: -4em; counter-increment: source-line; }
+pre.numberSource code > span > a:first-child::before
+{ content: counter(source-line);
+position: relative; left: -1em; text-align: right; vertical-align: baseline;
+border: none; display: inline-block;
+-webkit-touch-callout: none; -webkit-user-select: none;
+-khtml-user-select: none; -moz-user-select: none;
+-ms-user-select: none; user-select: none;
+padding: 0 4px; width: 4em;
+color: #aaaaaa;
+}
+pre.numberSource { margin-left: 3em; border-left: 1px solid #aaaaaa; padding-left: 4px; }
+div.sourceCode
+{ }
+@media screen {
+pre > code.sourceCode > span > a:first-child::before { text-decoration: underline; }
+}
+code span.al { color: #ff0000; font-weight: bold; } 
+code span.an { color: #60a0b0; font-weight: bold; font-style: italic; } 
+code span.at { color: #7d9029; } 
+code span.bn { color: #40a070; } 
+code span.bu { color: #008000; } 
+code span.cf { color: #007020; font-weight: bold; } 
+code span.ch { color: #4070a0; } 
+code span.cn { color: #880000; } 
+code span.co { color: #60a0b0; font-style: italic; } 
+code span.cv { color: #60a0b0; font-weight: bold; font-style: italic; } 
+code span.do { color: #ba2121; font-style: italic; } 
+code span.dt { color: #902000; } 
+code span.dv { color: #40a070; } 
+code span.er { color: #ff0000; font-weight: bold; } 
+code span.ex { } 
+code span.fl { color: #40a070; } 
+code span.fu { color: #06287e; } 
+code span.im { color: #008000; font-weight: bold; } 
+code span.in { color: #60a0b0; font-weight: bold; font-style: italic; } 
+code span.kw { color: #007020; font-weight: bold; } 
+code span.op { color: #666666; } 
+code span.ot { color: #007020; } 
+code span.pp { color: #bc7a00; } 
+code span.sc { color: #4070a0; } 
+code span.ss { color: #bb6688; } 
+code span.st { color: #4070a0; } 
+code span.va { color: #19177c; } 
+code span.vs { color: #4070a0; } 
+code span.wa { color: #60a0b0; font-weight: bold; font-style: italic; } 
+</style>
+<script>
+// apply pandoc div.sourceCode style to pre.sourceCode instead
+(function() {
+  var sheets = document.styleSheets;
+  for (var i = 0; i < sheets.length; i++) {
+    if (sheets[i].ownerNode.dataset["origin"] !== "pandoc") continue;
+    try { var rules = sheets[i].cssRules; } catch (e) { continue; }
+    var j = 0;
+    while (j < rules.length) {
+      var rule = rules[j];
+      // check if there is a div.sourceCode rule
+      if (rule.type !== rule.STYLE_RULE || rule.selectorText !== "div.sourceCode") {
+        j++;
+        continue;
+      }
+      var style = rule.style.cssText;
+      // check if color or background-color is set
+      if (rule.style.color === '' && rule.style.backgroundColor === '') {
+        j++;
+        continue;
+      }
+      // replace div.sourceCode by a pre.sourceCode rule
+      sheets[i].deleteRule(j);
+      sheets[i].insertRule('pre.sourceCode{' + style + '}', j);
+    }
+  }
+})();
+</script>
+
+
+
+
+<style type="text/css">body {
+background-color: #fff;
+margin: 1em auto;
+max-width: 700px;
+overflow: visible;
+padding-left: 2em;
+padding-right: 2em;
+font-family: "Open Sans", "Helvetica Neue", Helvetica, Arial, sans-serif;
+font-size: 14px;
+line-height: 1.35;
+}
+#TOC {
+clear: both;
+margin: 0 0 10px 10px;
+padding: 4px;
+width: 400px;
+border: 1px solid #CCCCCC;
+border-radius: 5px;
+background-color: #f6f6f6;
+font-size: 13px;
+line-height: 1.3;
+}
+#TOC .toctitle {
+font-weight: bold;
+font-size: 15px;
+margin-left: 5px;
+}
+#TOC ul {
+padding-left: 40px;
+margin-left: -1.5em;
+margin-top: 5px;
+margin-bottom: 5px;
+}
+#TOC ul ul {
+margin-left: -2em;
+}
+#TOC li {
+line-height: 16px;
+}
+table {
+margin: 1em auto;
+border-width: 1px;
+border-color: #DDDDDD;
+border-style: outset;
+border-collapse: collapse;
+}
+table th {
+border-width: 2px;
+padding: 5px;
+border-style: inset;
+}
+table td {
+border-width: 1px;
+border-style: inset;
+line-height: 18px;
+padding: 5px 5px;
+}
+table, table th, table td {
+border-left-style: none;
+border-right-style: none;
+}
+table thead, table tr.even {
+background-color: #f7f7f7;
+}
+p {
+margin: 0.5em 0;
+}
+blockquote {
+background-color: #f6f6f6;
+padding: 0.25em 0.75em;
+}
+hr {
+border-style: solid;
+border: none;
+border-top: 1px solid #777;
+margin: 28px 0;
+}
+dl {
+margin-left: 0;
+}
+dl dd {
+margin-bottom: 13px;
+margin-left: 13px;
+}
+dl dt {
+font-weight: bold;
+}
+ul {
+margin-top: 0;
+}
+ul li {
+list-style: circle outside;
+}
+ul ul {
+margin-bottom: 0;
+}
+pre, code {
+background-color: #f7f7f7;
+border-radius: 3px;
+color: #333;
+white-space: pre-wrap; 
+}
+pre {
+border-radius: 3px;
+margin: 5px 0px 10px 0px;
+padding: 10px;
+}
+pre:not([class]) {
+background-color: #f7f7f7;
+}
+code {
+font-family: Consolas, Monaco, 'Courier New', monospace;
+font-size: 85%;
+}
+p > code, li > code {
+padding: 2px 0px;
+}
+div.figure {
+text-align: center;
+}
+img {
+background-color: #FFFFFF;
+padding: 2px;
+border: 1px solid #DDDDDD;
+border-radius: 3px;
+border: 1px solid #CCCCCC;
+margin: 0 5px;
+}
+h1 {
+margin-top: 0;
+font-size: 35px;
+line-height: 40px;
+}
+h2 {
+border-bottom: 4px solid #f7f7f7;
+padding-top: 10px;
+padding-bottom: 2px;
+font-size: 145%;
+}
+h3 {
+border-bottom: 2px solid #f7f7f7;
+padding-top: 10px;
+font-size: 120%;
+}
+h4 {
+border-bottom: 1px solid #f7f7f7;
+margin-left: 8px;
+font-size: 105%;
+}
+h5, h6 {
+border-bottom: 1px solid #ccc;
+font-size: 105%;
+}
+a {
+color: #0033dd;
+text-decoration: none;
+}
+a:hover {
+color: #6666ff; }
+a:visited {
+color: #800080; }
+a:visited:hover {
+color: #BB00BB; }
+a[href^="http:"] {
+text-decoration: underline; }
+a[href^="https:"] {
+text-decoration: underline; }
+
+code > span.kw { color: #555; font-weight: bold; } 
+code > span.dt { color: #902000; } 
+code > span.dv { color: #40a070; } 
+code > span.bn { color: #d14; } 
+code > span.fl { color: #d14; } 
+code > span.ch { color: #d14; } 
+code > span.st { color: #d14; } 
+code > span.co { color: #888888; font-style: italic; } 
+code > span.ot { color: #007020; } 
+code > span.al { color: #ff0000; font-weight: bold; } 
+code > span.fu { color: #900; font-weight: bold; } 
+code > span.er { color: #a61717; background-color: #e3d2d2; } 
+</style>
+
+
+
+
+</head>
+
+<body>
+
+
+
+
+<h1 class="title toc-ignore">packrat vs. renv</h1>
+
+
+
+<div class="sourceCode" id="cb1"><pre class="sourceCode r"><code class="sourceCode r"><span id="cb1-1"><a href="#cb1-1" tabindex="-1"></a><span class="fu">library</span>(renv)</span></code></pre></div>
+<p>Our first attempt at solving the problem of reproducible environments
+was <a href="https://rstudio.github.io/packrat/">packrat</a>. While we
+learned a lot from packrat, it ultimately proved challenging to use in
+ways that were difficult to fix. This led us to create renv, a system
+with fewer surprises and better defaults. If you’re an existing packrat
+user, you can call <code>renv::migrate()</code> to switch renv, then
+read on to learn about the main differences:</p>
+<ol style="list-style-type: decimal">
+<li><p>The renv lockfile <code>renv.lock</code> is formatted as <a href="https://www.json.org/">JSON</a>. This should make the lockfile
+easier to use and consume with other tools.</p></li>
+<li><p>renv no longer attempts to explicitly download and track R
+package source tarballs within your project. This was a frustrating
+default that operated under the assumption that you might later want to
+be able to restore a project’s private library without access to a CRAN
+repository. In practice, this is almost never the case, and the time
+spent downloading + storing the package sources seemed to outweigh the
+potential reproducibility benefits.</p></li>
+<li><p>Packrat tried to maintain the distinction between so-called
+<em>stale</em> packages; that is, R packages which were installed by
+Packrat but were not recorded in the lockfile for some reason. This
+distinction was (1) overall not useful, and (2) confusing. renv no
+longer makes this distinction: <code>snapshot()</code> saves the state
+of your project library to <code>renv.lock</code>,
+<code>restore()</code> loads the state of your project library from
+<code>renv.lock</code>, and that’s all.</p></li>
+<li><p>In renv, the global package cache is enabled by default. This
+should reduce overall disk-space usage as packages can effectively be
+shared across each project using renv.</p></li>
+<li><p>renv’s dependency discovery machinery is more configurable. The
+function <code>renv::dependencies()</code> is exported, and users can
+create <code>.renvignore</code> files to instruct renv to ignore
+specific files and folders in their projects. (See
+<code>?renv::dependencies</code> for more information.)</p></li>
+</ol>
+
+
+
+<!-- code folding -->
+
+
+<!-- dynamically load mathjax for compatibility with self-contained -->
+<script>
+  (function () {
+    var script = document.createElement("script");
+    script.type = "text/javascript";
+    script.src  = "https://mathjax.rstudio.com/latest/MathJax.js?config=TeX-AMS-MML_HTMLorMML";
+    document.getElementsByTagName("head")[0].appendChild(script);
+  })();
+</script>
+
+</body>
+</html>

renv/library/windows/R-4.5/x86_64-w64-mingw32/renv/doc/profiles.R

@@ -0,0 +1,19 @@
+## ----include=FALSE------------------------------------------------------------
+knitr::opts_chunk$set(
+  collapse = TRUE,
+  comment = "#>",
+  eval = FALSE
+)
+
+## -----------------------------------------------------------------------------
+# renv::activate(profile = "dev")
+
+## -----------------------------------------------------------------------------
+# Sys.setenv(RENV_PROFILE = "dev")
+
+## -----------------------------------------------------------------------------
+# renv::activate(profile = "default")
+
+## -----------------------------------------------------------------------------
+# renv::settings$snapshot.type("explicit")
+

renv/library/windows/R-4.5/x86_64-w64-mingw32/renv/doc/profiles.Rmd

@@ -0,0 +1,115 @@
+---
+title: "Project profiles"
+output: rmarkdown::html_vignette
+vignette: >
+  %\VignetteIndexEntry{Project profiles}
+  %\VignetteEngine{knitr::rmarkdown}
+  %\VignetteEncoding{UTF-8}
+---
+
+```{r, include=FALSE}
+knitr::opts_chunk$set(
+  collapse = TRUE,
+  comment = "#>",
+  eval = FALSE
+)
+```
+
+
+## Introduction
+
+Starting with `renv 0.13.0`, it is possible to activate and switch between
+different profiles associated with a project. A profile can be thought of as
+a different mode in which a project is used. For example:
+
+- A "development" profile might be used when developing and testing a project,
+- A "production" profile might be used for production deployments,
+- A "shiny" profile might be used when running the Shiny application.
+
+At its heart, activating or using a particular profile implies using a different
+set of paths for the project library and lockfile. With this, it is possible
+to associate different packages, and different dependencies, with different
+workflows in a single project using renv.
+
+
+## Usage
+
+By default, renv projects use the "default" profile, which implies that
+library and lockfile paths are set in the typical way. To activate a particular
+profile, use:
+
+```{r}
+renv::activate(profile = "dev")
+```
+
+This creates a profile called `"dev"`, and sets it as the default for the
+project, so that newly-launched R sessions will operate using the `"dev"`
+profile. After setting this and re-launching R, you should see that the
+project library and lockfile paths are resolved within the `renv/profiles/dev`
+folder from the project root.
+
+Alternatively, if you want to activate a particular profile for an R session
+without setting it as the default for new R sessions, you can use:
+
+```{r}
+Sys.setenv(RENV_PROFILE = "dev")
+```
+
+and renv will automatically use that profile as appropriate when computing
+library and lockfile paths. Similarly, from the command line, you might
+enforce the use of a particular profile in an renv project with:
+
+```{sh}
+export RENV_PROFILE=dev
+```
+
+With that set, renv would default to using the `"dev"` profile for any
+newly-launched R sessions within renv projects.
+
+To activate the "default" profile used by a project, use:
+
+```{r}
+renv::activate(profile = "default")
+```
+
+
+## Managing profile-specific dependencies
+
+Profile-specific package dependencies can be declared within the project's
+top-level `DESCRIPTION` file. For example, to declare that the shiny
+profile depends on the [shiny] and [tidyverse] packages:
+
+```{sh}
+Config/renv/profiles/shiny/dependencies: shiny, tidyverse
+```
+
+If you'd like to also declare that these packages should be installed from
+a custom remote (analogous to the `Remotes` field for the default profile),
+you can define those remotes with a separate field:
+
+```{sh}
+Config/renv/profiles/shiny/remotes: rstudio/shiny, tidyverse/tidyverse
+```
+
+These remotes will then be respected in calls to `renv::install()`.
+
+The packages and remotes must be specified separately, as renv cannot
+determine the package name associated with a particular remote without
+explicitly resolving that remote. Remote resolution normally requires a web
+request, which renv tries to avoid in "regular" dependency discovery.
+
+If you'd prefer that only the packages enumerated in this field are used, you
+can opt-in to using `"explicit"` snapshots, and leave the `Imports`, `Depends`
+and `Suggests` fields blank:
+
+```{r}
+renv::settings$snapshot.type("explicit")
+```
+
+When set, only the dependencies listed in the project `DESCRIPTION` file will
+be used when the lockfile is generated. See `?renv::snapshot` for more details.
+
+
+
+[shiny]: https://shiny.posit.co/
+[tidyverse]: https://www.tidyverse.org/

renv/library/windows/R-4.5/x86_64-w64-mingw32/renv/doc/profiles.html

@@ -0,0 +1,434 @@
+<!DOCTYPE html>
+
+<html>
+
+<head>
+
+<meta charset="utf-8" />
+<meta name="generator" content="pandoc" />
+<meta http-equiv="X-UA-Compatible" content="IE=EDGE" />
+
+<meta name="viewport" content="width=device-width, initial-scale=1" />
+
+
+
+<title>Project profiles</title>
+
+<script>// Pandoc 2.9 adds attributes on both header and div. We remove the former (to
+// be compatible with the behavior of Pandoc < 2.8).
+document.addEventListener('DOMContentLoaded', function(e) {
+  var hs = document.querySelectorAll("div.section[class*='level'] > :first-child");
+  var i, h, a;
+  for (i = 0; i < hs.length; i++) {
+    h = hs[i];
+    if (!/^h[1-6]$/i.test(h.tagName)) continue;  // it should be a header h1-h6
+    a = h.attributes;
+    while (a.length > 0) h.removeAttribute(a[0].name);
+  }
+});
+</script>
+
+<style type="text/css">
+code{white-space: pre-wrap;}
+span.smallcaps{font-variant: small-caps;}
+span.underline{text-decoration: underline;}
+div.column{display: inline-block; vertical-align: top; width: 50%;}
+div.hanging-indent{margin-left: 1.5em; text-indent: -1.5em;}
+ul.task-list{list-style: none;}
+</style>
+
+
+
+<style type="text/css">
+code {
+white-space: pre;
+}
+.sourceCode {
+overflow: visible;
+}
+</style>
+<style type="text/css" data-origin="pandoc">
+html { -webkit-text-size-adjust: 100%; }
+pre > code.sourceCode { white-space: pre; position: relative; }
+pre > code.sourceCode > span { display: inline-block; line-height: 1.25; }
+pre > code.sourceCode > span:empty { height: 1.2em; }
+.sourceCode { overflow: visible; }
+code.sourceCode > span { color: inherit; text-decoration: inherit; }
+div.sourceCode { margin: 1em 0; }
+pre.sourceCode { margin: 0; }
+@media screen {
+div.sourceCode { overflow: auto; }
+}
+@media print {
+pre > code.sourceCode { white-space: pre-wrap; }
+pre > code.sourceCode > span { text-indent: -5em; padding-left: 5em; }
+}
+pre.numberSource code
+{ counter-reset: source-line 0; }
+pre.numberSource code > span
+{ position: relative; left: -4em; counter-increment: source-line; }
+pre.numberSource code > span > a:first-child::before
+{ content: counter(source-line);
+position: relative; left: -1em; text-align: right; vertical-align: baseline;
+border: none; display: inline-block;
+-webkit-touch-callout: none; -webkit-user-select: none;
+-khtml-user-select: none; -moz-user-select: none;
+-ms-user-select: none; user-select: none;
+padding: 0 4px; width: 4em;
+color: #aaaaaa;
+}
+pre.numberSource { margin-left: 3em; border-left: 1px solid #aaaaaa; padding-left: 4px; }
+div.sourceCode
+{ }
+@media screen {
+pre > code.sourceCode > span > a:first-child::before { text-decoration: underline; }
+}
+code span.al { color: #ff0000; font-weight: bold; } 
+code span.an { color: #60a0b0; font-weight: bold; font-style: italic; } 
+code span.at { color: #7d9029; } 
+code span.bn { color: #40a070; } 
+code span.bu { color: #008000; } 
+code span.cf { color: #007020; font-weight: bold; } 
+code span.ch { color: #4070a0; } 
+code span.cn { color: #880000; } 
+code span.co { color: #60a0b0; font-style: italic; } 
+code span.cv { color: #60a0b0; font-weight: bold; font-style: italic; } 
+code span.do { color: #ba2121; font-style: italic; } 
+code span.dt { color: #902000; } 
+code span.dv { color: #40a070; } 
+code span.er { color: #ff0000; font-weight: bold; } 
+code span.ex { } 
+code span.fl { color: #40a070; } 
+code span.fu { color: #06287e; } 
+code span.im { color: #008000; font-weight: bold; } 
+code span.in { color: #60a0b0; font-weight: bold; font-style: italic; } 
+code span.kw { color: #007020; font-weight: bold; } 
+code span.op { color: #666666; } 
+code span.ot { color: #007020; } 
+code span.pp { color: #bc7a00; } 
+code span.sc { color: #4070a0; } 
+code span.ss { color: #bb6688; } 
+code span.st { color: #4070a0; } 
+code span.va { color: #19177c; } 
+code span.vs { color: #4070a0; } 
+code span.wa { color: #60a0b0; font-weight: bold; font-style: italic; } 
+</style>
+<script>
+// apply pandoc div.sourceCode style to pre.sourceCode instead
+(function() {
+  var sheets = document.styleSheets;
+  for (var i = 0; i < sheets.length; i++) {
+    if (sheets[i].ownerNode.dataset["origin"] !== "pandoc") continue;
+    try { var rules = sheets[i].cssRules; } catch (e) { continue; }
+    var j = 0;
+    while (j < rules.length) {
+      var rule = rules[j];
+      // check if there is a div.sourceCode rule
+      if (rule.type !== rule.STYLE_RULE || rule.selectorText !== "div.sourceCode") {
+        j++;
+        continue;
+      }
+      var style = rule.style.cssText;
+      // check if color or background-color is set
+      if (rule.style.color === '' && rule.style.backgroundColor === '') {
+        j++;
+        continue;
+      }
+      // replace div.sourceCode by a pre.sourceCode rule
+      sheets[i].deleteRule(j);
+      sheets[i].insertRule('pre.sourceCode{' + style + '}', j);
+    }
+  }
+})();
+</script>
+
+
+
+
+<style type="text/css">body {
+background-color: #fff;
+margin: 1em auto;
+max-width: 700px;
+overflow: visible;
+padding-left: 2em;
+padding-right: 2em;
+font-family: "Open Sans", "Helvetica Neue", Helvetica, Arial, sans-serif;
+font-size: 14px;
+line-height: 1.35;
+}
+#TOC {
+clear: both;
+margin: 0 0 10px 10px;
+padding: 4px;
+width: 400px;
+border: 1px solid #CCCCCC;
+border-radius: 5px;
+background-color: #f6f6f6;
+font-size: 13px;
+line-height: 1.3;
+}
+#TOC .toctitle {
+font-weight: bold;
+font-size: 15px;
+margin-left: 5px;
+}
+#TOC ul {
+padding-left: 40px;
+margin-left: -1.5em;
+margin-top: 5px;
+margin-bottom: 5px;
+}
+#TOC ul ul {
+margin-left: -2em;
+}
+#TOC li {
+line-height: 16px;
+}
+table {
+margin: 1em auto;
+border-width: 1px;
+border-color: #DDDDDD;
+border-style: outset;
+border-collapse: collapse;
+}
+table th {
+border-width: 2px;
+padding: 5px;
+border-style: inset;
+}
+table td {
+border-width: 1px;
+border-style: inset;
+line-height: 18px;
+padding: 5px 5px;
+}
+table, table th, table td {
+border-left-style: none;
+border-right-style: none;
+}
+table thead, table tr.even {
+background-color: #f7f7f7;
+}
+p {
+margin: 0.5em 0;
+}
+blockquote {
+background-color: #f6f6f6;
+padding: 0.25em 0.75em;
+}
+hr {
+border-style: solid;
+border: none;
+border-top: 1px solid #777;
+margin: 28px 0;
+}
+dl {
+margin-left: 0;
+}
+dl dd {
+margin-bottom: 13px;
+margin-left: 13px;
+}
+dl dt {
+font-weight: bold;
+}
+ul {
+margin-top: 0;
+}
+ul li {
+list-style: circle outside;
+}
+ul ul {
+margin-bottom: 0;
+}
+pre, code {
+background-color: #f7f7f7;
+border-radius: 3px;
+color: #333;
+white-space: pre-wrap; 
+}
+pre {
+border-radius: 3px;
+margin: 5px 0px 10px 0px;
+padding: 10px;
+}
+pre:not([class]) {
+background-color: #f7f7f7;
+}
+code {
+font-family: Consolas, Monaco, 'Courier New', monospace;
+font-size: 85%;
+}
+p > code, li > code {
+padding: 2px 0px;
+}
+div.figure {
+text-align: center;
+}
+img {
+background-color: #FFFFFF;
+padding: 2px;
+border: 1px solid #DDDDDD;
+border-radius: 3px;
+border: 1px solid #CCCCCC;
+margin: 0 5px;
+}
+h1 {
+margin-top: 0;
+font-size: 35px;
+line-height: 40px;
+}
+h2 {
+border-bottom: 4px solid #f7f7f7;
+padding-top: 10px;
+padding-bottom: 2px;
+font-size: 145%;
+}
+h3 {
+border-bottom: 2px solid #f7f7f7;
+padding-top: 10px;
+font-size: 120%;
+}
+h4 {
+border-bottom: 1px solid #f7f7f7;
+margin-left: 8px;
+font-size: 105%;
+}
+h5, h6 {
+border-bottom: 1px solid #ccc;
+font-size: 105%;
+}
+a {
+color: #0033dd;
+text-decoration: none;
+}
+a:hover {
+color: #6666ff; }
+a:visited {
+color: #800080; }
+a:visited:hover {
+color: #BB00BB; }
+a[href^="http:"] {
+text-decoration: underline; }
+a[href^="https:"] {
+text-decoration: underline; }
+
+code > span.kw { color: #555; font-weight: bold; } 
+code > span.dt { color: #902000; } 
+code > span.dv { color: #40a070; } 
+code > span.bn { color: #d14; } 
+code > span.fl { color: #d14; } 
+code > span.ch { color: #d14; } 
+code > span.st { color: #d14; } 
+code > span.co { color: #888888; font-style: italic; } 
+code > span.ot { color: #007020; } 
+code > span.al { color: #ff0000; font-weight: bold; } 
+code > span.fu { color: #900; font-weight: bold; } 
+code > span.er { color: #a61717; background-color: #e3d2d2; } 
+</style>
+
+
+
+
+</head>
+
+<body>
+
+
+
+
+<h1 class="title toc-ignore">Project profiles</h1>
+
+
+
+<div id="introduction" class="section level2">
+<h2>Introduction</h2>
+<p>Starting with <code>renv 0.13.0</code>, it is possible to activate
+and switch between different profiles associated with a project. A
+profile can be thought of as a different mode in which a project is
+used. For example:</p>
+<ul>
+<li>A “development” profile might be used when developing and testing a
+project,</li>
+<li>A “production” profile might be used for production
+deployments,</li>
+<li>A “shiny” profile might be used when running the Shiny
+application.</li>
+</ul>
+<p>At its heart, activating or using a particular profile implies using
+a different set of paths for the project library and lockfile. With
+this, it is possible to associate different packages, and different
+dependencies, with different workflows in a single project using
+renv.</p>
+</div>
+<div id="usage" class="section level2">
+<h2>Usage</h2>
+<p>By default, renv projects use the “default” profile, which implies
+that library and lockfile paths are set in the typical way. To activate
+a particular profile, use:</p>
+<div class="sourceCode" id="cb1"><pre class="sourceCode r"><code class="sourceCode r"><span id="cb1-1"><a href="#cb1-1" tabindex="-1"></a>renv<span class="sc">::</span><span class="fu">activate</span>(<span class="at">profile =</span> <span class="st">&quot;dev&quot;</span>)</span></code></pre></div>
+<p>This creates a profile called <code>&quot;dev&quot;</code>, and sets it as the
+default for the project, so that newly-launched R sessions will operate
+using the <code>&quot;dev&quot;</code> profile. After setting this and
+re-launching R, you should see that the project library and lockfile
+paths are resolved within the <code>renv/profiles/dev</code> folder from
+the project root.</p>
+<p>Alternatively, if you want to activate a particular profile for an R
+session without setting it as the default for new R sessions, you can
+use:</p>
+<div class="sourceCode" id="cb2"><pre class="sourceCode r"><code class="sourceCode r"><span id="cb2-1"><a href="#cb2-1" tabindex="-1"></a><span class="fu">Sys.setenv</span>(<span class="at">RENV_PROFILE =</span> <span class="st">&quot;dev&quot;</span>)</span></code></pre></div>
+<p>and renv will automatically use that profile as appropriate when
+computing library and lockfile paths. Similarly, from the command line,
+you might enforce the use of a particular profile in an renv project
+with:</p>
+<div class="sourceCode" id="cb3"><pre class="sourceCode sh"><code class="sourceCode bash"><span id="cb3-1"><a href="#cb3-1" tabindex="-1"></a><span class="bu">export</span> <span class="va">RENV_PROFILE</span><span class="op">=</span>dev</span></code></pre></div>
+<p>With that set, renv would default to using the <code>&quot;dev&quot;</code>
+profile for any newly-launched R sessions within renv projects.</p>
+<p>To activate the “default” profile used by a project, use:</p>
+<div class="sourceCode" id="cb4"><pre class="sourceCode r"><code class="sourceCode r"><span id="cb4-1"><a href="#cb4-1" tabindex="-1"></a>renv<span class="sc">::</span><span class="fu">activate</span>(<span class="at">profile =</span> <span class="st">&quot;default&quot;</span>)</span></code></pre></div>
+</div>
+<div id="managing-profile-specific-dependencies" class="section level2">
+<h2>Managing profile-specific dependencies</h2>
+<p>Profile-specific package dependencies can be declared within the
+project’s top-level <code>DESCRIPTION</code> file. For example, to
+declare that the shiny profile depends on the <a href="https://shiny.posit.co/">shiny</a> and <a href="https://www.tidyverse.org/">tidyverse</a> packages:</p>
+<div class="sourceCode" id="cb5"><pre class="sourceCode sh"><code class="sourceCode bash"><span id="cb5-1"><a href="#cb5-1" tabindex="-1"></a><span class="ex">Config/renv/profiles/shiny/dependencies:</span> shiny, tidyverse</span></code></pre></div>
+<p>If you’d like to also declare that these packages should be installed
+from a custom remote (analogous to the <code>Remotes</code> field for
+the default profile), you can define those remotes with a separate
+field:</p>
+<div class="sourceCode" id="cb6"><pre class="sourceCode sh"><code class="sourceCode bash"><span id="cb6-1"><a href="#cb6-1" tabindex="-1"></a><span class="ex">Config/renv/profiles/shiny/remotes:</span> rstudio/shiny, tidyverse/tidyverse</span></code></pre></div>
+<p>These remotes will then be respected in calls to
+<code>renv::install()</code>.</p>
+<p>The packages and remotes must be specified separately, as renv cannot
+determine the package name associated with a particular remote without
+explicitly resolving that remote. Remote resolution normally requires a
+web request, which renv tries to avoid in “regular” dependency
+discovery.</p>
+<p>If you’d prefer that only the packages enumerated in this field are
+used, you can opt-in to using <code>&quot;explicit&quot;</code> snapshots, and
+leave the <code>Imports</code>, <code>Depends</code> and
+<code>Suggests</code> fields blank:</p>
+<div class="sourceCode" id="cb7"><pre class="sourceCode r"><code class="sourceCode r"><span id="cb7-1"><a href="#cb7-1" tabindex="-1"></a>renv<span class="sc">::</span>settings<span class="sc">$</span><span class="fu">snapshot.type</span>(<span class="st">&quot;explicit&quot;</span>)</span></code></pre></div>
+<p>When set, only the dependencies listed in the project
+<code>DESCRIPTION</code> file will be used when the lockfile is
+generated. See <code>?renv::snapshot</code> for more details.</p>
+</div>
+
+
+
+<!-- code folding -->
+
+
+<!-- dynamically load mathjax for compatibility with self-contained -->
+<script>
+  (function () {
+    var script = document.createElement("script");
+    script.type = "text/javascript";
+    script.src  = "https://mathjax.rstudio.com/latest/MathJax.js?config=TeX-AMS-MML_HTMLorMML";
+    document.getElementsByTagName("head")[0].appendChild(script);
+  })();
+</script>
+
+</body>
+</html>

renv/library/windows/R-4.5/x86_64-w64-mingw32/renv/doc/python.R

@@ -0,0 +1,7 @@
+## ----include=FALSE------------------------------------------------------------
+knitr::opts_chunk$set(
+  collapse = TRUE,
+  comment = "#>",
+  eval = FALSE
+)
+

renv/library/windows/R-4.5/x86_64-w64-mingw32/renv/doc/python.Rmd

@@ -0,0 +1,70 @@
+---
+title: "Using Python with renv"
+output: rmarkdown::html_vignette
+vignette: >
+  %\VignetteIndexEntry{Using Python with renv}
+  %\VignetteEngine{knitr::rmarkdown}
+  %\VignetteEncoding{UTF-8}
+---
+
+```{r, include=FALSE}
+knitr::opts_chunk$set(
+  collapse = TRUE,
+  comment = "#>",
+  eval = FALSE
+)
+```
+
+If you're using renv with an R project that also depends on some Python
+packages (say, through the [reticulate](https://rstudio.github.io/reticulate/)
+package), then you may find renv's Python integration useful.
+
+
+## Activating Python integration
+
+Python integration can be activated on a project-by-project basis. Use
+`renv::use_python()` to tell renv to create and use a project-local Python
+environment with your project. If the reticulate package is installed and
+active, then renv will use the same version of Python that reticulate
+normally would when generating the virtual environment. Alternatively, you can
+set the `RETICULATE_PYTHON` environment variable to instruct renv to use a
+different version of Python.
+
+If you'd rather tell renv to use an existing Python virtual environment, you
+can do so by passing the path of that virtual environment instead -- use
+`renv::use_python(python = "/path/to/python")` and renv will record and
+use that Python interpreter with your project. This can also be used with
+pre-existing virtual environments and Conda environments.
+
+
+## Understanding Python integration
+
+Once Python integration is active, renv will attempt to manage the state of
+your Python virtual environment when `snapshot()` / `restore()` is called. With
+this, projects that use renv and Python can ensure that Python dependencies
+are tracked in addition to R package dependencies. Note that future restores
+will require both `renv.lock` (for R package dependencies) and
+`requirements.txt` (for Python package dependencies).
+
+
+### Virtual environments
+
+When using virtual environments, the following extensions are provided:
+
+- `renv::snapshot()` calls `pip freeze > requirements.txt` to save the
+  set of installed Python packages;
+
+- `renv::restore()` calls `pip install -r requirements.txt` to install
+  the previously-recorded set of Python packages.
+
+
+### Conda environments
+
+When using Conda environments, the following extensions are provided:
+
+- `renv::snapshot()` calls `conda env export > environment.yml` to save the
+  set of installed Python packages;
+
+- `renv::restore()` calls `conda env [create/update] --file environment.yml` to
+  install the previously-recorded set of Python packages.
+

renv/library/windows/R-4.5/x86_64-w64-mingw32/renv/doc/python.html

@@ -0,0 +1,316 @@
+<!DOCTYPE html>
+
+<html>
+
+<head>
+
+<meta charset="utf-8" />
+<meta name="generator" content="pandoc" />
+<meta http-equiv="X-UA-Compatible" content="IE=EDGE" />
+
+<meta name="viewport" content="width=device-width, initial-scale=1" />
+
+
+
+<title>Using Python with renv</title>
+
+<script>// Pandoc 2.9 adds attributes on both header and div. We remove the former (to
+// be compatible with the behavior of Pandoc < 2.8).
+document.addEventListener('DOMContentLoaded', function(e) {
+  var hs = document.querySelectorAll("div.section[class*='level'] > :first-child");
+  var i, h, a;
+  for (i = 0; i < hs.length; i++) {
+    h = hs[i];
+    if (!/^h[1-6]$/i.test(h.tagName)) continue;  // it should be a header h1-h6
+    a = h.attributes;
+    while (a.length > 0) h.removeAttribute(a[0].name);
+  }
+});
+</script>
+
+<style type="text/css">
+code{white-space: pre-wrap;}
+span.smallcaps{font-variant: small-caps;}
+span.underline{text-decoration: underline;}
+div.column{display: inline-block; vertical-align: top; width: 50%;}
+div.hanging-indent{margin-left: 1.5em; text-indent: -1.5em;}
+ul.task-list{list-style: none;}
+</style>
+
+
+
+
+
+
+
+<style type="text/css">body {
+background-color: #fff;
+margin: 1em auto;
+max-width: 700px;
+overflow: visible;
+padding-left: 2em;
+padding-right: 2em;
+font-family: "Open Sans", "Helvetica Neue", Helvetica, Arial, sans-serif;
+font-size: 14px;
+line-height: 1.35;
+}
+#TOC {
+clear: both;
+margin: 0 0 10px 10px;
+padding: 4px;
+width: 400px;
+border: 1px solid #CCCCCC;
+border-radius: 5px;
+background-color: #f6f6f6;
+font-size: 13px;
+line-height: 1.3;
+}
+#TOC .toctitle {
+font-weight: bold;
+font-size: 15px;
+margin-left: 5px;
+}
+#TOC ul {
+padding-left: 40px;
+margin-left: -1.5em;
+margin-top: 5px;
+margin-bottom: 5px;
+}
+#TOC ul ul {
+margin-left: -2em;
+}
+#TOC li {
+line-height: 16px;
+}
+table {
+margin: 1em auto;
+border-width: 1px;
+border-color: #DDDDDD;
+border-style: outset;
+border-collapse: collapse;
+}
+table th {
+border-width: 2px;
+padding: 5px;
+border-style: inset;
+}
+table td {
+border-width: 1px;
+border-style: inset;
+line-height: 18px;
+padding: 5px 5px;
+}
+table, table th, table td {
+border-left-style: none;
+border-right-style: none;
+}
+table thead, table tr.even {
+background-color: #f7f7f7;
+}
+p {
+margin: 0.5em 0;
+}
+blockquote {
+background-color: #f6f6f6;
+padding: 0.25em 0.75em;
+}
+hr {
+border-style: solid;
+border: none;
+border-top: 1px solid #777;
+margin: 28px 0;
+}
+dl {
+margin-left: 0;
+}
+dl dd {
+margin-bottom: 13px;
+margin-left: 13px;
+}
+dl dt {
+font-weight: bold;
+}
+ul {
+margin-top: 0;
+}
+ul li {
+list-style: circle outside;
+}
+ul ul {
+margin-bottom: 0;
+}
+pre, code {
+background-color: #f7f7f7;
+border-radius: 3px;
+color: #333;
+white-space: pre-wrap; 
+}
+pre {
+border-radius: 3px;
+margin: 5px 0px 10px 0px;
+padding: 10px;
+}
+pre:not([class]) {
+background-color: #f7f7f7;
+}
+code {
+font-family: Consolas, Monaco, 'Courier New', monospace;
+font-size: 85%;
+}
+p > code, li > code {
+padding: 2px 0px;
+}
+div.figure {
+text-align: center;
+}
+img {
+background-color: #FFFFFF;
+padding: 2px;
+border: 1px solid #DDDDDD;
+border-radius: 3px;
+border: 1px solid #CCCCCC;
+margin: 0 5px;
+}
+h1 {
+margin-top: 0;
+font-size: 35px;
+line-height: 40px;
+}
+h2 {
+border-bottom: 4px solid #f7f7f7;
+padding-top: 10px;
+padding-bottom: 2px;
+font-size: 145%;
+}
+h3 {
+border-bottom: 2px solid #f7f7f7;
+padding-top: 10px;
+font-size: 120%;
+}
+h4 {
+border-bottom: 1px solid #f7f7f7;
+margin-left: 8px;
+font-size: 105%;
+}
+h5, h6 {
+border-bottom: 1px solid #ccc;
+font-size: 105%;
+}
+a {
+color: #0033dd;
+text-decoration: none;
+}
+a:hover {
+color: #6666ff; }
+a:visited {
+color: #800080; }
+a:visited:hover {
+color: #BB00BB; }
+a[href^="http:"] {
+text-decoration: underline; }
+a[href^="https:"] {
+text-decoration: underline; }
+
+code > span.kw { color: #555; font-weight: bold; } 
+code > span.dt { color: #902000; } 
+code > span.dv { color: #40a070; } 
+code > span.bn { color: #d14; } 
+code > span.fl { color: #d14; } 
+code > span.ch { color: #d14; } 
+code > span.st { color: #d14; } 
+code > span.co { color: #888888; font-style: italic; } 
+code > span.ot { color: #007020; } 
+code > span.al { color: #ff0000; font-weight: bold; } 
+code > span.fu { color: #900; font-weight: bold; } 
+code > span.er { color: #a61717; background-color: #e3d2d2; } 
+</style>
+
+
+
+
+</head>
+
+<body>
+
+
+
+
+<h1 class="title toc-ignore">Using Python with renv</h1>
+
+
+
+<p>If you’re using renv with an R project that also depends on some
+Python packages (say, through the <a href="https://rstudio.github.io/reticulate/">reticulate</a> package),
+then you may find renv’s Python integration useful.</p>
+<div id="activating-python-integration" class="section level2">
+<h2>Activating Python integration</h2>
+<p>Python integration can be activated on a project-by-project basis.
+Use <code>renv::use_python()</code> to tell renv to create and use a
+project-local Python environment with your project. If the reticulate
+package is installed and active, then renv will use the same version of
+Python that reticulate normally would when generating the virtual
+environment. Alternatively, you can set the
+<code>RETICULATE_PYTHON</code> environment variable to instruct renv to
+use a different version of Python.</p>
+<p>If you’d rather tell renv to use an existing Python virtual
+environment, you can do so by passing the path of that virtual
+environment instead – use
+<code>renv::use_python(python = &quot;/path/to/python&quot;)</code> and renv will
+record and use that Python interpreter with your project. This can also
+be used with pre-existing virtual environments and Conda
+environments.</p>
+</div>
+<div id="understanding-python-integration" class="section level2">
+<h2>Understanding Python integration</h2>
+<p>Once Python integration is active, renv will attempt to manage the
+state of your Python virtual environment when <code>snapshot()</code> /
+<code>restore()</code> is called. With this, projects that use renv and
+Python can ensure that Python dependencies are tracked in addition to R
+package dependencies. Note that future restores will require both
+<code>renv.lock</code> (for R package dependencies) and
+<code>requirements.txt</code> (for Python package dependencies).</p>
+<div id="virtual-environments" class="section level3">
+<h3>Virtual environments</h3>
+<p>When using virtual environments, the following extensions are
+provided:</p>
+<ul>
+<li><p><code>renv::snapshot()</code> calls
+<code>pip freeze &gt; requirements.txt</code> to save the set of
+installed Python packages;</p></li>
+<li><p><code>renv::restore()</code> calls
+<code>pip install -r requirements.txt</code> to install the
+previously-recorded set of Python packages.</p></li>
+</ul>
+</div>
+<div id="conda-environments" class="section level3">
+<h3>Conda environments</h3>
+<p>When using Conda environments, the following extensions are
+provided:</p>
+<ul>
+<li><p><code>renv::snapshot()</code> calls
+<code>conda env export &gt; environment.yml</code> to save the set of
+installed Python packages;</p></li>
+<li><p><code>renv::restore()</code> calls
+<code>conda env [create/update] --file environment.yml</code> to install
+the previously-recorded set of Python packages.</p></li>
+</ul>
+</div>
+</div>
+
+
+
+<!-- code folding -->
+
+
+<!-- dynamically load mathjax for compatibility with self-contained -->
+<script>
+  (function () {
+    var script = document.createElement("script");
+    script.type = "text/javascript";
+    script.src  = "https://mathjax.rstudio.com/latest/MathJax.js?config=TeX-AMS-MML_HTMLorMML";
+    document.getElementsByTagName("head")[0].appendChild(script);
+  })();
+</script>
+
+</body>
+</html>