Error(s) in re-building vignettes:
--- re-building ‘rEDM-tutorial.Rmd’ using rmarkdown
2026-08-05 16:07:23.819 R[46701:69769] 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)
Traceback:

 2: FindNeighbors(embedding, lib_i, pred_i, knn, exclusionRadius = exclusionRadius,     validLib = validLib, libOverlap = idx$libOverlap, backend = backend,  1: 
Traceback:

Traceback:
RowCumsum(valid) 1: 
RowCumsum(valid) 2: 
 1:  2: FindNeighbors(embedding, lib_i, pred_i, knn, exclusionRadius = exclusionRadius,     validLib = validLib, libOverlap = idx$libOverlap, backend = backend,     verbose = verbose)FindNeighbors(embedding, lib_i, pred_i, knn, exclusionRadius = exclusionRadius,     verbose = verbose)
RowCumsum(valid)

 2: FindNeighbors(embedding, lib_i, pred_i, knn, exclusionRadius = exclusionRadius,  3:  3:     validLib = validLib, libOverlap = idx$libOverlap, backend = backend,     validLib = validLib, libOverlap = idx$libOverlap, backend = backend,     verbose = verbose)SMap(dataFrame, columns, target, lib, pred, E = E, Tp = Tp, knn = knn, SMap(dataFrame, columns, target, lib, pred, E = E, Tp = Tp, knn = knn,     verbose = verbose)    tau = tau, theta = th, exclusionRadius = exclusionRadius,     embedded = embedded, validLib = validLib, noTime = noTime, 

    ignoreNan = ignoreNan, backend = backend)    tau = tau, theta = th, exclusionRadius = exclusionRadius,  3:     embedded = embedded, validLib = validLib, noTime = noTime, 
    ignoreNan = ignoreNan, backend = backend)SMap(dataFrame, columns, target, lib, pred, E = E, Tp = Tp, knn = knn, 
 4: ComputeError(predictions$Observations, predictions$Predictions)
 3:     tau = tau, theta = th, exclusionRadius = exclusionRadius, SMap(dataFrame, columns, target, lib, pred, E = E, Tp = Tp, knn = knn,  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]], ...) 5: 
