Error(s) in re-building vignettes:
--- re-building ‘rEDM-tutorial.Rmd’ using rmarkdown
2026-08-13 13:59:19.984 R[41156:59922] XType: Using static font registry.

 *** caught segfault ***
address 0x110, cause 'invalid permissions'

 *** caught segfault ***
address 0x110, cause 'invalid permissions'

 *** caught segfault ***
address 0x110, cause 'invalid permissions'

 *** caught segfault ***
address 0x110, cause 'invalid permissions'

Traceback:
 1: RowCumsum(valid)
 2: FindNeighbors(embedding, lib_i, pred_i, knn, exclusionRadius = exclusionRadius,     validLib = validLib, libOverlap = idx$libOverlap, backend = backend,     verbose = verbose)
 3: SMap(dataFrame, columns, target, lib, pred, E = E, Tp = Tp, knn = knn,     tau = tau, theta = th, exclusionRadius = exclusionRadius,     embedded = embedded, validLib = validLib, noTime = noTime,     ignoreNan = ignoreNan, backend = backend)
 4: ComputeError(predictions$Observations, predictions$Predictions)
 5: SweepRho(SMap(dataFrame, columns, target, lib, pred, E = E, Tp = Tp,     knn = knn, tau = tau, theta = th, exclusionRadius = exclusionRadius,     embedded = embedded, validLib = validLib, noTime = noTime,     ignoreNan = ignoreNan, backend = backend)$predictions)
 6: FUN(X[[i]], ...)
 7: lapply(X = S, FUN = FUN, ...)
 8: doTryCatch(return(expr), name, parentenv, handler)
 9: tryCatchOne(expr, names, parentenv, handlers[[1L]])
10: tryCatchList(expr, classes, parentenv, handlers)
11: tryCatch(expr, error = function(e) {    call <- conditionCall(e)    if (!is.null(call)) {        if (identical(call[[1L]], quote(doTryCatch)))             call <- sys.call(-4L)        dcall <- deparse(call, nlines = 1L)        prefix <- paste("Error in", dcall, ": ")        LONG <- 75L        sm <- strsplit(conditionMessage(e), "\n")[[1L]]        w <- 14L + nchar(dcall, type = "w") + nchar(sm[1L], type = "w")        if (is.na(w))             w <- 14L + nchar(dcall, type = "b") + nchar(sm[1L],                 type = "b")        if (w > LONG)             prefix <- paste0(prefix, "\n  ")    }    else prefix <- "Error : "    msg <- paste0(prefix, conditionMessage(e), "\n")    .Internal(seterrmessage(msg[1L]))    if (!silent && isTRUE(getOption("show.error.messages"))) {
Traceback:
        cat(msg, file = outFile)        .Internal(printDeferredWarnings())    }    invisible(structure(msg, class = "try-error", condition = e))}) 1: RowCumsum(valid)
 2: FindNeighbors(embedding, lib_i, pred_i, knn, exclusionRadius = exclusionRadius,     validLib = validLib, libOverlap = idx$libOverlap, backend = backend, 
12: try(lapply(X = S, FUN = FUN, ...), silent = TRUE)
13: sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE))
14:     verbose = verbose)FUN(X[[i]], ...)
15: lapply(seq_len(cores), inner.do)
16: parallel::mclapply(values, worker, mc.cores = cores, mc.preschedule = TRUE)
 3: SMap(dataFrame, columns, target, lib, pred, E = E, Tp = Tp, knn = knn, 
17: doTryCatch(return(expr), name, parentenv, handler)
18:     tau = tau, theta = th, exclusionRadius = exclusionRadius,     embedded = embedded, validLib = validLib, noTime = noTime,     ignoreNan = ignoreNan, backend = backend)
 4: ComputeError(predictions$Observations, predictions$Predictions)
 5: tryCatchOne(expr, names, parentenv, handlers[[1L]])
19: tryCatchList(expr, classes, parentenv, handlers)
20: tryCatch(parallel::mclapply(values, worker, mc.cores = cores,     mc.preschedule = TRUE), error = function(e) NULL)
SweepRho(SMap(dataFrame, columns, target, lib, pred, E = E, Tp = Tp,     knn = knn, tau = tau, theta = th, exclusionRadius = exclusionRadius,     embedded = embedded, validLib = validLib, noTime = noTime,     ignoreNan = ignoreNan, backend = backend)$predictions)
 6: FUN(X[[i]], ...)
 7: lapply(X = S, FUN = FUN, ...)21: SweepApply(theta, worker, numProcess)
