R/package-cache.R

Defines functions package_metadata_startup_members_write package_metadata_startup_members_read package_metadata_startup_members_valid package_metadata_startup_members_unpack package_metadata_startup_members_snapshots_valid package_metadata_target_packages package_metadata_startup_s3_write package_metadata_startup_s3_read package_metadata_startup_s3_complete package_metadata_startup_members_identities_valid package_metadata_startup_s3_identities_valid package_metadata_bundle_key_matches_manifest package_metadata_identities_match_manifest package_metadata_context_matches_manifest package_metadata_identity_matches_manifest package_metadata_manifest_valid package_metadata_file_info_stamp package_metadata_watch_paths package_metadata_startup_identity package_metadata_missing_absent package_metadata_rdb_scan package_metadata_rdb_scan_headers package_metadata_rdb_decode package_metadata_lazyload_files package_metadata_runtime_stable package_metadata_rdx_has_hooks package_metadata_transitive_packages package_metadata_delayed_s3_packages package_metadata_startup_lib_paths package_metadata_context package_metadata_cache_write package_metadata_cache_read package_metadata_cache_path package_metadata_cache_allowed package_metadata_cache_directory package_metadata_cache_root package_metadata_server_syntax package_metadata_server_constant package_metadata_server_loaded package_metadata_help_identity package_metadata_live_identity package_metadata_namespace_state package_metadata_namespace_record package_metadata_validation_record package_metadata_signature package_metadata_identity package_metadata_normalize_path package_metadata_sort package_metadata_file_checksum

# Shared storage for immutable package metadata. Providers choose their type,
# identity/context, and validator; live functions and document state stay local.
# Content hashes are computed on first use and after filesystem changes. The
# change time and file identity detect replacements preserving size and mtime;
# access time is excluded because reading a database must not invalidate it.
package_metadata_file_checksum <- function(files) unname(tools::md5sum(files))

package_metadata_sort <- function(x) {
    if (length(x)) sort(as.character(x), method = "radix") else character()
}

package_metadata_file_fingerprint <- local({
    cache <- NULL
    function(files) {
        if (is.null(cache)) cache <<- ByteLruCache$new(4 * 1024^2, 4096L)
        files <- package_metadata_sort(unique(files))
        info <- fs::file_info(files, fail = FALSE)
        stamp <- list(files, as.numeric(info$size), info$type, as.numeric(info$modification_time),
            as.numeric(info$change_time), info$device_id, info$inode)
        key <- digest::digest(files, algo = "xxhash64")
        previous <- cache$get(key)
        if (!is.null(previous) && identical(previous$stamp, stamp)) return(previous$value)
        hashes <- package_metadata_file_checksum(files)
        if (any(is.na(hashes) & !is.na(info$size) & info$type != "directory")) stop("Cannot fingerprint package metadata files")
        value <- digest::digest(list(files, hashes), algo = "xxhash64")
        cache$set(key, list(stamp = stamp, value = value))
        value
    }
})

package_metadata_normalize_path <- function(path) {
    if (!is.character(path) || length(path) != 1L || is.na(path) || !nzchar(path)) {
        return("")
    }
    normalizePath(path, winslash = "/", mustWork = FALSE)
}

package_metadata_version <- local({
    cache <- NULL
    function(package, path, lib_paths, files_fp) {
        if (is.null(cache)) cache <<- ByteLruCache$new(1024^2, 2048L)
        key <- paste0(path, "\n", files_fp)
        cached <- cache$get(key)
        if (!is.null(cached)) return(cached)
        ver <- as.character(utils::packageVersion(package, lib.loc = lib_paths))
        cache$set(key, ver)
        ver
    }
})

package_metadata_identity <- function(package, lib_paths = .libPaths(), context = NULL) {
    path <- package_metadata_normalize_path(find.package(package, lib.loc = lib_paths))
    pkg_rds <- file.path(path, "Meta", "package.rds")
    files <- c(file.path(path, c("DESCRIPTION", "NAMESPACE")),
        if (file.exists(pkg_rds)) pkg_rds,
        unlist(lapply(c("R", "data", "help"), function(directory) {
            list.files(file.path(path, directory), pattern = "\\.(rdb|rdx|rds)$", full.names = TRUE)
        }), use.names = FALSE), list.files(file.path(path, "libs"), full.names = TRUE, recursive = TRUE))
    files_fp <- package_metadata_file_fingerprint(files)
    list(package = package, path = path,
        version = package_metadata_version(package, path, lib_paths, files_fp), r = as.character(getRversion()),
        files = files_fp, context = context)
}

package_metadata_function_signature <- local({
    cache <- NULL
    previous <- NULL
    function(fn) {
        context <- list(syntax = member_function_syntax, formatter = deparse1,
            options = lapply(c("digits", "scipen", "deparse.cutoff"), getOption))
        if (is.null(cache) || !identical(context, previous)) {
            cache <<- ByteLruCache$new(64 * 1024^2, 4096L)
            previous <<- context
        }
        key <- .Call("member_function_key_c", fn, PACKAGE = "languageserver")
        record <- cache$get(key)
        arguments <- formals(fn)
        code <- body(fn)
        if (!is.null(record) && identical(record$arguments, arguments) && identical(record$code, code)) return(record$value)
        value <- deparse1(member_function_syntax(fn))
        # Keep syntax, rather than closure environments. Compare it on hits
        # even if an evicted/deleted function's address has been reused.
        cache$set(key, list(arguments = arguments, code = code, value = value))
        value
    }
})

package_metadata_signature <- function(value) {
    if (typeof(value) == "closure") return(package_metadata_function_signature(value))
    if (is.call(value) || is.expression(value) || is.pairlist(value)) return(deparse1(value))
    if (is.list(value)) return(lapply(value, package_metadata_signature))
    value
}

package_metadata_validation_record <- function(token, name) package_metadata_signature(token)

# Worker-local validation tokens may contain live function references. Inspect
# mutable bindings on every pass, but normalize only changed facts. Nothing in
# this memo is written to disk or used to execute package/document methods.
package_metadata_validation_records <- local({
    cache <- NULL
    function(key, tokens, context, normalize = package_metadata_validation_record) {
        if (is.null(cache)) cache <<- ByteLruCache$new(32 * 1024^2, 64L)
        if (is.null(tokens)) {
            cache$remove(key)
            return(NULL)
        }
        context <- list(inputs = context, normalize = normalize, signature = package_metadata_signature)
        previous <- cache$get(key)
        if (!identical(previous$context, context)) previous <- NULL
        if (!is.null(previous) && identical(previous$tokens, tokens)) return(previous$records)
        records <- stats::setNames(lapply(names(tokens), function(name) {
            token <- tokens[[name]]
            if (!is.null(previous$records[[name]]) && identical(previous$tokens[[name]], token)) return(previous$records[[name]])
            normalize(token, name)
        }), names(tokens))
        cache$set(key, list(context = context, tokens = tokens, records = records))
        records
    }
})

package_metadata_namespace_record <- function(token, name) {
    list(name = name, kind = token$kind,
        value = digest::digest(package_metadata_signature(token$value), algo = "xxhash64"))
}

package_metadata_namespace_state <- function(ns, package = unname(getNamespaceName(ns))) {
    # Cache keys must describe the loaded values too: .onLoad(), tracing and
    # package reinstalls can change them without changing an export's name.
    dollar_context <- member_snapshot_dollar_context(ns)
    modes <- member_s7_capabilities()
    materialize <- isNamespace(ns)
    binding_names <- package_metadata_sort(ls(ns, all.names = TRUE, sorted = FALSE))
    tokens <- stats::setNames(lapply(binding_names, function(name) {
        record <- member_binding(ns, name, materialize = materialize)
        value <- record[[2L]]
        snapshot <- if (identical(record[[1L]], "value") && !is.object(value) &&
                is.atomic(value) && length(value) <= 256L) {
            value
        } else {
            member_snapshot(value, max_bindings = 50000L, s7_modes = modes, lookup_scope = ns,
                dollar_context = dollar_context, function_syntax = package_metadata_function_signature)
        }
        list(kind = record[[1L]], value = snapshot)
    }), binding_names)
    records <- package_metadata_validation_records(paste0(package, ":members"), tokens,
        list(namespace = ns, snapshot = member_snapshot), package_metadata_namespace_record)
    has_hooks <- any(c(".onLoad", ".onAttach", ".First.lib", ".Last.lib") %in% binding_names)
    lazy_records <- NULL
    if (materialize && has_hooks) {
        lazydata <- member_namespace_lazydata(ns)
        if (is.environment(lazydata)) {
            lazy_names <- package_metadata_sort(ls(lazydata, all.names = TRUE, sorted = FALSE))
            if (length(lazy_names)) {
                lazy_tokens <- stats::setNames(lapply(lazy_names, function(name) {
                    record <- member_binding(lazydata, name, materialize = TRUE)
                    value <- record[[2L]]
                    snapshot <- if (identical(record[[1L]], "value") && !is.object(value) &&
                            is.atomic(value) && length(value) <= 256L) {
                        value
                    } else {
                        member_snapshot(value, max_bindings = 50000L, s7_modes = modes, lookup_scope = ns,
                            dollar_context = dollar_context, function_syntax = package_metadata_function_signature)
                    }
                    list(kind = record[[1L]], value = snapshot)
                }), lazy_names)
                lazy_records <- unname(package_metadata_validation_records(
                    paste0(package, ":lazydata"), lazy_tokens,
                    list(namespace = lazydata, snapshot = member_snapshot), package_metadata_namespace_record))
            }
        }
    }
    state <- if (is.null(lazy_records)) {
        list(bindings = unname(records), subsets = member_subset_registry(ns, package))
    } else {
        list(bindings = unname(records), lazydata = lazy_records, subsets = member_subset_registry(ns, package))
    }
    digest::digest(state, algo = "xxhash64")
}