SweepRho(SMap(dataFrame, columns, target, lib, pred, E = E, Tp = Tp,     embedded = embedded, validLib = validLib, noTime = noTime,     ignoreNan = ignoreNan, backend = backend)
    tau = tau, theta = th, exclusionRadius = exclusionRadius,     embedded = embedded, validLib = validLib, noTime = noTime,  4: ComputeError(predictions$Observations, predictions$Predictions)
    knn = knn, tau = tau, theta = th, exclusionRadius = exclusionRadius,     embedded = embedded, validLib = validLib, noTime = noTime,     ignoreNan = ignoreNan, backend = backend)$predictions)
 6: FUN(X[[i]], ...)
 7:  7:     ignoreNan = ignoreNan, backend = backend) 5: lapply(X = S, FUN = FUN, ...)SweepRho(SMap(dataFrame, columns, target, lib, pred, E = E, Tp = Tp, lapply(X = S, FUN = FUN, ...)
 4: ComputeError(predictions$Observations, predictions$Predictions)
 8: doTryCatch(return(expr), name, parentenv, handler)
 9: 
tryCatchOne(expr, names, parentenv, handlers[[1L]]) 5:     knn = knn, tau = tau, theta = th, exclusionRadius = exclusionRadius, 
 8: SweepRho(SMap(dataFrame, columns, target, lib, pred, E = E, Tp = Tp, 
    knn = knn, tau = tau, theta = th, exclusionRadius = exclusionRadius, 10: doTryCatch(return(expr), name, parentenv, handler)tryCatchList(expr, classes, parentenv, handlers)    embedded = embedded, validLib = validLib, noTime = noTime, 
11: tryCatch(expr, error = function(e) {    embedded = embedded, validLib = validLib, noTime = noTime,     ignoreNan = ignoreNan, backend = backend)$predictions)
    ignoreNan = ignoreNan, backend = backend)$predictions)
 9: tryCatchOne(expr, names, parentenv, handlers[[1L]]) 6: 
FUN(X[[i]], ...)
 7: 
10: lapply(X = S, FUN = FUN, ...) 6: FUN(X[[i]], ...)
 7: lapply(X = S, FUN = FUN, ...)tryCatchList(expr, classes, parentenv, handlers)

11: tryCatch(expr, error = function(e) { 8:     call <- conditionCall(e)
 8: doTryCatch(return(expr), name, parentenv, handler)    if (!is.null(call)) {doTryCatch(return(expr), name, parentenv, handler)        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)     call <- conditionCall(e)            prefix <- paste0(prefix, "\n  ")
    }
    else prefix <- "Error : " 9:     msg <- paste0(prefix, conditionMessage(e), "\n") 9:     if (!is.null(call)) {    .Internal(seterrmessage(msg[1L]))    if (!silent && isTRUE(getOption("show.error.messages"))) {        if (identical(call[[1L]], quote(doTryCatch)))         cat(msg, file = outFile)        .Internal(printDeferredWarnings())    }    invisible(structure(msg, class = "try-error", condition = e))})
tryCatchOne(expr, names, parentenv, handlers[[1L]])12: 
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)            call <- sys.call(-4L)try(lapply(X = S, FUN = FUN, ...), silent = TRUE)        dcall <- deparse(call, nlines = 1L)
13:         dcall <- deparse(call, nlines = 1L)sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE))        prefix <- paste("Error in", dcall, ": ")tryCatchOne(expr, names, parentenv, handlers[[1L]])        prefix <- paste("Error in", dcall, ": ")
14: 
        LONG <- 75LFUN(X[[i]], ...)        sm <- strsplit(conditionMessage(e), "\n")[[1L]]        w <- 14L + nchar(dcall, type = "w") + nchar(sm[1L], type = "w")        if (is.na(w)) 
15: 10:         LONG <- 75LtryCatchList(expr, classes, parentenv, handlers)        sm <- strsplit(conditionMessage(e), "\n")[[1L]]
lapply(seq_len(cores), inner.do)
16: 11: tryCatch(expr, error = function(e) {    call <- conditionCall(e)            w <- 14L + nchar(dcall, type = "b") + nchar(sm[1L],         w <- 14L + nchar(dcall, type = "w") + nchar(sm[1L], type = "w")parallel::mclapply(values, worker, mc.cores = cores, mc.preschedule = TRUE)
17: doTryCatch(return(expr), name, parentenv, handler)                type = "b")        if (is.na(w))     if (!is.null(call)) {            w <- 14L + nchar(dcall, type = "b") + nchar(sm[1L],                 type = "b")        if (w > LONG)         if (identical(call[[1L]], quote(doTryCatch)))             call <- sys.call(-4L)
18: tryCatchOne(expr, names, parentenv, handlers[[1L]])
            prefix <- paste0(prefix, "\n  ")        if (w > LONG)     }        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"))) {19:     }    else prefix <- "Error : "    msg <- paste0(prefix, conditionMessage(e), "\n")            prefix <- paste0(prefix, "\n  ")    }    else prefix <- "Error : "    msg <- paste0(prefix, conditionMessage(e), "\n")    .Internal(seterrmessage(msg[1L]))    if (!silent && isTRUE(getOption("show.error.messages"))) {        cat(msg, file = outFile)        cat(msg, file = outFile)        .Internal(printDeferredWarnings())        .Internal(printDeferredWarnings())    }    invisible(structure(msg, class = "try-error", condition = e))    .Internal(seterrmessage(msg[1L]))    }tryCatchList(expr, classes, parentenv, handlers)    invisible(structure(msg, class = "try-error", condition = e))})
12: 
20: tryCatch(parallel::mclapply(values, worker, mc.cores = cores, try(lapply(X = S, FUN = FUN, ...), silent = TRUE)})
13: sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE))    mc.preschedule = TRUE), error = function(e) NULL)
12: 
    if (!silent && isTRUE(getOption("show.error.messages"))) {21: 
14: SweepApply(theta, worker, numProcess)
22: FUN(X[[i]], ...)
15: lapply(seq_len(cores), inner.do)
16: unlist(SweepApply(theta, worker, numProcess))try(lapply(X = S, FUN = FUN, ...), silent = TRUE)
13: parallel::mclapply(values, worker, mc.cores = cores, mc.preschedule = TRUE)
23: 
17: doTryCatch(return(expr), name, parentenv, handler)
18: tryCatchOne(expr, names, parentenv, handlers[[1L]])
19: tryCatchList(expr, classes, parentenv, handlers)sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE))        cat(msg, file = outFile)        .Internal(printDeferredWarnings())    }    invisible(structure(msg, class = "try-error", condition = e))})
20: tryCatch(parallel::mclapply(values, worker, mc.cores = cores, PredictNonlinear(dataFrame = Thrips, columns = "Thrips_imaginis",     mc.preschedule = TRUE), error = function(e) NULL)
21: 
SweepApply(theta, worker, numProcess)
22: unlist(SweepApply(theta, worker, numProcess))
    target = "Thrips_imaginis", lib = "1 73", pred = "1 73", 14: 12: try(lapply(X = S, FUN = FUN, ...), silent = TRUE)
13: sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE))
14: FUN(X[[i]], ...)
15: lapply(seq_len(cores), inner.do)
16: parallel::mclapply(values, worker, mc.cores = cores, mc.preschedule = TRUE)
FUN(X[[i]], ...)17: 
    E = E, showPlot = TRUE)

