Error(s) in re-building vignettes:
--- re-building ‘rEDM-tutorial.Rmd’ using rmarkdown
2026-08-09 15:27:09.948 R[43344:63015] 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, 
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,     ignoreNan = ignoreNan, backend = backend)$predictions)
    tau = tau, theta = th, exclusionRadius = exclusionRadius,     embedded = embedded, validLib = validLib, noTime = noTime,     ignoreNan = ignoreNan, backend = backend) 6: 
 4: FUN(X[[i]], ...)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, 
 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"))) {        cat(msg, file = outFile)        .Internal(printDeferredWarnings())    }    invisible(structure(msg, class = "try-error", condition = e))})
12:     embedded = embedded, validLib = validLib, noTime = noTime,     ignoreNan = ignoreNan, backend = backend)$predictions)
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)
17: doTryCatch(return(expr), name, parentenv, handler)
18: tryCatchOne(expr, names, parentenv, handlers[[1L]])
19:  6: FUN(X[[i]], ...)
tryCatchList(expr, classes, parentenv, handlers)

Traceback:
 1: RowCumsum(valid)
 2: FindNeighbors(embedding, lib_i, pred_i, knn, exclusionRadius = exclusionRadius, 
Traceback:
    validLib = validLib, libOverlap = idx$libOverlap, backend = backend,     verbose = verbose) 1: 
 3: SMap(dataFrame, columns, target, lib, pred, E = E, Tp = Tp, knn = knn, 20:     tau = tau, theta = th, exclusionRadius = exclusionRadius, RowCumsum(valid)    embedded = embedded, validLib = validLib, noTime = noTime,  7: lapply(X = S, FUN = FUN, ...)    ignoreNan = ignoreNan, backend = backend)
 8: tryCatch(parallel::mclapply(values, worker, mc.cores = cores, doTryCatch(return(expr), name, parentenv, handler)    mc.preschedule = TRUE), error = function(e) NULL)

 9: tryCatchOne(expr, names, parentenv, handlers[[1L]])
 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)