package_metadata_live_identity <- function(package, lib_paths = .libPaths(), context = NULL) {
    identity <- package_metadata_identity(package, lib_paths, context)
    identity$namespace <- package_metadata_namespace_state(asNamespace(package))
    identity$bindings <- s3_metadata_context(package)
    identity$cacheable <- !is.null(identity$bindings)
    identity
}

# Help can come from a library other than the first installed/loaded namespace.
# Track the database actually read, without hashing unrelated native binaries
# on every documentation request.
package_metadata_help_identity <- function(hfile, package = NULL) {
    paths <- as.character(hfile)
    if (!length(paths)) {
        if (is.null(package)) return(NULL)
        paths <- file.path(find.package(package), "help", ".missing-topic")
    }
    roots <- unique(dirname(dirname(paths)))
    files <- unlist(lapply(roots, function(root) {
        c(file.path(root, c("DESCRIPTION", "Meta/Rd.rds", "help/AnIndex")),
            list.files(file.path(root, "help"), pattern = "\\.(rdb|rdx|rds)$", full.names = TRUE))
    }), use.names = FALSE)
    list(package = basename(roots[[1L]]), path = roots, r = as.character(getRversion()),
        files = package_metadata_file_fingerprint(files))
}

# R caches lazy-load database bytes by filename and offers no public flush API.
# Read an immutable copy under its content fingerprint so replacing the actual
# database cannot reuse R's old bytes. Copies are made only on a documentation
# miss, reused for other topics, and removed with the session temporary folder.
package_metadata_help_file <- local({
    cache <- NULL
    function(hfile) {
        identity <- package_metadata_help_identity(hfile)
        paths <- as.character(hfile)
        if (is.null(identity)) return(hfile)
        if (is.null(cache)) cache <<- ByteLruCache$new(package_metadata_cache_max_bytes, 128L)
        root <- file.path(tempdir(), "languageserver-help", identity$files)
        copies <- vapply(paths, function(path) {
            package <- basename(dirname(dirname(path)))
            directory <- file.path(root, package, "help")
            database <- file.path(dirname(path), paste0(package, c(".rdb", ".rdx")))
            targets <- file.path(directory, basename(database))
            if (!all(file.exists(targets))) {
                dir.create(directory, recursive = TRUE, showWarnings = FALSE)
                if (!all(file.copy(database, targets, overwrite = TRUE))) stop("Cannot copy help database")
            }
            file.path(directory, basename(path))
        }, character(1L), USE.NAMES = FALSE)
        if (!cache$has(root)) {
            size <- sum(file.info(list.files(root, full.names = TRUE, recursive = TRUE))$size)
            before <- cache$keys()
            cache$set(root, root, additional_bytes = size)
            if (!cache$has(root)) {
                unlink(root, recursive = TRUE)
                stop("Help database exceeds cache budget")
            }
            for (expired in setdiff(before, cache$keys())) unlink(expired, recursive = TRUE)
        } else {
            cache$get(root)
        }
        attributes(copies) <- attributes(hfile)
        copies
    }
})

package_metadata_help_context <- local({
    previous <- NULL
    key <- NULL
    function() {
        context <- list(locale = Sys.getlocale(),
            options = lapply(c("width", "useFancyQuotes", "help.htmlmath", "help.option"), getOption),
            renderer = list(get_help_rd, tools::Rd2txt, tools::Rd2HTML))
        if (!identical(previous, context)) {
            previous <<- context
            key <<- digest::digest(context, algo = "xxhash64")
        }
        key
    }
})

package_metadata_cache_format <- 3L
package_metadata_cache_max_bytes <- 256 * 1024^2

package_metadata_server_load_state <- new.env(parent = emptyenv())

package_metadata_server_loaded <- function() {
    ns <- asNamespace("languageserver")
    path <- getNamespaceInfo(ns, "path")
    dll <- getLoadedDLLs()[["languageserver"]][["path"]]
    files <- c(package_metadata_sort(list.files(file.path(path, "R"), full.names = TRUE)), dll)
    package_metadata_server_load_state$namespace <- ns
    package_metadata_server_load_state$files <- unname(tools::md5sum(files))
}

package_metadata_server_constant <- function(value, depth = 0L) {
    if (depth > 12L || is.object(value)) return(FALSE)
    if (is.atomic(value) || is.null(value)) return(length(value) <= 10000L)
    if (typeof(value) == "closure") return(TRUE)
    if (is.call(value) || is.expression(value) || is.pairlist(value)) return(TRUE)
    is.list(value) && all(vapply(value, package_metadata_server_constant, logical(1L), depth + 1L))
}

package_metadata_server_syntax <- function(value) {
    if (typeof(value) == "closure") return(package_metadata_function_signature(value))
    if (is.call(value) || is.expression(value) || is.pairlist(value)) return(deparse1(value))
    if (is.list(value)) return(lapply(value, package_metadata_server_syntax))
    value
}

package_metadata_cache_root <- function() {
    value <- getOption("languageserver.package_cache_dir")
    if (is.null(value)) {
        value <- Sys.getenv(
            "R_LANGSVR_PACKAGE_CACHE_DIR",
            tools::R_user_dir("languageserver", "cache")
        )
        if (tolower(trimws(value)) == "false") return(FALSE)
    }
    if (!is.character(value) || length(value) != 1L || is.na(value) || !nzchar(value)) return(FALSE)
    value
}

package_metadata_cache_directory <- function() {
    value <- package_metadata_cache_root()
    if (identical(value, FALSE)) NULL else file.path(value, "package-metadata")
}

package_metadata_cache_allowed <- function(identity) {
    is.list(identity) && !identical(identity$cacheable, FALSE) &&
        !(is.list(identity$context) && identical(identity$context$cacheable, FALSE))
}

package_metadata_cache_server <- local({
    identity <- NULL
    previous <- NULL
    function() {
        ns <- asNamespace("languageserver")
        if (!identical(package_metadata_server_load_state$namespace, ns)) package_metadata_server_loaded()
        nms <- package_metadata_sort(ls(ns, all.names = TRUE, sorted = FALSE))
        nms <- nms[nms != ".packageName"]
        out_vals <- vector("list", length(nms))
        names(out_vals) <- nms
        keep <- logical(length(nms))
        for (i in seq_along(nms)) {
            record <- member_binding(ns, nms[[i]], materialize = TRUE)
            value <- record[[2L]]
            if (typeof(value) == "closure") {
                out_vals[[i]] <- value
                keep[[i]] <- TRUE
            } else if (is.environment(value) && "R6ClassGenerator" %in% attr(value, "class", exact = TRUE)) {
                out_vals[[i]] <- list(public = value$public_methods, private = value$private_methods, active = value$active)
                keep[[i]] <- TRUE
            } else if (package_metadata_server_constant(value)) {
                out_vals[[i]] <- value
                keep[[i]] <- TRUE
            }
        }
        values <- out_vals[keep]
        state <- list(namespace = ns, values = values, files = package_metadata_server_load_state$files)
        if (!is.null(identity) && identical(state, previous)) return(identity)
        previous <<- state
        identity <<- list(version = getNamespaceInfo(ns, "spec")[["version"]],
            implementation = digest::digest(lapply(values, package_metadata_server_syntax), algo = "xxhash64"),
            loaded_files = package_metadata_server_load_state$files)
        identity
    }
})

package_metadata_cache_path <- function(type, identity, key = NULL) {
    directory <- package_metadata_cache_directory()
    if (is.null(directory)) return(NULL)
    if (!package_metadata_cache_allowed(identity)) return(NULL)
    hash <- digest::digest(list(format = package_metadata_cache_format, type = type, key = key, identity = identity,
            server = package_metadata_cache_server()), algo = "xxhash64")
    file.path(directory, paste0(identity$package, "-", type, "-", hash, ".rds"))
}

package_metadata_cache_read <- function(path, identity, validate = is.list) {
    if (identical(package_metadata_cache_root(), FALSE) || !package_metadata_cache_allowed(identity) ||
            is.null(path) || !file.exists(path)) return(NULL)
    tryCatch({
        size <- file.info(path)$size
        if (is.na(size) || size > package_metadata_cache_max_bytes) return(NULL)
        record <- readRDS(path)
        if (!is.list(record) || is.object(record) || !identical(record$format, package_metadata_cache_format) ||
                !identical(record$server, package_metadata_cache_server()) ||
                !identical(record$identity, identity) ||
                !is.raw(record$payload) || length(record$payload) > package_metadata_cache_max_bytes ||
                !identical(record$checksum, digest::digest(record$payload, algo = "xxhash64", serialize = FALSE))) return(NULL)
        value <- unserialize(record$payload)
        if (!isTRUE(validate(value))) return(NULL)
        suppressWarnings(Sys.setFileTime(path, Sys.time()))
        value
    }, error = function(e) NULL)
}