22: unlist(SweepApply(theta, worker, numProcess))
23: PredictNonlinear(dataFrame = Thrips, columns = "Thrips_imaginis",     target = "Thrips_imaginis", lib = "1 73", pred = "1 73",     E = E, showPlot = TRUE)

 8: doTryCatch(return(expr), name, parentenv, handler)
 9: 
Traceback:
tryCatchOne(expr, names, parentenv, handlers[[1L]])
10: 24: eval(expr, envir)
25: eval(expr, envir) 1: RowCumsum(valid)
 2: FindNeighbors(embedding, lib_i, pred_i, knn, exclusionRadius = exclusionRadius, tryCatchList(expr, classes, parentenv, handlers)
11: tryCatch(expr, error = function(e) {    call <- conditionCall(e)
26:     validLib = validLib, libOverlap = idx$libOverlap, backend = backend,     verbose = verbose)
    if (!is.null(call)) { 3: SMap(dataFrame, columns, target, lib, pred, E = E, Tp = Tp, knn = knn,         if (identical(call[[1L]], quote(doTryCatch)))             call <- sys.call(-4L)        dcall <- deparse(call, nlines = 1L)        prefix <- paste("Error in", dcall, ": ")        LONG <- 75L        sm <- strsplit(conditionMessage(e), "\n")[[1L]]    tau = tau, theta = th, exclusionRadius = exclusionRadius, withVisible(eval(expr, envir))
Traceback:
    embedded = embedded, validLib = validLib, noTime = noTime, 
27: withCallingHandlers(code, error = function (e)     ignoreNan = ignoreNan, backend = backend)rlang::entrace(e), message = function (cnd) 
        w <- 14L + nchar(dcall, type = "w") + nchar(sm[1L], type = "w") 4:  1: RowCumsum(valid)        if (is.na(w))             w <- 14L + nchar(dcall, type = "b") + nchar(sm[1L],                 type = "b")        if (w > LONG)             prefix <- paste0(prefix, "\n  ")ComputeError(predictions$Observations, predictions$Predictions)

    } 2: FindNeighbors(embedding, lib_i, pred_i, knn, exclusionRadius = exclusionRadius,  5:     validLib = validLib, libOverlap = idx$libOverlap, backend = backend,     else prefix <- "Error : "{    watcher$capture_plot_and_output()    if (on_message$capture) {    verbose = verbose)
 3:     msg <- paste0(prefix, conditionMessage(e), "\n")    .Internal(seterrmessage(msg[1L]))    if (!silent && isTRUE(getOption("show.error.messages"))) {        cat(msg, file = outFile)        .Internal(printDeferredWarnings())    }        watcher$push(cnd)SMap(dataFrame, columns, target, lib, pred, E = E, Tp = Tp, knn = knn,     }    invisible(structure(msg, class = "try-error", condition = e))    tau = tau, theta = th, exclusionRadius = exclusionRadius,     if (on_message$silence) {})    embedded = embedded, validLib = validLib, noTime = noTime, 
    ignoreNan = ignoreNan, backend = backend)12: try(lapply(X = S, FUN = FUN, ...), silent = TRUE)
13: 
SweepRho(SMap(dataFrame, columns, target, lib, pred, E = E, Tp = Tp, sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE))
14: FUN(X[[i]], ...)
15: lapply(seq_len(cores), inner.do)
16:  4: ComputeError(predictions$Observations, predictions$Predictions)
 5: SweepRho(SMap(dataFrame, columns, target, lib, pred, E = E, Tp = Tp,     knn = knn, tau = tau, theta = th, exclusionRadius = exclusionRadius,     embedded = embedded, validLib = validLib, noTime = noTime,     ignoreNan = ignoreNan, backend = backend)$predictions)
 6:     knn = knn, tau = tau, theta = th, exclusionRadius = exclusionRadius, parallel::mclapply(values, worker, mc.cores = cores, mc.preschedule = TRUE)FUN(X[[i]], ...)    embedded = embedded, validLib = validLib, noTime = noTime,     ignoreNan = ignoreNan, backend = backend)$predictions)

 7: lapply(X = S, FUN = FUN, ...)
 8: 17: doTryCatch(return(expr), name, parentenv, handler)        invokeRestart("muffleMessage")

 6: FUN(X[[i]], ...)
 7: lapply(X = S, FUN = FUN, ...)
 8: doTryCatch(return(expr), name, parentenv, handler) 9: 
tryCatchOne(expr, names, parentenv, handlers[[1L]])doTryCatch(return(expr), name, parentenv, handler)

18: 10: tryCatchOne(expr, names, parentenv, handlers[[1L]])tryCatchList(expr, classes, parentenv, handlers)
    }19:  9: }, warning = function (cnd) tryCatchList(expr, classes, parentenv, handlers)tryCatchOne(expr, names, parentenv, handlers[[1L]])