15: 23: 24: PredictNonlinear(dataFrame = Thrips, columns = "Thrips_imaginis", eval(expr, envir)    target = "Thrips_imaginis", lib = "1 73", pred = "1 73",     E = E, showPlot = TRUE)
24: eval(expr, envir)
25: eval(expr, envir)
26: 
lapply(seq_len(cores), inner.do)
withVisible(eval(expr, envir))16: parallel::mclapply(values, worker, mc.cores = cores, mc.preschedule = TRUE)
17: doTryCatch(return(expr), name, parentenv, handler)
18: tryCatchOne(expr, names, parentenv, handlers[[1L]])
19: tryCatchList(expr, classes, parentenv, handlers)25: 

doTryCatch(return(expr), name, parentenv, handler)20: tryCatch(parallel::mclapply(values, worker, mc.cores = cores,     mc.preschedule = TRUE), error = function(e) NULL)27: withCallingHandlers(code, error = function (e) 
rlang::entrace(e), message = function (cnd) {    watcher$capture_plot_and_output()    if (on_message$capture) {        watcher$push(cnd)eval(expr, envir)18: 
tryCatchOne(expr, names, parentenv, handlers[[1L]])    }    if (on_message$silence) {        invokeRestart("muffleMessage")    }}, warning = function (cnd) {    if (getOption("warn") >= 2 || getOption("warn") < 0) {

19: 26: withVisible(eval(expr, envir))
27: withCallingHandlers(code, error = function (e) rlang::entrace(e), message = function (cnd) {    watcher$capture_plot_and_output()    if (on_message$capture) {        watcher$push(cnd)    }        return()    }    watcher$capture_plot_and_output()    if (on_warning$capture) {        cnd <- sanitize_call(cnd)        watcher$push(cnd)    }    if (on_warning$silence) {        invokeRestart("muffleWarning")    }    if (on_message$silence) {        invokeRestart("muffleMessage")    }21: tryCatchList(expr, classes, parentenv, handlers)}, error = function (cnd) SweepApply(theta, worker, numProcess)}, warning = function (cnd) {
22: unlist(SweepApply(theta, worker, numProcess))    watcher$capture_plot_and_output()
{
    if (getOption("warn") >= 2 || getOption("warn") < 0) {        return()    cnd <- sanitize_call(cnd)20: 23: PredictNonlinear(dataFrame = Thrips, columns = "Thrips_imaginis",     target = "Thrips_imaginis", lib = "1 73", pred = "1 73",     E = E, showPlot = TRUE)
24: eval(expr, envir)
25: eval(expr, envir)    }    watcher$capture_plot_and_output()tryCatch(parallel::mclapply(values, worker, mc.cores = cores,     watcher$push(cnd)    switch(on_error, continue = invokeRestart("eval_continue"),         stop = invokeRestart("eval_stop"), error = NULL)})
    if (on_warning$capture) {
        cnd <- sanitize_call(cnd)28: eval(call)
26:     mc.preschedule = TRUE), error = function(e) NULL)
21: SweepApply(theta, worker, numProcess)        watcher$push(cnd)    }    if (on_warning$silence) {29: eval(call)
30: withVisible(eval(expr, envir))        invokeRestart("muffleWarning")    }}, error = function (cnd) {with_handlers({    for (expr in tle$exprs) {        ev <- withVisible(eval(expr, envir))        watcher$capture_plot_and_output()
22: unlist(SweepApply(theta, worker, numProcess))
23: PredictNonlinear(dataFrame = Thrips, columns = "Thrips_imaginis",     target = "Thrips_imaginis", lib = "1 73", pred = "1 73",     watcher$capture_plot_and_output()    cnd <- sanitize_call(cnd)    watcher$push(cnd)    switch(on_error, continue = invokeRestart("eval_continue"),         stop = invokeRestart("eval_stop"), error = NULL)    E = E, showPlot = TRUE)

        watcher$print_value(ev$value, ev$visible, envir)24: 27: eval(expr, envir)withCallingHandlers(code, error = function (e) rlang::entrace(e), message = function (cnd) {    watcher$capture_plot_and_output()    if (on_message$capture) {})
28: eval(call)    }        watcher$push(cnd)
25: eval(expr, envir)
26: withVisible(eval(expr, envir))
29: eval(call)

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

42: 47: eng_r(options)
43: 
29: 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)    }    TRUEblock_exec(params)35: 
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())             error <<- format(e)    })
47: with_options(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())             error <<- format(e)}, handlers)
with_options(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group),     }), list(rlang_trace_top_env = knit_global()))    error = function(e) {        if (progress && is.function(pb$interrupt))             pb$interrupt()31: doWithOneRestart(return(expr), restart)
        if (is_R_CMD_build() || is_R_CMD_check()) 
            error <<- format(e)    }), list(rlang_trace_top_env = knit_global()))