package_metadata_cache_write <- function(path, identity, value) {
    if (identical(package_metadata_cache_root(), FALSE) || !package_metadata_cache_allowed(identity) ||
            is.null(path)) return(invisible(NULL))
    if (as.numeric(utils::object.size(value)) > package_metadata_cache_max_bytes) return(invisible(NULL))
    temporary <- NULL
    on.exit(if (!is.null(temporary)) unlink(temporary), add = TRUE)
    tryCatch(suppressWarnings({
        directory <- dirname(path)
        dir.create(directory, recursive = TRUE, showWarnings = FALSE)
        temporary <- tempfile("metadata-", tmpdir = directory)
        payload <- serialize(value, NULL)
        if (length(payload) > package_metadata_cache_max_bytes) return(invisible(NULL))
        saveRDS(list(format = package_metadata_cache_format, server = package_metadata_cache_server(), identity = identity,
                checksum = digest::digest(payload, algo = "xxhash64", serialize = FALSE), payload = payload), temporary)
        if (!file.rename(temporary, path)) {
            # Windows cannot replace an existing cache file with file.rename.
            # A racing reader can safely miss the cache and prepare its model.
            unlink(path)
            if (!file.rename(temporary, path)) return(invisible(NULL))
        }
        files <- list.files(directory, pattern = "\\.rds$", full.names = TRUE)
        info <- file.info(files)
        order <- order(info$mtime, decreasing = TRUE, na.last = TRUE)
        sizes <- info$size[order]
        sizes[is.na(sizes)] <- 0
        expired <- order[seq_along(order) > 512L | cumsum(sizes) > package_metadata_cache_max_bytes]
        if (length(expired)) unlink(files[expired])
    }), error = function(e) NULL)
    invisible(NULL)
}

package_metadata_context <- function(packages, lib_paths = .libPaths()) {
    lib_paths <- package_metadata_startup_lib_paths(lib_paths)
    traversal <- package_metadata_transitive_packages(packages, lib_paths)
    identity_packages <- if (isTRUE(traversal$complete)) {
        unique(c(packages, traversal$packages))
    } else {
        packages
    }
    identities <- lapply(identity_packages, function(package) {
        tryCatch(package_metadata_startup_identity(package, lib_paths = lib_paths),
            error = function(e) list(package = package, error = conditionMessage(e)))
    })
    bindings <- s3_metadata_context(packages)
    list(packages = identities, bindings = bindings,
        cacheable = !is.null(bindings) && !any(vapply(identities, function(identity) !is.null(identity$error), logical(1L))))
}

package_metadata_startup_lib_paths <- function(lib_paths = .libPaths()) {
    unique(normalizePath(c(lib_paths, .Library.site, .Library),
            winslash = "/", mustWork = FALSE))
}

package_metadata_dcf_packages <- local({
    cache <- NULL
    function(desc_file, fields = c("Depends", "Imports")) {
        if (!file.exists(desc_file)) {
            return(structure(character(), complete = FALSE))
        }
        if (is.null(cache)) cache <<- ByteLruCache$new(1024^2, 2048L)
        fp <- tryCatch(package_metadata_file_fingerprint(desc_file), error = function(e) NULL)
        key <- if (!is.null(fp)) paste(c(fp, fields), collapse = "\n")
        if (!is.null(key)) {
            cached <- cache$get(key)
            if (!is.null(cached)) return(cached)
        }
        dcf <- tryCatch(read.dcf(desc_file, fields = unique(c("Package", fields))), error = function(e) NULL)
        if (!is.matrix(dcf) || nrow(dcf) < 1L || !("Package" %in% colnames(dcf)) ||
                is.na(dcf[1L, "Package"]) || !nzchar(trimws(dcf[1L, "Package"]))) {
            return(structure(character(), complete = FALSE))
        }
        keep_fields <- intersect(fields, colnames(dcf))
        values <- if (length(keep_fields)) as.character(dcf[1L, keep_fields]) else character()
        values <- values[!is.na(values) & nzchar(values)]
        res <- if (!length(values)) {
            character()
        } else {
            entries <- trimws(unlist(strsplit(values, ",", fixed = TRUE), use.names = FALSE))
            entries <- trimws(sub("\\s*\\([\\s\\S]*\\)$", "", entries, perl = TRUE))
            setdiff(entries[nzchar(entries)], "R")
        }
        if (!is.null(key)) cache$set(key, res)
        res
    }
})

package_metadata_namespace_imports <- local({
    cache <- NULL
    function(path) {
        if (is.null(cache)) cache <<- ByteLruCache$new(1024^2, 2048L)
        ns_info_file <- file.path(path, "Meta", "nsInfo.rds")
        ns_file <- file.path(path, "NAMESPACE")
        candidates <- c(ns_info_file, ns_file)
        present <- file.exists(candidates)
        fp <- if (any(present)) {
            tryCatch(package_metadata_file_fingerprint(candidates[present]), error = function(e) NULL)
        } else {
            ""
        }
        key <- if (!is.null(fp)) paste(c(path, as.character(present), fp), collapse = "\n")
        if (!is.null(key)) {
            cached <- cache$get(key)
            if (!is.null(cached)) return(cached)
        }
        pkgs <- character()
        if (present[[1L]]) {
            ns_info <- tryCatch(readRDS(ns_info_file), error = function(e) NULL)
            if (is.list(ns_info)) {
                imp_pkgs <- unlist(lapply(ns_info$imports, function(entry) {
                    if (is.character(entry)) {
                        entry
                    } else if (is.list(entry) && length(entry)) {
                        as.character(entry[[1L]])
                    } else {
                        character()
                    }
                }), use.names = FALSE)
                cls_pkgs <- unlist(lapply(ns_info$importClasses, function(entry) {
                    if (is.list(entry) && length(entry)) as.character(entry[[1L]]) else character()
                }), use.names = FALSE)
                mth_pkgs <- unlist(lapply(ns_info$importMethods, function(entry) {
                    if (is.list(entry) && length(entry)) as.character(entry[[1L]]) else character()
                }), use.names = FALSE)
                pkgs <- c(pkgs, imp_pkgs, cls_pkgs, mth_pkgs, package_metadata_delayed_s3_packages(ns_info))
            }
        }
        syntax <- package_metadata_namespace_syntax(ns_file)
        pkgs <- unique(c(pkgs, syntax$packages))
        pkgs <- setdiff(pkgs[!is.na(pkgs) & nzchar(pkgs)], "R")
        if (!isTRUE(syntax$valid)) attr(pkgs, "complete") <- FALSE
        if (!is.null(key)) cache$set(key, pkgs)
        pkgs
    }
})

# S3method(pkg::generic, class) registers a delayed packageEvent() hook whose
# effect depends on whether pkg is already loaded (base::registerS3methods).
package_metadata_delayed_s3_packages <- function(ns_info) {
    methods <- if (is.list(ns_info)) ns_info$S3methods
    if (!is.matrix(methods) || ncol(methods) < 4L) return(character())
    delayed <- as.character(methods[, 4L])
    unique(delayed[!is.na(delayed) & nzchar(delayed)])
}

# Syntax-only NAMESPACE walk: never evaluates anything. parseNamespaceFile()
# evaluates if () conditions, which may call requireNamespace() and run a
# foreign .onLoad() in the server, so every branch of every if/else is
# collected instead (a conservative superset of possible dependencies).
# Branch choice cannot change runtime state of an installed package:
# loadNamespace() reads the install-time resolved Meta/nsInfo.rds, which
# package_metadata_package_runtime_stable() requires and the startup manifest
# fingerprints.
package_metadata_namespace_syntax <- local({
    cache <- NULL
    function(ns_file) {
        result <- list(packages = character(), valid = TRUE)
        if (!file.exists(ns_file)) return(result)
        if (is.null(cache)) cache <<- ByteLruCache$new(1024^2, 2048L)
        fp <- tryCatch(package_metadata_file_fingerprint(ns_file), error = function(e) NULL)
        if (!is.null(fp)) {
            cached <- cache$get(fp)
            if (!is.null(cached)) return(cached)
        }
        exprs <- tryCatch(parse(ns_file, keep.source = FALSE), error = function(e) NULL)
        if (is.null(exprs)) {
            result$valid <- FALSE
            if (!is.null(fp)) cache$set(fp, result)
            return(result)
        }
        packages <- character()
        arg_name <- function(arg) {
            if (is.name(arg) || (is.character(arg) && length(arg) == 1L)) as.character(arg) else ""
        }
        walk <- function(expr) {
            if (!is.call(expr) || !is.name(expr[[1L]])) return(invisible(NULL))
            op <- as.character(expr[[1L]])
            args <- as.list(expr)[-1L]
            if (identical(op, "{")) {
                for (sub_expr in args) walk(sub_expr)
            } else if (identical(op, "if")) {
                for (branch in args[-1L]) walk(branch)
            } else if (op %in% c("<-", "=") && length(args) >= 2L) {
                # parseNamespaceFile() parses the value of an assignment as a directive.
                walk(args[[2L]])
            } else if (identical(op, "import")) {
                arg_names <- names(args)
                keep <- if (is.null(arg_names)) rep(TRUE, length(args)) else arg_names != "except"
                packages <<- c(packages, vapply(args[keep], arg_name, character(1L)))
            } else if (op %in% c("importFrom", "importClassFrom", "importClassesFrom", "importMethodsFrom") && length(args)) {
                packages <<- c(packages, arg_name(args[[1L]]))
            } else if (identical(op, "S3method") && length(args)) {
                generic <- args[[1L]]
                if (is.call(generic) && length(generic) == 3L &&
                        (identical(generic[[1L]], as.name("::")) || identical(generic[[1L]], as.name(":::")))) {
                    packages <<- c(packages, arg_name(generic[[2L]]))
                }
            }
            invisible(NULL)
        }
        for (expr in as.list(exprs)) walk(expr)
        packages <- unique(packages[!is.na(packages) & nzchar(packages)])
        res <- list(packages = setdiff(packages, "R"), valid = TRUE)
        if (!is.null(fp)) cache$set(fp, res)
        res
    }
})

package_metadata_transitive_limit <- 2048L