11: tryCatch(expr, error = function(e) {    call <- conditionCall(e)    if (!is.null(call)) {
{20:     if (getOption("warn") >= 2 || getOption("warn") < 0) {        return()    }    watcher$capture_plot_and_output()10: tryCatchList(expr, classes, parentenv, handlers)        if (identical(call[[1L]], quote(doTryCatch)))             call <- sys.call(-4L)        dcall <- deparse(call, nlines = 1L)    if (on_warning$capture) {tryCatch(parallel::mclapply(values, worker, mc.cores = cores, 
11: tryCatch(expr, error = function(e) {    call <- conditionCall(e)        cnd <- sanitize_call(cnd)    mc.preschedule = TRUE), error = function(e) NULL)        prefix <- paste("Error in", dcall, ": ")        LONG <- 75L
        sm <- strsplit(conditionMessage(e), "\n")[[1L]]21:         w <- 14L + nchar(dcall, type = "w") + nchar(sm[1L], type = "w")        if (is.na(w))             w <- 14L + nchar(dcall, type = "b") + nchar(sm[1L], SweepApply(theta, worker, numProcess)        watcher$push(cnd)    if (!is.null(call)) {
22:         if (identical(call[[1L]], quote(doTryCatch))) unlist(SweepApply(theta, worker, numProcess))            call <- sys.call(-4L)    }        dcall <- deparse(call, nlines = 1L)        prefix <- paste("Error in", dcall, ": ")        LONG <- 75L        sm <- strsplit(conditionMessage(e), "\n")[[1L]]        w <- 14L + nchar(dcall, type = "w") + nchar(sm[1L], type = "w")
        if (is.na(w))     if (on_warning$silence) {        invokeRestart("muffleWarning")    }}, error = function (cnd)                 type = "b"){    watcher$capture_plot_and_output()    cnd <- sanitize_call(cnd)    watcher$push(cnd)    switch(on_error, continue = invokeRestart("eval_continue"),             w <- 14L + nchar(dcall, type = "b") + nchar(sm[1L],                 type = "b")        if (w > LONG)         stop = invokeRestart("eval_stop"), error = NULL)            prefix <- paste0(prefix, "\n  ")23:         if (w > LONG) PredictNonlinear(dataFrame = Thrips, columns = "Thrips_imaginis",             prefix <- paste0(prefix, "\n  ")})
28:     }eval(call)    else prefix <- "Error : "    }    else prefix <- "Error : "    msg <- paste0(prefix, conditionMessage(e), "\n")    .Internal(seterrmessage(msg[1L]))    if (!silent && isTRUE(getOption("show.error.messages"))) {        cat(msg, file = outFile)        .Internal(printDeferredWarnings())    }    msg <- paste0(prefix, conditionMessage(e), "\n")    target = "Thrips_imaginis", lib = "1 73", pred = "1 73", 
    E = E, showPlot = TRUE)
    invisible(structure(msg, class = "try-error", condition = e))24: })eval(expr, envir)
12: try(lapply(X = S, FUN = FUN, ...), silent = TRUE)
13: sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE))
    .Internal(seterrmessage(msg[1L]))14:     if (!silent && isTRUE(getOption("show.error.messages"))) {        cat(msg, file = outFile)
29: 25: FUN(X[[i]], ...)eval(expr, envir)        .Internal(printDeferredWarnings())eval(call)
30: with_handlers({    for (expr in tle$exprs) {        ev <- withVisible(eval(expr, envir))        watcher$capture_plot_and_output()        watcher$print_value(ev$value, ev$visible, envir)    }    }    TRUE    invisible(structure(msg, class = "try-error", condition = e))})

}, handlers)
26: 12: 15: lapply(seq_len(cores), inner.do)
try(lapply(X = S, FUN = FUN, ...), silent = TRUE)withVisible(eval(expr, envir))