10:  4: ComputeError(predictions$Observations, predictions$Predictions)
 4:  5: ComputeError(predictions$Observations, predictions$Predictions)tryCatchList(expr, classes, parentenv, handlers)
 5: SweepRho(SMap(dataFrame, columns, target, lib, pred, E = E, Tp = Tp, 21:     knn = knn, tau = tau, theta = th, exclusionRadius = exclusionRadius, SweepRho(SMap(dataFrame, columns, target, lib, pred, E = E, Tp = Tp, SweepApply(theta, worker, numProcess)    embedded = embedded, validLib = validLib, noTime = noTime, 

22:     knn = knn, tau = tau, theta = th, exclusionRadius = exclusionRadius, 11:     embedded = embedded, validLib = validLib, noTime = noTime, unlist(SweepApply(theta, worker, numProcess))tryCatch(expr, error = function(e) {    ignoreNan = ignoreNan, backend = backend)$predictions)
    ignoreNan = ignoreNan, backend = backend)$predictions)
 6:     call <- conditionCall(e)23:     if (!is.null(call)) {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)        if (identical(call[[1L]], quote(doTryCatch))) 
            call <- sys.call(-4L)        dcall <- deparse(call, nlines = 1L) 6: 
        prefix <- paste("Error in", dcall, ": ")26: FUN(X[[i]], ...)withVisible(eval(expr, envir))
27: 
 7:         LONG <- 75L        sm <- strsplit(conditionMessage(e), "\n")[[1L]]lapply(X = S, FUN = FUN, ...)FUN(X[[i]], ...)

withCallingHandlers(code, error = function (e)         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) rlang::entrace(e), message = function (cnd)  7: {    watcher$capture_plot_and_output()            prefix <- paste0(prefix, "\n  ") 8: lapply(X = S, FUN = FUN, ...)
    }    if (on_message$capture) { 8:     else prefix <- "Error : "doTryCatch(return(expr), name, parentenv, handler)
doTryCatch(return(expr), name, parentenv, handler) 9: 
tryCatchOne(expr, names, parentenv, handlers[[1L]])    msg <- paste0(prefix, conditionMessage(e), "\n")        watcher$push(cnd)    }    if (on_message$silence) { 9: tryCatchOne(expr, names, parentenv, handlers[[1L]])
10: tryCatchList(expr, classes, parentenv, handlers)        invokeRestart("muffleMessage")
    .Internal(seterrmessage(msg[1L]))
11: 10: tryCatch(expr, error = function(e) {    call <- conditionCall(e)    }    if (!is.null(call)) {}, warning = function (cnd) {    if (!silent && isTRUE(getOption("show.error.messages"))) {tryCatchList(expr, classes, parentenv, handlers)        cat(msg, file = outFile)        if (identical(call[[1L]], quote(doTryCatch)))     if (getOption("warn") >= 2 || getOption("warn") < 0) {        return()        .Internal(printDeferredWarnings())    }    watcher$capture_plot_and_output()    if (on_warning$capture) {    }
        cnd <- sanitize_call(cnd)11: tryCatch(expr, error = function(e) {            call <- sys.call(-4L)    invisible(structure(msg, class = "try-error", condition = e))})        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))         watcher$push(cnd)    }    if (on_warning$silence) {    call <- conditionCall(e)        invokeRestart("muffleWarning")    }}, error = function (cnd) {    if (!is.null(call)) {12: try(lapply(X = S, FUN = FUN, ...), silent = TRUE)
13:             w <- 14L + nchar(dcall, type = "b") + nchar(sm[1L],                 type = "b")sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE))        if (w > LONG)     watcher$capture_plot_and_output()            prefix <- paste0(prefix, "\n  ")    }    else prefix <- "Error : "
        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")    msg <- paste0(prefix, conditionMessage(e), "\n")        if (w > LONG)     .Internal(seterrmessage(msg[1L]))    if (!silent && isTRUE(getOption("show.error.messages"))) {14:         cat(msg, file = outFile)            prefix <- paste0(prefix, "\n  ")        .Internal(printDeferredWarnings())    }    invisible(structure(msg, class = "try-error", condition = e))})
FUN(X[[i]], ...)
15:     }    cnd <- sanitize_call(cnd)12:     watcher$push(cnd)    switch(on_error, continue = invokeRestart("eval_continue"), lapply(seq_len(cores), inner.do)        stop = invokeRestart("eval_stop"), error = NULL)    else prefix <- "Error : "
})
28: try(lapply(X = S, FUN = FUN, ...), silent = TRUE)    msg <- paste0(prefix, conditionMessage(e), "\n")    .Internal(seterrmessage(msg[1L]))    if (!silent && isTRUE(getOption("show.error.messages"))) {
13: 16: sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE))parallel::mclapply(values, worker, mc.cores = cores, mc.preschedule = TRUE)
        cat(msg, file = outFile)
17:         .Internal(printDeferredWarnings())14:     }doTryCatch(return(expr), name, parentenv, handler)    invisible(structure(msg, class = "try-error", condition = e))})

12: FUN(X[[i]], ...)18: tryCatchOne(expr, names, parentenv, handlers[[1L]])
19: tryCatchList(expr, classes, parentenv, handlers)
20: try(lapply(X = S, FUN = FUN, ...), silent = TRUE)tryCatch(parallel::mclapply(values, worker, mc.cores = cores, eval(call)
29: eval(call)

30: 
with_handlers({    mc.preschedule = TRUE), error = function(e) NULL)    for (expr in tle$exprs) {13: 15: sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE))        ev <- withVisible(eval(expr, envir))
        watcher$capture_plot_and_output()        watcher$print_value(ev$value, ev$visible, envir)    }
    TRUE14: FUN(X[[i]], ...)
lapply(seq_len(cores), inner.do)}, handlers)
21: 16: 
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)31: 
parallel::mclapply(values, worker, mc.cores = cores, mc.preschedule = TRUE)doWithOneRestart(return(expr), restart)

32: withOneRestart(expr, restarts[[1L]])
33: withRestartList(expr, restarts[-nr])24: 
17: eval(expr, envir)
34: 25: doTryCatch(return(expr), name, parentenv, handler)eval(expr, envir)doWithOneRestart(return(expr), restart)