package_metadata_transitive_packages <- function(
    packages,
    lib_paths = .libPaths(),
    limit = package_metadata_transitive_limit) {
    if (!is.numeric(limit) || length(limit) != 1L || is.na(limit) || limit < 0) {
        return(list(packages = character(), missing = character(), complete = FALSE))
    }
    lib_paths <- package_metadata_startup_lib_paths(lib_paths)
    visited <- character()
    installed <- character()
    missing <- character()
    pending <- unique(as.character(packages))
    pending <- pending[!is.na(pending) & nzchar(pending)]
    while (length(pending)) {
        package <- pending[[1L]]
        pending <- pending[-1L]
        if (package %in% visited) next
        path <- tryCatch(find.package(package, lib.loc = lib_paths, quiet = TRUE),
            error = function(e) character())
        if (length(path) != 1L || !nzchar(path)) {
            visited <- c(visited, package)
            missing <- c(missing, package)
            next
        }
        if (length(installed) >= limit) {
            return(list(packages = installed, missing = missing, complete = FALSE))
        }
        visited <- c(visited, package)
        installed <- c(installed, package)
        deps <- if (identical(package, "base")) {
            character()
        } else {
            dcf <- package_metadata_dcf_packages(file.path(path, "DESCRIPTION"))
            if (identical(attr(dcf, "complete", exact = TRUE), FALSE)) {
                return(list(packages = installed, missing = missing, complete = FALSE))
            }
            imports <- package_metadata_namespace_imports(path)
            if (identical(attr(imports, "complete", exact = TRUE), FALSE)) {
                return(list(packages = installed, missing = missing, complete = FALSE))
            }
            unique(c(as.character(dcf), as.character(imports)))
        }
        deps <- setdiff(deps, visited)
        if (length(deps)) pending <- unique(c(pending, deps))
    }
    list(packages = installed, missing = missing, complete = TRUE)
}

package_metadata_nspackloader_lines <- local({
    cached <- NULL
    function() {
        if (!is.null(cached)) return(cached)
        loader <- file.path(R.home("share"), "R", "nspackloader.R")
        if (!file.exists(loader)) return(character())
        cached <<- tryCatch(readLines(loader, warn = FALSE), error = function(e) character())
        cached
    }
})

package_metadata_rdx_has_hooks <- function(rdx_file) {
    rdx <- tryCatch(readRDS(rdx_file), error = function(e) NULL)
    if (!is.list(rdx) || !is.list(rdx$variables)) return(TRUE)
    vars <- names(rdx$variables)
    if (is.null(vars)) return(length(rdx$variables) > 0L)
    any(vars %in% c(".onLoad", ".onAttach", ".First.lib", ".Last.lib")) ||
        any(startsWith(vars, ".__A__") | startsWith(vars, ".__T__") | startsWith(vars, ".__C__"))
}

# Persistent startup bundles bypass isolated-worker s3_metadata_context() and
# live namespace inspection. Restrict filesystem-only reuse to base R .Library
# startup packages and declarative lazy-loaded packages with no load hooks,
# load actions, S4 metadata tables, or native DLL initializers.
package_metadata_package_runtime_stable <- local({
    cache <- NULL
    function(package, lib_paths = .libPaths()) {
        lib_paths <- package_metadata_startup_lib_paths(lib_paths)
        path <- tryCatch(find.package(package, lib.loc = lib_paths, quiet = TRUE),
            error = function(e) character())
        if (length(path) != 1L || !nzchar(path)) return(FALSE)
        pkg_dir <- normalizePath(path, winslash = "/", mustWork = FALSE)
        if (package %in% startup_packages) {
            base_dir <- normalizePath(file.path(.Library, package), winslash = "/", mustWork = FALSE)
            if (identical(pkg_dir, base_dir)) return(TRUE)
        }
        if (dir.exists(file.path(path, "libs"))) return(FALSE)
        pkg_rds <- file.path(path, "Meta", "package.rds")
        ns_info_file <- file.path(path, "Meta", "nsInfo.rds")
        if (!file.exists(pkg_rds) || !file.exists(ns_info_file)) return(FALSE)
        r_dir <- file.path(path, "R")
        r_files <- if (dir.exists(r_dir)) {
            package_metadata_sort(list.files(r_dir, all.files = TRUE, no.. = TRUE))
        } else {
            character()
        }
        data_dir <- file.path(path, "data")
        data_files <- if (dir.exists(data_dir)) {
            package_metadata_sort(list.files(data_dir, all.files = TRUE, no.. = TRUE))
        } else {
            character()
        }
        if (is.null(cache)) cache <<- ByteLruCache$new(1024^2, 2048L)
        tracked <- c(
            pkg_rds,
            ns_info_file,
            if (length(r_files)) file.path(r_dir, r_files),
            if (length(data_files)) file.path(data_dir, data_files)
        )
        fp <- tryCatch(package_metadata_file_fingerprint(tracked), error = function(e) NULL)
        key <- if (!is.null(fp)) paste(c(pkg_dir, r_files, "|", data_files, "|", fp), collapse = "\n")
        if (!is.null(key)) {
            cached <- cache$get(key)
            if (!is.null(cached)) return(cached)
        }
        store <- function(val) {
            if (!is.null(key)) cache$set(key, val)
            val
        }
        ns_info <- tryCatch(readRDS(ns_info_file), error = function(e) NULL)
        if (!is.list(ns_info)) return(store(FALSE))
        if (length(ns_info$dynlibs) > 0L || length(ns_info$nativeRoutines) > 0L ||
                length(ns_info$exportClasses) > 0L || length(ns_info$exportMethods) > 0L ||
                length(ns_info$exportClassPatterns) > 0L ||
                length(package_metadata_delayed_s3_packages(ns_info)) > 0L) {
            return(store(FALSE))
        }
        if (dir.exists(r_dir)) {
            codename <- strsplit(package, "_", fixed = TRUE)[[1L]][[1L]]
            allowed_r_files <- c(codename, paste0(codename, c(".rdx", ".rdb")), "sysdata.rdx", "sysdata.rdb")
            if (length(r_files) && !all(r_files %in% allowed_r_files)) {
                return(store(FALSE))
            }
            code_file <- file.path(r_dir, codename)
            rdx_file <- file.path(r_dir, paste0(codename, ".rdx"))
            rdb_file <- file.path(r_dir, paste0(codename, ".rdb"))
            loader_lines <- package_metadata_nspackloader_lines()
            if (file.exists(code_file)) {
                if (!file.exists(rdx_file) || !file.exists(rdb_file) || !length(loader_lines)) {
                    return(store(FALSE))
                }
                code_lines <- tryCatch(readLines(code_file, warn = FALSE), error = function(e) NULL)
                if (!identical(code_lines, loader_lines)) return(store(FALSE))
            } else if (length(r_files) > 0L) {
                if (!file.exists(rdx_file) || !file.exists(rdb_file)) return(store(FALSE))
            }
            if (file.exists(rdx_file) != file.exists(rdb_file)) {
                return(store(FALSE))
            }
            if (file.exists(rdx_file) && package_metadata_rdx_has_hooks(rdx_file)) {
                return(store(FALSE))
            }
            sys_rdx <- file.path(r_dir, "sysdata.rdx")
            sys_rdb <- file.path(r_dir, "sysdata.rdb")
            if (file.exists(sys_rdx) != file.exists(sys_rdb)) {
                return(store(FALSE))
            }
            if (file.exists(sys_rdx) && package_metadata_rdx_has_hooks(sys_rdx)) {
                return(store(FALSE))
            }
        }
        if (dir.exists(data_dir)) {
            if (length(data_files) &&
                    !all(data_files %in% c("Rdata.rdb", "Rdata.rdx", "Rdata.rds", "datalist"))) {
                return(store(FALSE))
            }
            data_rdx <- file.path(data_dir, "Rdata.rdx")
            data_rdb <- file.path(data_dir, "Rdata.rdb")
            if (file.exists(data_rdx) != file.exists(data_rdb)) {
                return(store(FALSE))
            }
            if (file.exists(data_rdx) && package_metadata_rdx_has_hooks(data_rdx)) {
                return(store(FALSE))
            }
        }
        store(TRUE)
    }
})

package_metadata_runtime_stable <- function(packages, lib_paths = .libPaths()) {
    packages <- unique(as.character(packages))
    packages <- packages[!is.na(packages) & nzchar(packages)]
    if (!length(packages)) return(TRUE)
    lib_paths <- package_metadata_startup_lib_paths(lib_paths)
    all(vapply(packages, package_metadata_package_runtime_stable, logical(1L), lib_paths = lib_paths))
}

# Lazy-load databases of non-base packages whose content was not produced by
# R itself (base R startup packages are trusted and skipped).
package_metadata_lazyload_files <- function(packages, lib_paths = .libPaths()) {
    lib_paths <- package_metadata_startup_lib_paths(lib_paths)
    files <- character()
    for (package in unique(as.character(packages))) {
        path <- tryCatch(find.package(package, lib.loc = lib_paths, quiet = TRUE),
            error = function(e) character())
        if (length(path) != 1L || !nzchar(path)) next
        pkg_dir <- normalizePath(path, winslash = "/", mustWork = FALSE)
        base_dir <- normalizePath(file.path(.Library, package), winslash = "/", mustWork = FALSE)
        if (package %in% startup_packages && identical(pkg_dir, base_dir)) next
        codename <- strsplit(package, "_", fixed = TRUE)[[1L]][[1L]]
        candidates <- c(file.path(path, "R", paste0(codename, ".rdx")),
            file.path(path, "R", "sysdata.rdx"), file.path(path, "data", "Rdata.rdx"))
        files <- c(files, candidates[file.exists(candidates)])
    }
    files
}