16: parallel::mclapply(values, worker, mc.cores = cores, mc.preschedule = TRUE)
27: 31: withCallingHandlers(code, error = function (e) rlang::entrace(e), message = function (cnd) {    watcher$capture_plot_and_output()doWithOneRestart(return(expr), restart)17:     if (on_message$capture) {doTryCatch(return(expr), name, parentenv, handler)

18: 32: withOneRestart(expr, restarts[[1L]])
33: withRestartList(expr, restarts[-nr])
34: doWithOneRestart(return(expr), restart)
35: withOneRestart(withRestartList(expr, restarts[-nr]), restarts[[nr]])
36:         watcher$push(cnd)tryCatchOne(expr, names, parentenv, handlers[[1L]])13: sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE))
    }withRestartList(expr, restarts)
14: 
FUN(X[[i]], ...)    if (on_message$silence) {19: tryCatchList(expr, classes, parentenv, handlers)
20: tryCatch(parallel::mclapply(values, worker, mc.cores = cores,     mc.preschedule = TRUE), error = function(e) NULL)
21: SweepApply(theta, worker, numProcess)        invokeRestart("muffleMessage")    }
37: 22: }, warning = function (cnd) 
unlist(SweepApply(theta, worker, numProcess)){    if (getOption("warn") >= 2 || getOption("warn") < 0) {        return()15: 
    }lapply(seq_len(cores), inner.do)
    watcher$capture_plot_and_output()    if (on_warning$capture) {16:         cnd <- sanitize_call(cnd)parallel::mclapply(values, worker, mc.cores = cores, mc.preschedule = TRUE)        watcher$push(cnd)    }
23: withRestarts(with_handlers({    if (on_warning$silence) {    for (expr in tle$exprs) {PredictNonlinear(dataFrame = Thrips, columns = "Thrips_imaginis",         invokeRestart("muffleWarning")    target = "Thrips_imaginis", lib = "1 73", pred = "1 73",     E = E, showPlot = TRUE)
    }        ev <- withVisible(eval(expr, envir))24: eval(expr, envir)}, error = function (cnd) 
17: 25: doTryCatch(return(expr), name, parentenv, handler)        watcher$capture_plot_and_output(){eval(expr, envir)        watcher$print_value(ev$value, ev$visible, envir)
26:     watcher$capture_plot_and_output()withVisible(eval(expr, envir))
18:     }tryCatchOne(expr, names, parentenv, handlers[[1L]])    TRUE
}, handlers), eval_continue = function() TRUE, eval_stop = function() FALSE)19:     cnd <- sanitize_call(cnd)
27: withCallingHandlers(code, error = function (e)     watcher$push(cnd)rlang::entrace(e), message = function (cnd) {    watcher$capture_plot_and_output()    if (on_message$capture) {    switch(on_error, continue = invokeRestart("eval_continue"), 
        watcher$push(cnd)38: evaluate::evaluate(...)        stop = invokeRestart("eval_stop"), error = NULL)tryCatchList(expr, classes, parentenv, handlers)    }
    if (on_message$silence) {
})20: 39: 
tryCatch(parallel::mclapply(values, worker, mc.cores = cores,     mc.preschedule = TRUE), error = function(e) NULL)
21: SweepApply(theta, worker, numProcess)
28: evaluate(code, envir = env, new_device = FALSE, keep_warning = if (is.numeric(options$warning)) TRUE else options$warning, eval(call)22: unlist(SweepApply(theta, worker, numProcess))
23: 
PredictNonlinear(dataFrame = Thrips, columns = "Thrips_imaginis",     keep_message = if (is.numeric(options$message)) TRUE else options$message,     stop_on_error = if (is.numeric(options$error)) options$error else {        invokeRestart("muffleMessage")29: eval(call)
30: with_handlers({    }        if (options$error && options$include) }, warning = function (cnd)             0L    target = "Thrips_imaginis", lib = "1 73", pred = "1 73",     E = E, showPlot = TRUE){    for (expr in tle$exprs) {        else 2L        ev <- withVisible(eval(expr, envir))    }, output_handler = knit_handlers(options$render, options))    if (getOption("warn") >= 2 || getOption("warn") < 0) {        return()
    }
        watcher$capture_plot_and_output()40:         watcher$print_value(ev$value, ev$visible, envir)    }24:     TRUE    watcher$capture_plot_and_output()in_dir(input_dir(), expr)eval(expr, envir)}, handlers)
31: 
doWithOneRestart(return(expr), restart)

    if (on_warning$capture) {        cnd <- sanitize_call(cnd)41: 32: in_input_dir(evaluate(code, envir = env, new_device = FALSE,     keep_warning = if (is.numeric(options$warning)) TRUE else options$warning,     keep_message = if (is.numeric(options$message)) TRUE else options$message,     stop_on_error = if (is.numeric(options$error)) options$error else {        if (options$error && options$include) 25: eval(expr, envir)withOneRestart(expr, restarts[[1L]])            0L        watcher$push(cnd)        else 2L

33:     }, output_handler = knit_handlers(options$render, options)))    }
42:     if (on_warning$silence) {        invokeRestart("muffleWarning")26: eng_r(options)    }}, error = function (cnd) {    watcher$capture_plot_and_output()    cnd <- sanitize_call(cnd)
withRestartList(expr, restarts[-nr])
    watcher$push(cnd)withVisible(eval(expr, envir))43: 
block_exec(params)    switch(on_error, continue = invokeRestart("eval_continue"), 27: withCallingHandlers(code, error = function (e) rlang::entrace(e), message = function (cnd) 34: doWithOneRestart(return(expr), restart){        stop = invokeRestart("eval_stop"), error = NULL)
})

35: withOneRestart(withRestartList(expr, restarts[-nr]), restarts[[nr]])
36: withRestartList(expr, restarts)    watcher$capture_plot_and_output()
44: 37: withRestarts(with_handlers({    for (expr in tle$exprs) {        ev <- withVisible(eval(expr, envir))        watcher$capture_plot_and_output()        watcher$print_value(ev$value, ev$visible, envir)    }    TRUE}, handlers), eval_continue = function() TRUE, eval_stop = function() FALSE)
38: call_block(x)
evaluate::evaluate(...)    if (on_message$capture) {        watcher$push(cnd)    }    if (on_message$silence) {        invokeRestart("muffleMessage")    }}, warning = function (cnd) {    if (getOption("warn") >= 2 || getOption("warn") < 0) {        return()    }    watcher$capture_plot_and_output()    if (on_warning$capture) {28: 
39: 45: process_group(group)        cnd <- sanitize_call(cnd)eval(call)
29:         watcher$push(cnd)evaluate(code, envir = env, new_device = FALSE, keep_warning = if (is.numeric(options$warning)) TRUE else options$warning,     }eval(call)
30: with_handlers({
    keep_message = if (is.numeric(options$message)) TRUE else options$message,     for (expr in tle$exprs) {    if (on_warning$silence) {        ev <- withVisible(eval(expr, envir))        watcher$capture_plot_and_output()    stop_on_error = if (is.numeric(options$error)) options$error else {        invokeRestart("muffleWarning")    }        watcher$print_value(ev$value, ev$visible, envir)}, error = function (cnd) {    watcher$capture_plot_and_output()        if (options$error && options$include)     cnd <- sanitize_call(cnd)    }    watcher$push(cnd)    TRUE            0L}, handlers)        else 2L    }, output_handler = knit_handlers(options$render, options))46: 
    switch(on_error, continue = invokeRestart("eval_continue"), 
        stop = invokeRestart("eval_stop"), error = NULL)withCallingHandlers(if (tangle) process_tangle(group) else process_group(group), })
    error = function(e) {40:         if (progress && is.function(pb$interrupt)) in_dir(input_dir(), expr)            pb$interrupt()31:         if (is_R_CMD_build() || is_R_CMD_check())             error <<- format(e)    })