withOneRestart(withRestartList(expr, restarts[-nr]), restarts[[nr]])32: withOneRestart(expr, restarts[[1L]])48: 
48: 
xfun:::handle_error(with_options(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group), 36:     error = function(e) {        if (progress && is.function(pb$interrupt))             pb$interrupt()        if (is_R_CMD_build() || is_R_CMD_check()) xfun:::handle_error(with_options(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group),     error = function(e) {        if (progress && is.function(pb$interrupt)) 33: withRestartList(expr, restarts[-nr])
34: doWithOneRestart(return(expr), restart)
35: withOneRestart(withRestartList(expr, restarts[-nr]), restarts[[nr]])
36: withRestartList(expr, restarts)
37: withRestartList(expr, restarts)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: evaluate::evaluate(...)
39: 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,     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)))
42: eng_r(options)
43: block_exec(params)

44: 37:             error <<- format(e)call_block(x)
            pb$interrupt()        if (is_R_CMD_build() || is_R_CMD_check())             error <<- format(e)    }), list(rlang_trace_top_env = knit_global())), function(loc) {withRestarts(with_handlers({    }), list(rlang_trace_top_env = knit_global())), function(loc) {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())     for (expr in tle$exprs) {        ev <- withVisible(eval(expr, envir))        watcher$capture_plot_and_output()        watcher$print_value(ev$value, ev$visible, envir)    }    setwd(wd)    TRUE    setwd(wd)            error <<- format(e)}, handlers), eval_continue = function() TRUE, eval_stop = function() FALSE)