35: 
18: tryCatchOne(expr, names, parentenv, handlers[[1L]])
19: 15: withOneRestart(withRestartList(expr, restarts[-nr]), restarts[[nr]])
36: lapply(seq_len(cores), inner.do)
16: parallel::mclapply(values, worker, mc.cores = cores, mc.preschedule = TRUE)
17: doTryCatch(return(expr), name, parentenv, handler)26: tryCatchList(expr, classes, parentenv, handlers)withRestartList(expr, restarts)
withVisible(eval(expr, envir))
27: 

20: tryCatch(parallel::mclapply(values, worker, mc.cores = cores,     mc.preschedule = TRUE), error = function(e) NULL)
21: withCallingHandlers(code, error = function (e) 18: SweepApply(theta, worker, numProcess)rlang::entrace(e), message = function (cnd) 
22: unlist(SweepApply(theta, worker, numProcess)){
    watcher$capture_plot_and_output()37:     if (on_message$capture) {withRestarts(with_handlers({23: PredictNonlinear(dataFrame = Thrips, columns = "Thrips_imaginis", tryCatchOne(expr, names, parentenv, handlers[[1L]])        watcher$push(cnd)    target = "Thrips_imaginis", lib = "1 73", pred = "1 73",     }
    E = E, showPlot = TRUE)19: tryCatchList(expr, classes, parentenv, handlers)
    for (expr in tle$exprs) {20:     if (on_message$silence) {        ev <- withVisible(eval(expr, envir))tryCatch(parallel::mclapply(values, worker, mc.cores = cores,         watcher$capture_plot_and_output()
        watcher$print_value(ev$value, ev$visible, envir)24: eval(expr, envir)    }    mc.preschedule = TRUE), error = function(e) NULL)
25:     TRUE
        invokeRestart("muffleMessage")21: SweepApply(theta, worker, numProcess)
22: unlist(SweepApply(theta, worker, numProcess))
23: PredictNonlinear(dataFrame = Thrips, columns = "Thrips_imaginis",     }}, handlers), eval_continue = function() TRUE, eval_stop = function() FALSE)}, warning = function (cnd) 
{    if (getOption("warn") >= 2 || getOption("warn") < 0) {        return()    }    watcher$capture_plot_and_output()    if (on_warning$capture) {eval(expr, envir)        cnd <- sanitize_call(cnd)    target = "Thrips_imaginis", lib = "1 73", pred = "1 73", 
        watcher$push(cnd)26: 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))    }withVisible(eval(expr, envir))
    if (on_warning$silence) {40:     E = E, showPlot = TRUE)        invokeRestart("muffleWarning")
in_dir(input_dir(), expr)
41: in_input_dir(evaluate(code, envir = env, new_device = FALSE, 
24: eval(expr, envir)
25: eval(expr, envir)    }}, error = function (cnd) {27: 
withCallingHandlers(code, error = function (e) 26: withVisible(eval(expr, envir))
    watcher$capture_plot_and_output()27:     cnd <- sanitize_call(cnd)    watcher$push(cnd)withCallingHandlers(code, error = function (e)     switch(on_error, continue = invokeRestart("eval_continue"), rlang::entrace(e), message = function (cnd)     keep_warning = if (is.numeric(options$warning)) TRUE else options$warning, {        stop = invokeRestart("eval_stop"), error = NULL)    watcher$capture_plot_and_output()    keep_message = if (is.numeric(options$message)) TRUE else options$message, })
28: eval(call)    stop_on_error = if (is.numeric(options$error)) options$error else {    if (on_message$capture) {        if (options$error && options$include)         watcher$push(cnd)
rlang::entrace(e), message = function (cnd) {    watcher$capture_plot_and_output()    if (on_message$capture) {29:     }            0Leval(call)        watcher$push(cnd)        else 2L    }, output_handler = knit_handlers(options$render, options)))    }    if (on_message$silence) {        invokeRestart("muffleMessage")    }}, warning = function (cnd) 
42: {
eng_r(options)
30: 43:     if (on_message$silence) {        invokeRestart("muffleMessage")    }with_handlers({    if (getOption("warn") >= 2 || getOption("warn") < 0) {    for (expr in tle$exprs) {}, warning = function (cnd)         ev <- withVisible(eval(expr, envir))        return()        watcher$capture_plot_and_output(){        watcher$print_value(ev$value, ev$visible, envir)    }    TRUEblock_exec(params)
44: call_block(x)
    }    watcher$capture_plot_and_output()    if (on_warning$capture) {        cnd <- sanitize_call(cnd)        watcher$push(cnd)    }    if (getOption("warn") >= 2 || getOption("warn") < 0) {    if (on_warning$silence) {        return()        invokeRestart("muffleWarning")}, handlers)45: 
process_group(group)
46: 31: doWithOneRestart(return(expr), restart)withCallingHandlers(if (tangle) process_tangle(group) else process_group(group), 
32: withOneRestart(expr, restarts[[1L]])
    }    error = function(e) {}, error = function (cnd)     }{    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)        if (progress && is.function(pb$interrupt)) 33: })            pb$interrupt()        if (is_R_CMD_build() || is_R_CMD_check()) 
withRestartList(expr, restarts[-nr])
34:             error <<- format(e)28:     })
eval(call)47: doWithOneRestart(return(expr), restart)
35: with_options(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group), withOneRestart(withRestartList(expr, restarts[-nr]), restarts[[nr]])