28: 
doWithOneRestart(return(expr), restart)
41: in_input_dir(evaluate(code, envir = env, new_device = FALSE, 32: withOneRestart(expr, restarts[[1L]])
33: withRestartList(expr, restarts[-nr])
47:     keep_warning = if (is.numeric(options$warning)) TRUE else options$warning, eval(call)34: doWithOneRestart(return(expr), restart)
35: withOneRestart(withRestartList(expr, restarts[-nr]), restarts[[nr]])
    keep_message = if (is.numeric(options$message)) TRUE else options$message, 
36: 29:     stop_on_error = if (is.numeric(options$error)) options$error else {withRestartList(expr, restarts)        if (options$error && options$include) 
            0L        else 2Leval(call)
30: 37:     }, output_handler = knit_handlers(options$render, options)))
42: eng_r(options)
withRestarts(with_handlers({43: with_options(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group),     error = function(e) {with_handlers({block_exec(params)    for (expr in tle$exprs) {    for (expr in tle$exprs) {        ev <- withVisible(eval(expr, envir))        if (progress && is.function(pb$interrupt))         watcher$capture_plot_and_output()            pb$interrupt()        ev <- withVisible(eval(expr, envir))        watcher$print_value(ev$value, ev$visible, envir)    }        if (is_R_CMD_build() || is_R_CMD_check())             error <<- format(e)        watcher$capture_plot_and_output()    TRUE
44:         watcher$print_value(ev$value, ev$visible, envir)    }), list(rlang_trace_top_env = knit_global()))call_block(x)}, handlers)
31: doWithOneRestart(return(expr), restart)

    }
32: 48: withOneRestart(expr, restarts[[1L]])
xfun:::handle_error(with_options(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group), 45: process_group(group)33:     error = function(e) {    TRUE        if (progress && is.function(pb$interrupt)) withRestartList(expr, restarts[-nr])            pb$interrupt()
34: doWithOneRestart(return(expr), restart)        if (is_R_CMD_build() || is_R_CMD_check()) 
}, handlers), eval_continue = function() TRUE, eval_stop = function() FALSE)