package_metadata_rdb_decode <- function(raw_bytes, compressed) {
    if (isFALSE(compressed)) return(raw_bytes)
    if (length(raw_bytes) < 4L) stop("Truncated lazy-load record")
    u_len <- readBin(raw_bytes[1:4], "integer", n = 1L, size = 4L, endian = "big")
    if (is.na(u_len) || u_len < 0L) stop("Invalid lazy-load length")
    if (isTRUE(compressed) || identical(compressed, 1L) || identical(compressed, 1)) {
        out <- memDecompress(raw_bytes[-(1:4)], "gzip")
        if (length(out) != u_len) stop("Truncated lazy-load decompression")
        return(out)
    }
    if (length(raw_bytes) < 5L || raw_bytes[5L] == as.raw(0L)) {
        stop("Truncated lazy-load header")
    }
    type <- rawToChar(raw_bytes[5L])
    payload <- raw_bytes[-(1:5)]
    out <- switch(type,
        Z = {
            if (length(payload) < 6L ||
                    !identical(payload[1:6], as.raw(c(0xfd, 0x37, 0x7a, 0x58, 0x5a, 0x00)))) {
                xz_hdr <- as.raw(c(
                    0xfd, 0x37, 0x7a, 0x58, 0x5a, 0x00, 0x00, 0x00, 0xff, 0x12, 0xd9, 0x41,
                    0x02, 0x00, 0x21, 0x01, 0x1c, 0x00, 0x00, 0x00, 0x10, 0xcf, 0x58, 0xcc
                ))
                payload <- c(xz_hdr, payload)
            }
            memDecompress(payload, "xz")
        },
        "2" = memDecompress(payload, "bzip2"),
        "1" = memDecompress(payload, "gzip"),
        "0" = payload,
        stop("Unknown lazy-load compression"))
    if (length(out) != u_len) stop("Truncated lazy-load decompression")
    out
}

# Pure in-process XDR header scan of .rdx/.rdb records.
# Returns TRUE if any top-level variable, lazyKey, or namespace-free eagerKey
# environment binding is a promise (SEXPTYPE == 5L) or unreadable, FALSE if all
# variables and standard namespace references are valid non-promises, and NA if
# user environment references or unknown XDR headers require the isolated
# baseenv() scan worker.
package_metadata_rdb_scan_headers <- function(rdx_file) {
    rdx <- tryCatch(readRDS(rdx_file), error = function(e) NULL)
    rdb_file <- sub("\\.rdx$", ".rdb", rdx_file)
    size <- file.info(rdb_file)$size
    if (!is.list(rdx) || is.na(size)) return(TRUE)
    bytes <- tryCatch(readBin(rdb_file, "raw", size), error = function(e) NULL)
    if (is.null(bytes)) return(TRUE)
    sexp_type <- function(record) {
        if (length(record) < 18L || record[1L] != as.raw(0x58) || record[2L] != as.raw(0x0a)) return(NA_integer_)
        ver <- readBin(record[3:6], "integer", n = 1L, size = 4L, endian = "big")
        pos <- if (identical(ver, 2L)) {
            15L
        } else if (identical(ver, 3L)) {
            enc_len <- readBin(record[15:18], "integer", n = 1L, size = 4L, endian = "big")
            if (is.na(enc_len) || enc_len < 0L) return(NA_integer_)
            19L + enc_len
        } else {
            return(NA_integer_)
        }
        if (length(record) < pos + 3L) return(NA_integer_)
        as.integer(record[pos + 3L])
    }
    check_key <- function(key) {
        key <- as.numeric(key)
        if (length(key) != 2L || anyNA(key) || key[[1L]] < 0 || key[[2L]] < 0 || key[[1L]] + key[[2L]] > size) {
            return(5L)
        }
        record <- tryCatch(
            package_metadata_rdb_decode(bytes[key[[1L]] + seq_len(key[[2L]])], rdx$compressed),
            error = function(e) NULL
        )
        if (is.null(record)) return(5L)
        sexp_type(record)
    }
    needs_worker <- length(rdx$references) > 4L
    var_names <- names(rdx$variables)
    for (i in seq_along(rdx$variables)) {
        st <- check_key(rdx$variables[[i]])
        if (is.na(st)) {
            needs_worker <- TRUE
        } else if (identical(st, 5L)) {
            return(TRUE)
        } else if (st %in% c(247L, 254L)) {
            nm <- if (!is.null(var_names)) var_names[[i]] else ""
            if (!(nm %in% c(".__NAMESPACE__.", ".__S3MethodsTable__."))) {
                needs_worker <- TRUE
            }
        }
    }
    if (length(rdx$references) > 0L) {
        hook <- function(x) new.env(parent = emptyenv())
        for (ref in rdx$references) {
            for (key in if (is.list(ref)) ref$lazyKeys) {
                st <- check_key(key)
                if (is.na(st)) {
                    needs_worker <- TRUE
                } else if (identical(st, 5L)) {
                    return(TRUE)
                }
            }
            eager <- if (is.list(ref)) ref$eagerKey else ref
            eager <- as.numeric(eager)
            if (length(eager) != 2L || anyNA(eager) || eager[[1L]] < 0 ||
                    eager[[2L]] < 0 || eager[[1L]] + eager[[2L]] > size) {
                return(TRUE)
            }
            raw_rec <- tryCatch(
                package_metadata_rdb_decode(bytes[eager[[1L]] + seq_len(eager[[2L]])], rdx$compressed),
                error = function(e) NULL
            )
            if (is.null(raw_rec)) return(TRUE)
            if (any(raw_rec == as.raw(0xf8) | raw_rec == as.raw(0xf9))) {
                needs_worker <- TRUE
            } else {
                val <- tryCatch(unserialize(raw_rec, refhook = hook), error = function(e) e)
                if (inherits(val, "error")) return(TRUE)
                bindings <- if (is.list(val)) val$bindings
                if (is.list(bindings) && length(bindings) && any(vapply(seq_along(bindings), function(i) {
                    typeof(bindings[[i]]) == "promise"
                }, logical(1L)))) {
                    return(TRUE)
                }
            }
        }
    }
    if (needs_worker) NA else FALSE
}

# Runs in an isolated process: unserializing lazy-load records may load the
# namespaces referenced by closures. Each record is decoded without forcing
# promises; a top-level promise (delayedAssign()) or a promise binding in a
# serialized environment means the value depends on load-time evaluation.
package_metadata_rdb_scan <- function(files) {
    hook <- function(x) new.env(parent = emptyenv())
    decode <- function(raw_bytes, compressed) {
        if (isFALSE(compressed)) return(raw_bytes)
        if (length(raw_bytes) < 4L) stop("Truncated lazy-load record")
        u_len <- readBin(raw_bytes[1:4], "integer", n = 1L, size = 4L, endian = "big")
        if (is.na(u_len) || u_len < 0L) stop("Invalid lazy-load length")
        if (isTRUE(compressed) || identical(compressed, 1L) || identical(compressed, 1)) {
            out <- memDecompress(raw_bytes[-(1:4)], "gzip")
            if (length(out) != u_len) stop("Truncated lazy-load decompression")
            return(out)
        }
        if (length(raw_bytes) < 5L || raw_bytes[5L] == as.raw(0L)) {
            stop("Truncated lazy-load header")
        }
        type <- rawToChar(raw_bytes[5L])
        payload <- raw_bytes[-(1:5)]
        out <- switch(type,
            Z = {
                if (length(payload) < 6L ||
                        !identical(payload[1:6], as.raw(c(0xfd, 0x37, 0x7a, 0x58, 0x5a, 0x00)))) {
                    xz_hdr <- as.raw(c(
                        0xfd, 0x37, 0x7a, 0x58, 0x5a, 0x00, 0x00, 0x00, 0xff, 0x12, 0xd9, 0x41,
                        0x02, 0x00, 0x21, 0x01, 0x1c, 0x00, 0x00, 0x00, 0x10, 0xcf, 0x58, 0xcc
                    ))
                    payload <- c(xz_hdr, payload)
                }
                memDecompress(payload, "xz")
            },
            "2" = memDecompress(payload, "bzip2"),
            "1" = memDecompress(payload, "gzip"),
            "0" = payload,
            stop("Unknown lazy-load compression"))
        if (length(out) != u_len) stop("Truncated lazy-load decompression")
        out
    }
    sexp_type <- function(record) {
        if (length(record) < 18L || record[1L] != as.raw(0x58) || record[2L] != as.raw(0x0a)) return(NA_integer_)
        ver <- readBin(record[3:6], "integer", n = 1L, size = 4L, endian = "big")
        pos <- if (identical(ver, 2L)) {
            15L
        } else if (identical(ver, 3L)) {
            enc_len <- readBin(record[15:18], "integer", n = 1L, size = 4L, endian = "big")
            if (is.na(enc_len) || enc_len < 0L) return(NA_integer_)
            19L + enc_len
        } else {
            return(NA_integer_)
        }
        if (length(record) < pos + 3L) return(NA_integer_)
        as.integer(record[pos + 3L])
    }
    scan_one <- function(rdx_file) {
        rdx <- readRDS(rdx_file)
        rdb_file <- sub("\\.rdx$", ".rdb", rdx_file)
        size <- file.info(rdb_file)$size
        if (!is.list(rdx) || is.na(size)) return(TRUE)
        bytes <- readBin(rdb_file, "raw", size)
        fetch_raw <- function(key) {
            key <- as.numeric(key)
            if (length(key) != 2L || anyNA(key) || key[[1L]] < 0 || key[[2L]] < 0 || key[[1L]] + key[[2L]] > size) {
                stop("Invalid lazy-load key")
            }
            decode(bytes[key[[1L]] + seq_len(key[[2L]])], rdx$compressed)
        }
        fetch <- function(key) {
            unserialize(fetch_raw(key), refhook = hook)
        }
        is_promise_key <- function(key) {
            record <- tryCatch(fetch_raw(key), error = function(e) NULL)
            if (is.null(record)) return(TRUE)
            st <- sexp_type(record)
            if (!is.na(st)) return(identical(st, 5L))
            value <- tryCatch(unserialize(record, refhook = hook), error = function(e) e)
            inherits(value, "error") || typeof(value) == "promise"
        }
        for (key in rdx$variables) {
            if (is_promise_key(key)) return(TRUE)
        }
        for (ref in rdx$references) {
            eager <- if (is.list(ref)) ref$eagerKey else ref
            value <- fetch(eager)
            bindings <- if (is.list(value)) value$bindings
            if (is.list(bindings) && length(bindings) && any(vapply(seq_along(bindings), function(i) {
                typeof(bindings[[i]]) == "promise"
            }, logical(1L)))) {
                return(TRUE)
            }
            # Source-reference environments keep large bindings lazily.
            for (key in if (is.list(ref)) ref$lazyKeys) {
                if (is_promise_key(key)) return(TRUE)
            }
        }
        FALSE
    }
    scan_file <- function(rdx_file) tryCatch(scan_one(rdx_file), error = function(e) TRUE)
    stats::setNames(vapply(files, scan_file, logical(1L)), files)
}