29:     watcher$capture_plot_and_output()    if (on_warning$capture) {36:     error = function(e) {        cnd <- sanitize_call(cnd)withRestartList(expr, restarts)        watcher$push(cnd)    }        if (progress && is.function(pb$interrupt))             pb$interrupt()        if (is_R_CMD_build() || is_R_CMD_check())     if (on_warning$silence) {            error <<- format(e)
        invokeRestart("muffleWarning")    }), list(rlang_trace_top_env = knit_global()))eval(call)
48: xfun:::handle_error(with_options(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group),     }
    error = function(e) {}, error = function (cnd)         if (progress && is.function(pb$interrupt)) 30:             pb$interrupt(){    watcher$capture_plot_and_output()    cnd <- sanitize_call(cnd)    watcher$push(cnd)    switch(on_error, continue = invokeRestart("eval_continue"), with_handlers({        stop = invokeRestart("eval_stop"), error = NULL)    for (expr in tle$exprs) {        if (is_R_CMD_build() || is_R_CMD_check()) })        ev <- withVisible(eval(expr, envir))37:         watcher$capture_plot_and_output()withRestarts(with_handlers({            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()))
        watcher$print_value(ev$value, ev$visible, envir)    }28:     TRUE    for (expr in tle$exprs) {}, handlers)        ev <- withVisible(eval(expr, envir))}, if (labels[i] != "") sprintf(" [%s]", labels[i]), get_loc)
        watcher$capture_plot_and_output()        watcher$print_value(ev$value, ev$visible, envir)eval(call)    }    TRUE

49: 31: 29: process_file(text, output)doWithOneRestart(return(expr), restart)}, handlers), eval_continue = function() TRUE, eval_stop = function() FALSE)

eval(call)
30: with_handlers({    for (expr in tle$exprs) {
32: 38:         ev <- withVisible(eval(expr, envir))        watcher$capture_plot_and_output()        watcher$print_value(ev$value, ev$visible, envir)    }    TRUE}, handlers)
31: evaluate::evaluate(...)50: withOneRestart(expr, restarts[[1L]])
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, 33: withRestartList(expr, restarts[-nr])knitr::knit(knit_input, knit_output, envir = envir, quiet = quiet)    stop_on_error = if (is.numeric(options$error)) options$error else {doWithOneRestart(return(expr), restart)
        if (options$error && options$include) 
            0L34: doWithOneRestart(return(expr), restart)51: 
35: withOneRestart(withRestartList(expr, restarts[-nr]), restarts[[nr]])

rmarkdown::render(file, encoding = encoding, quiet = quiet, envir = globalenv(),     output_dir = getwd(), ...)32: withOneRestart(expr, restarts[[1L]])

52:         else 2L    }, output_handler = knit_handlers(options$render, options))
36: withRestartList(expr, restarts)
37: 33: vweave_rmarkdown(...)withRestarts(with_handlers({40: in_dir(input_dir(), expr)
withRestartList(expr, restarts[-nr])    for (expr in tle$exprs) {
53: 41:         ev <- withVisible(eval(expr, envir))in_input_dir(evaluate(code, envir = env, new_device = FALSE,     keep_warning = if (is.numeric(options$warning)) TRUE else options$warning, engine$weave(file, quiet = quiet, encoding = enc)
34: doWithOneRestart(return(expr), restart)
        watcher$capture_plot_and_output()    keep_message = if (is.numeric(options$message)) TRUE else options$message,         watcher$print_value(ev$value, ev$visible, envir)    stop_on_error = if (is.numeric(options$error)) options$error else {    }    TRUE        if (options$error && options$include)             0L        else 2L    }, output_handler = knit_handlers(options$render, options)))}, handlers), eval_continue = function() TRUE, eval_stop = function() FALSE)