35: 46:             error <<- format(e)withOneRestart(withRestartList(expr, restarts[-nr]), restarts[[nr]])    }), list(rlang_trace_top_env = knit_global())), function(loc) {
36: withRestartList(expr, restarts)
37:     setwd(wd)    write_utf8(res, output %n% stdout())    paste0("\nQuitting from ", loc, if (!is.null(error)) withCallingHandlers(if (tangle) process_tangle(group) else process_group(group),         paste0("\n", rule(), error, "\n", rule()))38: withRestarts(with_handlers({    error = function(e) {}, if (labels[i] != "") sprintf(" [%s]", labels[i]), get_loc)        if (progress && is.function(pb$interrupt))             pb$interrupt()        if (is_R_CMD_build() || is_R_CMD_check())     for (expr in tle$exprs) {        ev <- withVisible(eval(expr, envir))        watcher$capture_plot_and_output()        watcher$print_value(ev$value, ev$visible, envir)    }    TRUE}, handlers), eval_continue = function() TRUE, eval_stop = function() FALSE)
38: evaluate::evaluate(...)            error <<- format(e)    })
47: 
with_options(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group), evaluate::evaluate(...)49: 
39:     error = function(e) {evaluate(code, envir = env, new_device = FALSE, keep_warning = if (is.numeric(options$warning)) TRUE else options$warning,     keep_message = if (is.numeric(options$message)) TRUE else options$message,     stop_on_error = if (is.numeric(options$error)) options$error else {        if (options$error && options$include)             0L        else 2L    }, output_handler = knit_handlers(options$render, options))
40: in_dir(input_dir(), expr)
41: in_input_dir(evaluate(code, envir = env, new_device = FALSE,     keep_warning = if (is.numeric(options$warning)) TRUE else options$warning, process_file(text, output)

50: 39:         if (progress && is.function(pb$interrupt)) evaluate(code, envir = env, new_device = FALSE, keep_warning = if (is.numeric(options$warning)) TRUE else options$warning,     keep_message = if (is.numeric(options$message)) TRUE else options$message,     keep_message = if (is.numeric(options$message)) TRUE else options$message,     stop_on_error = if (is.numeric(options$error)) options$error else {knitr::knit(knit_input, knit_output, envir = envir, quiet = quiet)            pb$interrupt()    stop_on_error = if (is.numeric(options$error)) options$error else {        if (options$error && options$include)             0L        else 2L    }, output_handler = knit_handlers(options$render, options))
40: in_dir(input_dir(), expr)

        if (is_R_CMD_build() || is_R_CMD_check()) 51:         if (options$error && options$include) 41:             error <<- format(e)in_input_dir(evaluate(code, envir = env, new_device = FALSE, rmarkdown::render(file, encoding = encoding, quiet = quiet, envir = globalenv(),     output_dir = getwd(), ...)    }), list(rlang_trace_top_env = knit_global()))
52: vweave_rmarkdown(...)            0L        else 2L

48:     }, output_handler = knit_handlers(options$render, options)))xfun:::handle_error(with_options(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group),     error = function(e) {53: engine$weave(file, quiet = quiet, encoding = enc)
    keep_warning = if (is.numeric(options$warning)) TRUE else options$warning,         if (progress && is.function(pb$interrupt)) 
42: eng_r(options)            pb$interrupt()54:         if (is_R_CMD_build() || is_R_CMD_check()) 
    keep_message = if (is.numeric(options$message)) TRUE else options$message,             error <<- format(e)    stop_on_error = if (is.numeric(options$error)) options$error else {        if (options$error && options$include) 43:             0LdoTryCatch(return(expr), name, parentenv, handler)
55: block_exec(params)tryCatchOne(expr, names, parentenv, handlers[[1L]])    }), list(rlang_trace_top_env = knit_global())), function(loc) {    setwd(wd)    write_utf8(res, output %n% stdout())    paste0("\nQuitting from ", loc, if (!is.null(error))         paste0("\n", rule(), error, "\n", rule()))        else 2L    }, output_handler = knit_handlers(options$render, options)))
42: eng_r(options)
43: block_exec(params)
44: call_block(x)
45: process_group(group)
46: withCallingHandlers(if (tangle) process_tangle(group) else process_group(group),     error = function(e) {        if (progress && is.function(pb$interrupt)) 
            pb$interrupt()        if (is_R_CMD_build() || is_R_CMD_check()) 44: 
56: tryCatchList(expr, classes, parentenv, handlers)
57: tryCatch({    engine$weave(file, quiet = quiet, encoding = enc)            error <<- format(e)    setwd(startdir)}, if (labels[i] != "") sprintf(" [%s]", labels[i]), get_loc)
    })call_block(x)
    output <- find_vignette_product(name, by = "weave", engine = engine)
    if (!have.makefile && vignette_is_tex(output)) {        texi2pdf(file = output, clean = FALSE, quiet = quiet)        output <- find_vignette_product(name, by = "texi2pdf",             engine = engine)49: 45: process_group(group)
    }    outputs <- c(outputs, output)47: with_options(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group), }, error = function(e) {    thisOK <<- FALSE46: process_file(text, output)    error = function(e) {
    fails <<- c(fails, file)withCallingHandlers(if (tangle) process_tangle(group) else process_group(group), 50:         if (progress && is.function(pb$interrupt))             pb$interrupt()    error = function(e) {knitr::knit(knit_input, knit_output, envir = envir, quiet = quiet)
    message(gettextf("Error: processing vignette '%s' failed with diagnostics:\n%s",         file, conditionMessage(e)))})
        if (is_R_CMD_build() || is_R_CMD_check()) 51:         if (progress && is.function(pb$interrupt)) rmarkdown::render(file, encoding = encoding, quiet = quiet, envir = globalenv(), 58: tools::buildVignettes(dir = "/Volumes/Builds/packages/big-sur-arm64/results/4.5/rEDM.Rcheck/vign_test/rEDM",     skip = TRUE, ser_elibs = "/Volumes/Temp/tmp/RtmpnIYlrJ/file6a535e78d330.rds")
An irrecoverable exception occurred. R is aborting now ...
    output_dir = getwd(), ...)            error <<- format(e)
    }), list(rlang_trace_top_env = knit_global()))52: vweave_rmarkdown(...)