package_metadata_promises_absent <- local({
    verdicts <- NULL
    scan_worker <- NULL
    file_key <- function(rdx_file) {
        tryCatch(
            package_metadata_file_fingerprint(c(rdx_file, sub("\\.rdx$", ".rdb", rdx_file))),
            error = function(e) NULL
        )
    }
    function(packages, lib_paths = .libPaths()) {
        lib_paths <- package_metadata_startup_lib_paths(lib_paths)
        files <- package_metadata_lazyload_files(packages, lib_paths)
        if (!length(files)) return(TRUE)
        if (is.null(verdicts)) verdicts <<- ByteLruCache$new(2 * 1024^2, 2048L)
        keys <- vapply(files, function(f) {
            k <- file_key(f)
            if (is.null(k)) "" else as.character(k)
        }, character(1L))
        if (any(!nzchar(keys))) return(FALSE)
        flagged <- logical(length(files))
        missing_idx <- integer()
        for (i in seq_along(files)) {
            k <- keys[[i]]
            cached <- verdicts$get(k)
            if (!is.null(cached)) {
                flagged[[i]] <- isTRUE(cached)
            } else {
                header_verdict <- package_metadata_rdb_scan_headers(files[[i]])
                if (!is.na(header_verdict)) {
                    verdicts$set(k, isTRUE(header_verdict))
                    flagged[[i]] <- isTRUE(header_verdict)
                } else {
                    missing_idx <- c(missing_idx, i)
                }
            }
        }
        if (length(missing_idx)) {
            if (is.null(scan_worker)) {
                fn <- package_metadata_rdb_scan
                environment(fn) <- baseenv()
                attributes(fn) <- NULL
                attributes(body(fn)) <- NULL
                scan_worker <<- fn
            }
            missing_keys <- keys[missing_idx]
            rep_idx <- missing_idx[!duplicated(missing_keys)]
            uncached_files <- files[rep_idx]
            uncached_keys <- keys[rep_idx]
            scanned <- tryCatch(callr::r(scan_worker, args = list(files = uncached_files),
                    libpath = lib_paths, system_profile = FALSE, user_profile = FALSE,
                    timeout = if (identical(Sys.getenv("R_COVR"), "true")) 60 else 20),
                error = function(e) {
                    logger$info("startup bundle lazy-load scan:", e)
                    NULL
                })
            if (!is.logical(scanned) || length(scanned) != length(uncached_files) || anyNA(scanned)) {
                return(FALSE)
            }
            for (j in seq_along(uncached_keys)) {
                k <- uncached_keys[[j]]
                val <- isTRUE(scanned[[j]])
                verdicts$set(k, val)
                flagged[keys == k] <- val
            }
        }
        !any(flagged)
    }
})

package_metadata_missing_absent <- function(missing_packages, lib_paths = .libPaths()) {
    if (is.null(missing_packages)) return(TRUE)
    if (!is.character(missing_packages)) return(FALSE)
    missing_packages <- unique(missing_packages[!is.na(missing_packages) & nzchar(missing_packages)])
    if (!length(missing_packages)) return(TRUE)
    lib_paths <- package_metadata_startup_lib_paths(lib_paths)
    !any(vapply(missing_packages, function(package) {
        path <- tryCatch(find.package(package, lib.loc = lib_paths, quiet = TRUE),
            error = function(e) character())
        length(path) == 1L && nzchar(path)
    }, logical(1L)))
}

# loadNamespace() also reads Meta/nsInfo.rds (in preference to NAMESPACE),
# Meta/package.rds, Meta/features.rds and the R/<codename> loader script.
package_metadata_startup_identity <- function(package, lib_paths = .libPaths()) {
    identity <- package_metadata_identity(package, lib_paths = lib_paths)
    path <- identity$path
    codename <- strsplit(package, "_", fixed = TRUE)[[1L]][[1L]]
    files <- c(file.path(path, "Meta", c("nsInfo.rds", "package.rds", "features.rds")),
        file.path(path, "R", codename), file.path(path, "data", "datalist"))
    present <- file.exists(files)
    identity$startup_files <- list(present = present,
        files = if (any(present)) package_metadata_file_fingerprint(files[present]) else "")
    identity
}

package_metadata_watch_paths <- function(packages, pkg_dirs, lib_paths) {
    sub_dirs <- file.path(
        rep(pkg_dirs, each = 5L),
        rep(c("Meta", "R", "data", "help", "libs"), times = length(pkg_dirs))
    )
    existing_subdirs <- sub_dirs[dir.exists(sub_dirs)]
    r_data_dirs <- file.path(
        rep(pkg_dirs, each = 2L),
        rep(c("R", "data"), times = length(pkg_dirs))
    )
    r_data_dirs <- r_data_dirs[dir.exists(r_data_dirs)]
    f_r_data <- list.files(r_data_dirs, all.files = TRUE, no.. = TRUE, full.names = TRUE)
    help_dirs <- file.path(pkg_dirs, "help")
    help_dirs <- help_dirs[dir.exists(help_dirs)]
    f_help <- list.files(help_dirs, pattern = "\\.(rdb|rdx|rds)$", full.names = TRUE)
    libs_dirs <- file.path(pkg_dirs, "libs")
    libs_dirs <- libs_dirs[dir.exists(libs_dirs)]
    f_libs <- c(
        list.dirs(libs_dirs, full.names = TRUE, recursive = TRUE),
        list.files(libs_dirs, all.files = TRUE, no.. = TRUE, full.names = TRUE, recursive = TRUE)
    )
    meta_candidates <- file.path(
        rep(pkg_dirs, each = 3L),
        "Meta",
        rep(c("nsInfo.rds", "package.rds", "features.rds"), times = length(pkg_dirs))
    )
    meta_files <- meta_candidates[file.exists(meta_candidates)]
    fixed <- c(file.path(pkg_dirs, "DESCRIPTION"), file.path(pkg_dirs, "NAMESPACE"))
    shadow <- unlist(lapply(seq_along(packages), function(i) {
        p_dir <- pkg_dirs[[i]]
        parent <- dirname(p_dir)
        idx <- match(parent, lib_paths)
        if (!is.na(idx) && idx > 1L) {
            file.path(lib_paths[seq_len(idx - 1L)], packages[[i]], "DESCRIPTION")
        } else {
            character()
        }
    }), use.names = FALSE)
    package_metadata_sort(
        unique(c(pkg_dirs, existing_subdirs, fixed, meta_files, f_r_data, f_help, f_libs, shadow))
    )
}

package_metadata_file_info_stamp <- function(watch_paths) {
    info <- fs::file_info(watch_paths, fail = FALSE)
    list(
        as.numeric(info$size),
        info$type,
        as.numeric(info$modification_time),
        as.numeric(info$change_time),
        info$device_id,
        info$inode
    )
}

package_metadata_manifest <- local({
    cache <- NULL
    function(packages, lib_paths = .libPaths()) {
        lib_paths <- package_metadata_startup_lib_paths(lib_paths)
        packages <- unique(as.character(packages))
        packages <- packages[!is.na(packages) & nzchar(packages)]
        if (!length(packages)) return(list())
        if (is.null(cache)) cache <<- ByteLruCache$new(4 * 1024^2, 256L)
        fp_cache <- environment(package_metadata_file_fingerprint)$cache
        key <- paste(c(packages, "|", lib_paths), collapse = "\n")
        if (!is.null(fp_cache) && fp_cache$size() > 0L) {
            cached <- cache$get(key)
            if (!is.null(cached) &&
                    identical(package_metadata_file_info_stamp(cached$watch_paths), cached$stamp)) {
                return(cached$manifest)
            }
        }
        manifest <- list()
        for (package in packages) {
            identity <- tryCatch(package_metadata_startup_identity(package, lib_paths = lib_paths),
                error = function(e) NULL)
            if (is.null(identity)) return(NULL)
            manifest[[package]] <- identity
        }
        pkg_dirs <- vapply(manifest, `[[`, character(1L), "path")
        watch_paths <- package_metadata_watch_paths(packages, pkg_dirs, lib_paths)
        stamp <- package_metadata_file_info_stamp(watch_paths)
        cache$set(key, list(manifest = manifest, watch_paths = watch_paths, stamp = stamp))
        manifest
    }
})