38: evaluate::evaluate(...)
39:     })
47: with_options(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())             error <<- format(e)    }), list(rlang_trace_top_env = knit_global()))
48: xfun:::handle_error(with_options(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()) evaluate(code, envir = env, new_device = FALSE, keep_warning = if (is.numeric(options$warning)) TRUE else options$warning,             error <<- format(e)    }), 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()))}, if (labels[i] != "") sprintf(" [%s]", labels[i]), get_loc)
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(),     write_utf8(res, output %n% stdout())    keep_message = if (is.numeric(options$message)) TRUE else options$message,     paste0("\nQuitting from ", loc, if (!is.null(error))     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))    output_dir = getwd(), ...)        paste0("\n", rule(), error, "\n", rule()))}, if (labels[i] != "") sprintf(" [%s]", labels[i]), get_loc)
    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: knitr::knit(knit_input, knit_output, envir = envir, quiet = quiet)
49: 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,     keep_message = if (is.numeric(options$message)) TRUE else options$message,     stop_on_error = if (is.numeric(options$error)) options$error else {51: rmarkdown::render(file, encoding = encoding, quiet = quiet, envir = globalenv(),     output_dir = getwd(), ...)
52: vweave_rmarkdown(...)
53: engine$weave(file, quiet = quiet, encoding = enc)52:         if (options$error && options$include)             0L        else 2L    }, output_handler = knit_handlers(options$render, options)))process_file(text, output)
54: vweave_rmarkdown(...)
50: 
42: eng_r(options)
43: block_exec(params)
44: doTryCatch(return(expr), name, parentenv, handler)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()55:         if (is_R_CMD_build() || is_R_CMD_check()) 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)            error <<- format(e)        output <- find_vignette_product(name, by = "texi2pdf",             engine = engine)53: engine$weave(file, quiet = quiet, encoding = enc)
knitr::knit(knit_input, knit_output, envir = envir, quiet = quiet)    }54: 
    outputs <- c(outputs, output)    })doTryCatch(return(expr), name, parentenv, handler)
47: 51: }, error = function(e) {    thisOK <<- FALSE    fails <<- c(fails, file)    message(gettextf("Error: processing vignette '%s' failed with diagnostics:\n%s", with_options(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group), 
    error = function(e) {rmarkdown::render(file, encoding = encoding, quiet = quiet, envir = globalenv(),     output_dir = getwd(), ...)
52: vweave_rmarkdown(...)55: tryCatchOne(expr, names, parentenv, handlers[[1L]])        if (progress && is.function(pb$interrupt)) 
53: engine$weave(file, quiet = quiet, encoding = enc)
54:         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/RtmpODmM7B/file829b4396a525.rds")
An irrecoverable exception occurred. R is aborting now ...
            pb$interrupt()
doTryCatch(return(expr), name, parentenv, handler)        if (is_R_CMD_build() || is_R_CMD_check())             error <<- format(e)
55: tryCatchOne(expr, names, parentenv, handlers[[1L]])
56: tryCatchList(expr, classes, parentenv, handlers)
57: 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) {tryCatch({    engine$weave(file, quiet = quiet, encoding = enc)    setwd(startdir)    }), list(rlang_trace_top_env = knit_global()))    thisOK <<- FALSE    fails <<- c(fails, file)
    message(gettextf("Error: processing vignette '%s' failed with diagnostics:\n%s", 48: xfun:::handle_error(with_options(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group),     error = function(e) {    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",         if (progress && is.function(pb$interrupt))         file, conditionMessage(e)))            pb$interrupt()        if (is_R_CMD_build() || is_R_CMD_check())             error <<- format(e)    }), 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)) })
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/RtmpODmM7B/file829b4396a525.rds")
        paste0("\n", rule(), error, "\n", rule()))}, if (labels[i] != "") sprintf(" [%s]", labels[i]), get_loc)            engine = engine)An irrecoverable exception occurred. R is aborting now ...
    }    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/RtmpODmM7B/file829b4396a525.rds")
An irrecoverable exception occurred. R is aborting now ...

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(),     output_dir = getwd(), ...)
52: vweave_rmarkdown(...)
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/RtmpODmM7B/file829b4396a525.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