53: engine$weave(file, quiet = quiet, encoding = enc)
            pb$interrupt()
        if (is_R_CMD_build() || is_R_CMD_check())             error <<- format(e)48:     })
xfun:::handle_error(with_options(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group),     error = function(e) {54: doTryCatch(return(expr), name, parentenv, handler)
55:         if (progress && is.function(pb$interrupt)) tryCatchOne(expr, names, parentenv, handlers[[1L]])
56: 47: with_options(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group), tryCatchList(expr, classes, parentenv, handlers)            pb$interrupt()        if (is_R_CMD_build() || is_R_CMD_check())             error <<- format(e)
57:     error = function(e) {        if (progress && is.function(pb$interrupt)) tryCatch({    engine$weave(file, quiet = quiet, encoding = enc)            pb$interrupt()        if (is_R_CMD_build() || is_R_CMD_check())     setwd(startdir)            error <<- format(e)    }), list(rlang_trace_top_env = knit_global()))    }), list(rlang_trace_top_env = knit_global())), function(loc) {    output <- find_vignette_product(name, by = "weave", engine = engine)    setwd(wd)
48: xfun:::handle_error(with_options(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group),     error = function(e) {    if (!have.makefile && vignette_is_tex(output)) {    write_utf8(res, output %n% stdout())    paste0("\nQuitting from ", loc, if (!is.null(error))         paste0("\n", rule(), error, "\n", rule()))}, if (labels[i] != "") sprintf(" [%s]", labels[i]), get_loc)
49: process_file(text, output)
50:         if (progress && is.function(pb$interrupt)) knitr::knit(knit_input, knit_output, envir = envir, quiet = quiet)
            pb$interrupt()        if (is_R_CMD_build() || is_R_CMD_check())         texi2pdf(file = output, clean = FALSE, quiet = quiet)51: rmarkdown::render(file, encoding = encoding, quiet = quiet, envir = globalenv(),         output <- find_vignette_product(name, by = "texi2pdf",             engine = engine)    }    outputs <- c(outputs, output)}, error = function(e) {            error <<- format(e)    }), list(rlang_trace_top_env = knit_global())), function(loc) {    output_dir = getwd(), ...)