package_metadata_manifest_valid <- function(manifest, lib_paths = .libPaths()) {
    if (!is.list(manifest) || is.object(manifest)) return(FALSE)
    manifest_names <- names(manifest)
    if (length(manifest) && (is.null(manifest_names) || any(!nzchar(manifest_names)))) {
        return(FALSE)
    }
    if (!length(manifest_names)) return(TRUE)
    current <- package_metadata_manifest(manifest_names, lib_paths = lib_paths)
    identical(current, manifest)
}

package_metadata_identity_matches_manifest <- function(identity, manifest_entry) {
    if (!is.list(identity) || is.object(identity) || !is.null(identity$error) ||
            !is.list(manifest_entry) || is.object(manifest_entry)) {
        return(FALSE)
    }
    if (!identical(identity$package, manifest_entry$package) ||
            !identical(package_metadata_normalize_path(identity$path),
                package_metadata_normalize_path(manifest_entry$path)) ||
            !identical(identity$version, manifest_entry$version) ||
            !identical(identity$r, manifest_entry$r) ||
            !identical(identity$files, manifest_entry$files)) {
        return(FALSE)
    }
    if (!is.null(identity$startup_files) &&
            !identical(identity$startup_files, manifest_entry$startup_files)) {
        return(FALSE)
    }
    TRUE
}

package_metadata_context_matches_manifest <- function(context, manifest) {
    if (!is.list(manifest) || is.object(manifest)) return(FALSE)
    if (!length(manifest)) return(TRUE)
    if (!is.list(context) || is.object(context) || identical(context$cacheable, FALSE)) {
        return(FALSE)
    }
    ctx_packages <- context$packages
    if (!is.list(ctx_packages) || is.object(ctx_packages)) return(FALSE)
    seen <- character()
    for (entry in ctx_packages) {
        if (!is.list(entry) || !is.character(entry$package) ||
                length(entry$package) != 1L || !nzchar(entry$package)) {
            return(FALSE)
        }
        pkg <- entry$package
        if (!(pkg %in% names(manifest)) ||
                !package_metadata_identity_matches_manifest(entry, manifest[[pkg]])) {
            return(FALSE)
        }
        seen <- c(seen, pkg)
    }
    all(names(manifest) %in% seen)
}

package_metadata_identities_match_manifest <- function(identities, manifest) {
    if (!is.list(manifest) || is.object(manifest)) return(FALSE)
    if (!length(manifest)) return(TRUE)
    if (!is.list(identities) || is.object(identities)) return(FALSE)
    id_names <- names(identities)
    if (length(identities) && (is.null(id_names) || any(!nzchar(id_names)))) {
        return(FALSE)
    }
    if (!all(names(manifest) %in% id_names)) return(FALSE)
    for (pkg in id_names) {
        if (!(pkg %in% names(manifest)) ||
                !package_metadata_identity_matches_manifest(identities[[pkg]], manifest[[pkg]])) {
            return(FALSE)
        }
    }
    TRUE
}

package_metadata_bundle_key_matches_manifest <- function(bundle_key, manifest) {
    if (!is.list(bundle_key) || !is.list(manifest)) return(FALSE)
    pre_manifest <- bundle_key$manifest
    if (is.null(pre_manifest) && is.list(bundle_key$identity)) {
        pre_manifest <- bundle_key$identity$packages
    }
    if (is.null(pre_manifest)) return(TRUE)
    if (!is.list(pre_manifest) || !all(names(pre_manifest) %in% names(manifest))) {
        return(FALSE)
    }
    for (pkg in names(pre_manifest)) {
        if (!package_metadata_identity_matches_manifest(pre_manifest[[pkg]], manifest[[pkg]])) {
            return(FALSE)
        }
    }
    TRUE
}

package_metadata_startup_s3_identities_valid <- function(catalogs, manifest) {
    if (!is.list(catalogs) || is.object(catalogs) ||
            !is.list(manifest) || is.object(manifest)) {
        return(FALSE)
    }
    catalog_names <- names(catalogs)
    if (!length(catalogs) || is.null(catalog_names) || any(!nzchar(catalog_names))) {
        return(FALSE)
    }
    if (!all(catalog_names %in% names(manifest))) return(FALSE)
    for (pkg in catalog_names) {
        catalog <- catalogs[[pkg]]
        if (!is.list(catalog) ||
                !package_metadata_identity_matches_manifest(catalog$identity, manifest[[pkg]]) ||
                !package_metadata_context_matches_manifest(catalog$identity$context, manifest)) {
            return(FALSE)
        }
    }
    worker_identities <- attr(catalogs, "identities", exact = TRUE)
    if (!is.null(worker_identities) &&
            !package_metadata_identities_match_manifest(worker_identities, manifest)) {
        return(FALSE)
    }
    TRUE
}

package_metadata_startup_members_identities_valid <- function(
    snapshots,
    manifest,
    identities = NULL) {
    if (!is.list(snapshots) || is.object(snapshots) ||
            !is.list(manifest) || is.object(manifest)) {
        return(FALSE)
    }
    snapshot_names <- names(snapshots)
    if (length(snapshots) && (is.null(snapshot_names) || any(!nzchar(snapshot_names)))) {
        return(FALSE)
    }
    if (!all(snapshot_names %in% names(manifest))) return(FALSE)
    for (pkg in snapshot_names) {
        snapshot <- snapshots[[pkg]]
        if (!is.list(snapshot) ||
                !package_metadata_identity_matches_manifest(snapshot$identity, manifest[[pkg]]) ||
                !package_metadata_context_matches_manifest(snapshot$identity$context, manifest)) {
            return(FALSE)
        }
    }
    if (!package_metadata_identities_match_manifest(identities, manifest)) {
        return(FALSE)
    }
    TRUE
}

package_metadata_startup_bundle_key <- local({
    cache <- NULL
    function(type, packages, lib_paths = .libPaths()) {
        if (is.null(package_metadata_cache_directory())) return(NULL)
        lib_paths <- package_metadata_startup_lib_paths(lib_paths)
        key_packages <- unique(c(startup_packages, as.character(packages)))
        key_packages <- key_packages[!is.na(key_packages) & nzchar(key_packages)]
        if (is.null(cache)) cache <<- ByteLruCache$new(4 * 1024^2, 256L)
        fp_cache <- environment(package_metadata_file_fingerprint)$cache
        graph_key <- paste(
            c(key_packages, "|", lib_paths, "|", as.character(package_metadata_transitive_limit)),
            collapse = "\n"
        )
        resolved <- NULL
        if (!is.null(fp_cache) && fp_cache$size() > 0L) {
            cached <- cache$get(graph_key)
            if (!is.null(cached) &&
                    package_metadata_missing_absent(cached$missing, lib_paths) &&
                    identical(package_metadata_file_info_stamp(cached$watch_paths), cached$stamp)) {
                resolved <- cached
            }
        }
        if (is.null(resolved)) {
            traversal <- package_metadata_transitive_packages(key_packages, lib_paths)
            if (!isTRUE(traversal$complete) ||
                    !all(key_packages %in% traversal$packages) ||
                    !package_metadata_runtime_stable(traversal$packages, lib_paths)) {
                return(NULL)
            }
            manifest <- package_metadata_manifest(traversal$packages, lib_paths)
            if (is.null(manifest)) return(NULL)
            m_cache <- environment(package_metadata_manifest)$cache
            m_key <- paste(c(traversal$packages, "|", lib_paths), collapse = "\n")
            m_entry <- m_cache$get(m_key)
            resolved <- list(
                manifest = manifest,
                missing = traversal$missing,
                watch_paths = m_entry$watch_paths,
                stamp = m_entry$stamp
            )
            cache$set(graph_key, resolved)
        }
        identity <- list(
            package = "startup",
            requested_packages = as.character(packages),
            lib_paths = lib_paths,
            packages = resolved$manifest
        )
        path <- package_metadata_cache_path(type, identity)
        if (is.null(path)) return(NULL)
        list(
            type = type,
            path = path,
            identity = identity,
            lib_paths = lib_paths,
            manifest = resolved$manifest,
            missing = resolved$missing
        )
    }
})

package_metadata_startup_s3_complete <- function(catalogs, requested_packages) {
    if (!is.list(catalogs) || is.object(catalogs)) return(FALSE)
    catalog_names <- names(catalogs)
    if (length(catalogs) && (is.null(catalog_names) || any(!nzchar(catalog_names)))) {
        return(FALSE)
    }
    valid <- vapply(catalogs, function(catalog) {
        is.list(catalog) && identical(catalog$schema, 1L) && is.null(catalog$error)
    }, logical(1L))
    dependencies <- unlist(lapply(catalogs[valid], `[[`, "dependencies"), use.names = FALSE)
    required <- unique(c(startup_packages, as.character(requested_packages), dependencies))
    all(valid) && all(required %in% names(catalogs))
}

package_metadata_startup_s3_read <- function(bundle_key, requested_packages) {
    if (is.null(bundle_key)) return(NULL)
    bundle <- package_metadata_cache_read(bundle_key$path, bundle_key$identity, function(value) {
        if (!is.list(value) || is.object(value) ||
                !package_metadata_startup_s3_complete(value$catalogs, requested_packages)) {
            return(FALSE)
        }
        required <- unique(c(startup_packages, as.character(requested_packages), names(value$catalogs)))
        required <- required[!is.na(required) & nzchar(required)]
        all(required %in% names(value$manifest)) &&
            package_metadata_bundle_key_matches_manifest(bundle_key, value$manifest) &&
            package_metadata_manifest_valid(value$manifest, bundle_key$lib_paths) &&
            package_metadata_startup_s3_identities_valid(value$catalogs, value$manifest) &&
            package_metadata_missing_absent(value$missing, bundle_key$lib_paths) &&
            package_metadata_runtime_stable(names(value$manifest), bundle_key$lib_paths)
    })
    if (!is.null(bundle)) bundle$catalogs
}