42: 54: doTryCatch(return(expr), name, parentenv, handler)eng_r(options)35: 
55: withOneRestart(withRestartList(expr, restarts[-nr]), restarts[[nr]])
43: 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)) {
block_exec(params)
44: call_block(x)
45: 36:         texi2pdf(file = output, clean = FALSE, quiet = quiet)        output <- find_vignette_product(name, by = "texi2pdf",             engine = engine)    }    outputs <- c(outputs, output)}, error = function(e) {    thisOK <<- FALSEprocess_group(group)withRestartList(expr, restarts)
    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", 
46: 37:     skip = TRUE, ser_elibs = "/Volumes/Temp/tmp/RtmpHsb4CJ/file6b8b4ef5b4cf.rds")withRestarts(with_handlers({    for (expr in tle$exprs) {
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))         ev <- withVisible(eval(expr, envir))        watcher$capture_plot_and_output()
            pb$interrupt()An irrecoverable exception occurred. R is aborting now ...
38:         if (is_R_CMD_build() || is_R_CMD_check())             error <<- format(e)    }), list(rlang_trace_top_env = knit_global()))
        watcher$print_value(ev$value, ev$visible, envir)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())             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: evaluate::evaluate(...)rmarkdown::render(file, encoding = encoding, quiet = quiet, envir = globalenv(),     output_dir = getwd(), ...)
52: vweave_rmarkdown(...)
53: engine$weave(file, quiet = quiet, encoding = enc)
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:     TRUE}, handlers), eval_continue = function() TRUE, eval_stop = function() FALSE)eng_r(options)
43: block_exec(params)


38: evaluate::evaluate(...)
39: evaluate(code, envir = env, new_device = FALSE, keep_warning = if (is.numeric(options$warning)) TRUE else options$warning, 44: 54: call_block(x)
45: process_group(group)
46: withCallingHandlers(if (tangle) process_tangle(group) else process_group(group),     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 2LdoTryCatch(return(expr), name, parentenv, handler)
    }, output_handler = knit_handlers(options$render, options))
55: 40: in_dir(input_dir(), expr)    error = function(e) {
tryCatchOne(expr, names, parentenv, handlers[[1L]])41: 
in_input_dir(evaluate(code, envir = env, new_device = FALSE, 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) {    keep_warning = if (is.numeric(options$warning)) TRUE else options$warning,     thisOK <<- FALSE    fails <<- c(fails, file)    message(gettextf("Error: processing vignette '%s' failed with diagnostics:\n%s",         file, conditionMessage(e)))})
    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 2L58: tools::buildVignettes(dir = "/Volumes/Builds/packages/big-sur-arm64/results/4.5/rEDM.Rcheck/vign_test/rEDM",     skip = TRUE, ser_elibs = "/Volumes/Temp/tmp/RtmpHsb4CJ/file6b8b4ef5b4cf.rds")
An irrecoverable exception occurred. R is aborting now ...
    }, output_handler = knit_handlers(options$render, options)))
42: eng_r(options)
43: block_exec(params)
44:         if (progress && is.function(pb$interrupt)) call_block(x)
45: process_group(group)            pb$interrupt()        if (is_R_CMD_build() || is_R_CMD_check())             error <<- format(e)    })
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), 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())             error <<- format(e)    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())             error <<- format(e)    }), list(rlang_trace_top_env = knit_global())), function(loc) {    }), 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()))    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)}, 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(),     output_dir = getwd(), ...)
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: 
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)doTryCatch(return(expr), name, parentenv, handler)
55:     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/RtmpHsb4CJ/file6b8b4ef5b4cf.rds")
An irrecoverable exception occurred. R is aborting now ...
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/RtmpHsb4CJ/file6b8b4ef5b4cf.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