52:     thisOK <<- FALSE    fails <<- c(fails, file)    message(gettextf("Error: processing vignette '%s' failed with diagnostics:\n%s",         file, conditionMessage(e)))})    setwd(wd)
    write_utf8(res, output %n% stdout())58:     paste0("\nQuitting from ", loc, if (!is.null(error)) vweave_rmarkdown(...)        paste0("\n", rule(), error, "\n", rule()))}, if (labels[i] != "") sprintf(" [%s]", labels[i]), get_loc)
tools::buildVignettes(dir = "/Volumes/Builds/packages/big-sur-arm64/results/4.5/rEDM.Rcheck/vign_test/rEDM",     skip = TRUE, ser_elibs = "/Volumes/Temp/tmp/RtmpnIYlrJ/file6a535e78d330.rds")49: process_file(text, output)
50: knitr::knit(knit_input, knit_output, envir = envir, quiet = quiet)
51: rmarkdown::render(file, encoding = encoding, quiet = quiet, envir = globalenv(), 
53: engine$weave(file, quiet = quiet, encoding = enc)    output_dir = getwd(), ...)


54: doTryCatch(return(expr), name, parentenv, handler)An irrecoverable exception occurred. R is aborting now ...

55: tryCatchOne(expr, names, parentenv, handlers[[1L]])
56: tryCatchList(expr, classes, parentenv, handlers)
57: tryCatch({52: vweave_rmarkdown(...)
    engine$weave(file, quiet = quiet, encoding = enc)    setwd(startdir)    output <- find_vignette_product(name, by = "weave", engine = engine)    if (!have.makefile && vignette_is_tex(output)) {        texi2pdf(file = output, clean = FALSE, quiet = quiet)        output <- find_vignette_product(name, by = "texi2pdf",             engine = engine)    }    outputs <- c(outputs, output)}, error = function(e) {    thisOK <<- FALSE    fails <<- c(fails, file)    message(gettextf("Error: processing vignette '%s' failed with diagnostics:\n%s",         file, conditionMessage(e)))})
58: tools::buildVignettes(dir = "/Volumes/Builds/packages/big-sur-arm64/results/4.5/rEDM.Rcheck/vign_test/rEDM",     skip = TRUE, ser_elibs = "/Volumes/Temp/tmp/RtmpnIYlrJ/file6a535e78d330.rds")
An irrecoverable exception occurred. R is aborting now ...
53: engine$weave(file, quiet = quiet, encoding = enc)
54: doTryCatch(return(expr), name, parentenv, handler)
55: tryCatchOne(expr, names, parentenv, handlers[[1L]])
56: tryCatchList(expr, classes, parentenv, handlers)
57: tryCatch({    engine$weave(file, quiet = quiet, encoding = enc)    setwd(startdir)    output <- find_vignette_product(name, by = "weave", engine = engine)    if (!have.makefile && vignette_is_tex(output)) {        texi2pdf(file = output, clean = FALSE, quiet = quiet)        output <- find_vignette_product(name, by = "texi2pdf",             engine = engine)    }    outputs <- c(outputs, output)}, error = function(e) {    thisOK <<- FALSE    fails <<- c(fails, file)    message(gettextf("Error: processing vignette '%s' failed with diagnostics:\n%s",         file, conditionMessage(e)))})
58: tools::buildVignettes(dir = "/Volumes/Builds/packages/big-sur-arm64/results/4.5/rEDM.Rcheck/vign_test/rEDM",     skip = TRUE, ser_elibs = "/Volumes/Temp/tmp/RtmpnIYlrJ/file6a535e78d330.rds")
An irrecoverable exception occurred. R is aborting now ...

Quitting from rEDM-tutorial.Rmd:466-469 [smap_thrips]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
<error/rlang_error>
Error in `data.frame()`:
! arguments imply differing number of rows: 15, 0
---
Backtrace:
    ▆
 1. └─rEDM::PredictNonlinear(...)
 2.   └─base::data.frame(Theta = theta, rho = rho)
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Error: processing vignette 'rEDM-tutorial.Rmd' failed with diagnostics:
arguments imply differing number of rows: 15, 0
--- failed re-building ‘rEDM-tutorial.Rmd’

SUMMARY: processing the following file failed:
  ‘rEDM-tutorial.Rmd’

Error: Vignette re-building failed.
Execution halted