package_metadata_startup_s3_write <- function(bundle_key, requested_packages, catalogs) {
    if (is.null(bundle_key) || !package_metadata_startup_s3_complete(catalogs, requested_packages)) {
        return(invisible(NULL))
    }
    required <- unique(c(startup_packages, as.character(requested_packages), names(catalogs)))
    required <- required[!is.na(required) & nzchar(required)]
    traversal <- package_metadata_transitive_packages(required, bundle_key$lib_paths)
    if (!isTRUE(traversal$complete)) return(invisible(NULL))
    packages <- unique(c(required, traversal$packages))
    if (!package_metadata_runtime_stable(packages, bundle_key$lib_paths) ||
            !package_metadata_promises_absent(packages, bundle_key$lib_paths)) {
        return(invisible(NULL))
    }
    manifest <- package_metadata_manifest(packages, bundle_key$lib_paths)
    if (is.null(manifest) ||
            !package_metadata_bundle_key_matches_manifest(bundle_key, manifest) ||
            !package_metadata_startup_s3_identities_valid(catalogs, manifest)) {
        return(invisible(NULL))
    }
    package_metadata_cache_write(bundle_key$path, bundle_key$identity,
        list(manifest = manifest, missing = traversal$missing, catalogs = catalogs))
}

package_metadata_target_packages <- function(packages) {
    packages <- unique(as.character(packages))
    packages[!is.na(packages) & nzchar(packages)]
}

package_metadata_startup_members_snapshots_valid <- function(snapshots) {
    if (!is.list(snapshots) || is.object(snapshots)) return(FALSE)
    if (identical(attr(snapshots, "complete", exact = TRUE), FALSE)) return(FALSE)
    if (!length(snapshots)) return(TRUE)
    snapshot_names <- names(snapshots)
    if (is.null(snapshot_names) || any(!nzchar(snapshot_names))) return(FALSE)
    all(vapply(snapshots, function(value) {
        is.list(value) && isTRUE(value$dataset_only) && !is.null(member_index_thaw(value))
    }, logical(1L)))
}

package_metadata_startup_members_unpack <- function(result, requested_packages = character()) {
    target_packages <- package_metadata_target_packages(requested_packages)
    if (!is.list(result) || is.object(result)) {
        return(list(
            .startup_members_unpacked = TRUE,
            snapshots = NULL,
            inspected = character(),
            identities = NULL,
            complete = FALSE,
            valid = FALSE
        ))
    }
    if (isTRUE(result$.startup_members_unpacked)) {
        return(result)
    }
    if (isTRUE(result$.startup_members_result)) {
        snapshots <- result$snapshots
        valid <- package_metadata_startup_members_snapshots_valid(snapshots)
        clean_snapshots <- snapshots
        if (valid && !is.null(attr(clean_snapshots, "identities", exact = TRUE))) {
            attr(clean_snapshots, "identities") <- NULL
        }
        inspected <- if (is.character(result$inspected)) {
            package_metadata_target_packages(result$inspected)
        } else {
            character()
        }
        identities <- result$identities
        if (is.null(identities)) {
            identities <- attr(snapshots, "identities", exact = TRUE)
        }
        if (is.null(identities) && valid && length(clean_snapshots) > 0L) {
            ctx_pkgs <- clean_snapshots[[1L]]$identity$context$packages
            if (is.list(ctx_pkgs) && length(ctx_pkgs) > 0L) {
                pkg_names <- vapply(ctx_pkgs, function(x) {
                    if (is.list(x) && is.character(x$package) && length(x$package) == 1L) x$package else ""
                }, character(1L))
                if (all(nzchar(pkg_names))) {
                    identities <- stats::setNames(ctx_pkgs, pkg_names)
                }
            }
        }
        complete <- valid &&
            isTRUE(result$complete) &&
            length(result$errors) == 0L &&
            all(target_packages %in% inspected) &&
            all(names(clean_snapshots) %in% inspected)
        return(list(
            .startup_members_unpacked = TRUE,
            snapshots = if (valid) clean_snapshots else NULL,
            inspected = inspected,
            identities = identities,
            complete = complete,
            valid = valid
        ))
    }
    valid <- package_metadata_startup_members_snapshots_valid(result)
    attr_inspected <- attr(result, "inspected", exact = TRUE)
    attr_identities <- attr(result, "identities", exact = TRUE)
    inspected <- if (is.character(attr_inspected)) {
        package_metadata_target_packages(attr_inspected)
    } else {
        unique(c(target_packages, names(result)))
    }
    complete <- valid &&
        !identical(attr(result, "complete", exact = TRUE), FALSE) &&
        all(target_packages %in% inspected)
    clean_snapshots <- result
    if (valid && (!is.null(attr(clean_snapshots, "complete", exact = TRUE)) ||
                !is.null(attr(clean_snapshots, "inspected", exact = TRUE)) ||
                !is.null(attr(clean_snapshots, "identities", exact = TRUE)) ||
                !is.null(attr(clean_snapshots, "errors", exact = TRUE)))) {
        attr(clean_snapshots, "complete") <- NULL
        attr(clean_snapshots, "inspected") <- NULL
        attr(clean_snapshots, "identities") <- NULL
        attr(clean_snapshots, "errors") <- NULL
    }
    if (is.null(attr_identities) && valid && length(clean_snapshots) > 0L) {
        ctx_pkgs <- clean_snapshots[[1L]]$identity$context$packages
        if (is.list(ctx_pkgs) && length(ctx_pkgs) > 0L) {
            pkg_names <- vapply(ctx_pkgs, function(x) {
                if (is.list(x) && is.character(x$package) && length(x$package) == 1L) x$package else ""
            }, character(1L))
            if (all(nzchar(pkg_names))) {
                attr_identities <- stats::setNames(ctx_pkgs, pkg_names)
            }
        }
    }
    list(
        .startup_members_unpacked = TRUE,
        snapshots = if (valid) clean_snapshots else NULL,
        inspected = inspected,
        identities = attr_identities,
        complete = complete,
        valid = valid
    )
}

package_metadata_startup_members_valid <- function(snapshots, requested_packages = character()) {
    unpacked <- package_metadata_startup_members_unpack(snapshots, requested_packages)
    isTRUE(unpacked$valid) && isTRUE(unpacked$complete)
}

package_metadata_startup_members_read <- function(bundle_key, requested_packages) {
    if (is.null(bundle_key)) return(NULL)
    target_packages <- package_metadata_target_packages(requested_packages)
    bundle <- package_metadata_cache_read(bundle_key$path, bundle_key$identity, function(value) {
        if (!is.list(value) || is.object(value) ||
                !package_metadata_startup_members_snapshots_valid(value$snapshots) ||
                !is.character(value$inspected) ||
                !all(target_packages %in% value$inspected) ||
                !all(names(value$snapshots) %in% value$inspected)) {
            return(FALSE)
        }
        required <- unique(c(startup_packages, target_packages, names(value$snapshots)))
        required <- required[!is.na(required) & nzchar(required)]
        all(required %in% names(value$manifest)) &&
            package_metadata_bundle_key_matches_manifest(bundle_key, value$manifest) &&
            package_metadata_manifest_valid(value$manifest, bundle_key$lib_paths) &&
            package_metadata_startup_members_identities_valid(
                value$snapshots, value$manifest, value$identities) &&
            package_metadata_missing_absent(value$missing, bundle_key$lib_paths) &&
            package_metadata_runtime_stable(names(value$manifest), bundle_key$lib_paths)
    })
    if (!is.null(bundle)) bundle$snapshots
}

package_metadata_startup_members_write <- function(bundle_key, requested_packages, snapshots) {
    if (is.null(bundle_key)) return(invisible(NULL))
    unpacked <- package_metadata_startup_members_unpack(snapshots, requested_packages)
    if (!isTRUE(unpacked$valid) || !isTRUE(unpacked$complete)) {
        return(invisible(NULL))
    }
    clean_snapshots <- unpacked$snapshots
    target_packages <- package_metadata_target_packages(requested_packages)
    s4_s7 <- unlist(lapply(clean_snapshots, function(snapshot) {
        c(snapshot$s4_dependencies, snapshot$s7_dependencies)
    }), use.names = FALSE)
    required <- unique(c(startup_packages, target_packages, names(clean_snapshots)))
    required <- required[!is.na(required) & nzchar(required)]
    traversal <- package_metadata_transitive_packages(c(required, s4_s7), bundle_key$lib_paths)
    if (!isTRUE(traversal$complete)) return(invisible(NULL))
    packages <- unique(c(required, traversal$packages))
    if (!package_metadata_runtime_stable(packages, bundle_key$lib_paths) ||
            !package_metadata_promises_absent(packages, bundle_key$lib_paths)) {
        return(invisible(NULL))
    }
    manifest <- package_metadata_manifest(packages, bundle_key$lib_paths)
    if (is.null(manifest) ||
            !package_metadata_bundle_key_matches_manifest(bundle_key, manifest) ||
            !package_metadata_startup_members_identities_valid(clean_snapshots, manifest, unpacked$identities)) {
        return(invisible(NULL))
    }
    package_metadata_cache_write(bundle_key$path, bundle_key$identity,
        list(
            manifest = manifest,
            identities = unpacked$identities,
            missing = traversal$missing,
            inspected = unpacked$inspected,
            snapshots = clean_snapshots
        ))
}

Try the languageserver package in your browser

Any scripts or data that you put into this service are public.

languageserver documentation built on Nov. 16, 2026, 9:07 a.m.