Error(s) in re-building vignettes:
--- re-building ‘clustering.Rmd’ using rmarkdown
2026-04-09 20:25:33.684 R[72612:403595] XType: Using static font registry.
--- finished re-building ‘clustering.Rmd’

--- re-building ‘co-occurrence-networks.Rmd’ using rmarkdown
--- finished re-building ‘co-occurrence-networks.Rmd’

--- re-building ‘link-prediction-association-rules.Rmd’ using rmarkdown
2026-04-09 20:25:39.540 R[72656:403727] XType: Using static font registry.
--- finished re-building ‘link-prediction-association-rules.Rmd’

--- re-building ‘psychological-networks.Rmd’ using rmarkdown
--- finished re-building ‘psychological-networks.Rmd’

--- re-building ‘transition-networks.Rmd’ using rmarkdown

 *** 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'

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

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

Traceback:
 1: .mmm_em(counts, init_state, k, screen_iter, tol, smooth, n_states,     init_posterior = init, from_ind = from_ind, cov_df = NULL)
 2: FUN(X[[i]], ...)
 3: lapply(X = S, FUN = FUN, ...)
 4: doTryCatch(return(expr), name, parentenv, handler)
 5: tryCatchOne(expr, names, parentenv, handlers[[1L]])
 6: tryCatchList(expr, classes, parentenv, handlers)
 7: 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))})
 8: try(lapply(X = S, FUN = FUN, ...), silent = TRUE)
 9: sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE))
10: FUN(X[[i]], ...)
11: lapply(seq_len(cores), inner.do)
12: parallel::mclapply(inits, .run_screen, mc.cores = n_cores)
13: build_mmm(net_GR, k = 2, covariates = c("Group"))
14: eval(expr, envir)
15: eval(expr, envir)
16: withVisible(eval(expr, envir))
17: withCallingHandlers(code, error = function (e) rlang::entrace(e), message = function (cnd) {    watcher$capture_plot_and_output()    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) {        cnd <- sanitize_call(cnd)        watcher$push(cnd)    }    if (on_warning$silence) {        invokeRestart("muffleWarning")    }}, 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)})
18: eval(call)
19: eval(call)
20: 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)
21: doWithOneRestart(return(expr), restart)
22: withOneRestart(expr, restarts[[1L]])
23: withRestartList(expr, restarts[-nr])
24: doWithOneRestart(return(expr), restart)
25: withOneRestart(withRestartList(expr, restarts[-nr]), restarts[[nr]])
26: withRestartList(expr, restarts)
27: 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)
28: evaluate::evaluate(...)
29: 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))
30: in_dir(input_dir(), expr)
31: 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)))
32: eng_r(options)
33: block_exec(params)
34: call_block(x)
35: process_group(group)
36: 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)    })
37: 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()))
38: 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)
39: process_file(text, output)
40: knitr::knit(knit_input, knit_output, envir = envir, quiet = quiet)
41: rmarkdown::render(file, encoding = encoding, quiet = quiet, envir = globalenv(),     output_dir = getwd(), ...)
42: vweave_rmarkdown(...)
43: engine$weave(file, quiet = quiet, encoding = enc)
44: doTryCatch(return(expr), name, parentenv, handler)
45: tryCatchOne(expr, names, parentenv, handlers[[1L]])
46: tryCatchList(expr, classes, parentenv, handlers)
47: 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)    }}, error = function(e) {    OK <<- FALSE    message(gettextf("Error: processing vignette '%s' failed with diagnostics:\n%s",         file, conditionMessage(e)))})
48: tools:::.buildOneVignette("transition-networks.Rmd", "/Volumes/Builds/packages/big-sur-arm64/results/4.5/Nestimate.Rcheck/vign_test/Nestimate",     TRUE, FALSE, "transition-networks", "UTF-8", "/Volumes/Temp/tmp/RtmpxaL00L/file11a94792e0301.rds")
An irrecoverable exception occurred. R is aborting now ...

Traceback:
 1: .mmm_em(counts, init_state, k, screen_iter, tol, smooth, n_states,     init_posterior = init, from_ind = from_ind, cov_df = NULL)
 2: FUN(X[[i]], ...)
 3: lapply(X = S, FUN = FUN, ...)
 4: doTryCatch(return(expr), name, parentenv, handler)
 5: tryCatchOne(expr, names, parentenv, handlers[[1L]])
 6: tryCatchList(expr, classes, parentenv, handlers)
 7: 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))})
 8: try(lapply(X = S, FUN = FUN, ...), silent = TRUE)
 9: sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE))
10: FUN(X[[i]], ...)
11: lapply(seq_len(cores), inner.do)
12: parallel::mclapply(inits, .run_screen, mc.cores = n_cores)
13: build_mmm(net_GR, k = 2, covariates = c("Group"))
14: eval(expr, envir)
15: eval(expr, envir)
16: withVisible(eval(expr, envir))
17: withCallingHandlers(code, error = function (e) rlang::entrace(e), message = function (cnd) {    watcher$capture_plot_and_output()    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) {        cnd <- sanitize_call(cnd)        watcher$push(cnd)    }    if (on_warning$silence) {        invokeRestart("muffleWarning")    }}, 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)})
18: eval(call)
19: eval(call)

Traceback:
 1: 20: with_handlers({    for (expr in tle$exprs) {        ev <- withVisible(eval(expr, envir))
Traceback:
        watcher$capture_plot_and_output() 1: .mmm_em(counts, init_state, k, screen_iter, tol, smooth, n_states,     init_posterior = init, from_ind = from_ind, cov_df = NULL)
 2: FUN(X[[i]], ...).mmm_em(counts, init_state, k, screen_iter, tol, smooth, n_states,     init_posterior = init, from_ind = from_ind, cov_df = NULL)
 2: FUN(X[[i]], ...)
 3: 
 *** caught segfault ***
address 0x110, cause 'invalid permissions'

 *** caught segfault ***
address 0x110, cause 'invalid permissions'
        watcher$print_value(ev$value, ev$visible, envir)    }    TRUE}, handlers)
21: doWithOneRestart(return(expr), restart)
22: withOneRestart(expr, restarts[[1L]])
23: withRestartList(expr, restarts[-nr])
24: doWithOneRestart(return(expr), restart)
25: withOneRestart(withRestartList(expr, restarts[-nr]), restarts[[nr]])
26: withRestartList(expr, restarts)
27: 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)
28: evaluate::evaluate(...)
29: 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))
30: in_dir(input_dir(), expr)
31: 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)))
32: eng_r(options)

 *** caught segfault ***
address 0x110, cause 'invalid permissions'
33: block_exec(params)
34: call_block(x)
35: process_group(group)
36: 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)    })
37: 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()))
38: 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)
39: 
Traceback:
 1: 
 3: lapply(X = S, FUN = FUN, ...)
 4: doTryCatch(return(expr), name, parentenv, handler).mmm_em(counts, init_state, k, screen_iter, tol, smooth, n_states, lapply(X = S, FUN = FUN, ...)
 4: doTryCatch(return(expr), name, parentenv, handler)
 5: 
 5: tryCatchOne(expr, names, parentenv, handlers[[1L]])
 6: process_file(text, output)tryCatchOne(expr, names, parentenv, handlers[[1L]])
 6: tryCatchList(expr, classes, parentenv, handlers)
 7: 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))})
 8: try(lapply(X = S, FUN = FUN, ...), silent = TRUE)
 9: sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE))
10: FUN(X[[i]], ...)
11: lapply(seq_len(cores), inner.do)
12: parallel::mclapply(inits, .run_screen, mc.cores = n_cores)
13: build_mmm(net_GR, k = 2, covariates = c("Group"))
14: eval(expr, envir)
15: eval(expr, envir)
16: withVisible(eval(expr, envir))
17: withCallingHandlers(code, error = function (e) rlang::entrace(e), message = function (cnd) {    watcher$capture_plot_and_output()    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) {        cnd <- sanitize_call(cnd)        watcher$push(cnd)    }    if (on_warning$silence) {        invokeRestart("muffleWarning")    }}, 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)})
18: eval(call)
19: eval(call)
20: 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)
21: doWithOneRestart(return(expr), restart)
22: withOneRestart(expr, restarts[[1L]])
23: withRestartList(expr, restarts[-nr])
24: doWithOneRestart(return(expr), restart)
25: withOneRestart(withRestartList(expr, restarts[-nr]), restarts[[nr]])
26: withRestartList(expr, restarts)
27: 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)
28: evaluate::evaluate(...)
29: 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))
30: in_dir(input_dir(), expr)
31: 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)))
32: eng_r(options)
33: block_exec(params)
34: call_block(x)
35: process_group(group)
36: 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)    })
37: 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()))
38: 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)
39: process_file(text, output)
40: knitr::knit(knit_input, knit_output, envir = envir, quiet = quiet)
41: rmarkdown::render(file, encoding = encoding, quiet = quiet, envir = globalenv(),     output_dir = getwd(), ...)
42: vweave_rmarkdown(...)
43: engine$weave(file, quiet = quiet, encoding = enc)
44: doTryCatch(return(expr), name, parentenv, handler)
45: tryCatchOne(expr, names, parentenv, handlers[[1L]])
46: tryCatchList(expr, classes, parentenv, handlers)
47: 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)    }}, error = function(e) {    OK <<- FALSE    message(gettextf("Error: processing vignette '%s' failed with diagnostics:\n%s",         file, conditionMessage(e)))})
48: tools:::.buildOneVignette("transition-networks.Rmd", "/Volumes/Builds/packages/big-sur-arm64/results/4.5/Nestimate.Rcheck/vign_test/Nestimate",     TRUE, FALSE, "transition-networks", "UTF-8", "/Volumes/Temp/tmp/RtmpxaL00L/file11a94792e0301.rds")
An irrecoverable exception occurred. R is aborting now ...

Traceback:
 1: .mmm_em(counts, init_state, k, screen_iter, tol, smooth, n_states,     init_posterior = init, from_ind = from_ind, cov_df = NULL)
 2: FUN(X[[i]], ...)
 3: lapply(X = S, FUN = FUN, ...)
 4: doTryCatch(return(expr), name, parentenv, handler)
 5: tryCatchOne(expr, names, parentenv, handlers[[1L]])
 6: tryCatchList(expr, classes, parentenv, handlers)
 7: 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))})
 8: try(lapply(X = S, FUN = FUN, ...), silent = TRUE)
 9: sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE))
10: FUN(X[[i]], ...)
11: lapply(seq_len(cores), inner.do)
12: parallel::mclapply(inits, .run_screen, mc.cores = n_cores)
13: build_mmm(net_GR, k = 2, covariates = c("Group"))
14: eval(expr, envir)
15: eval(expr, envir)
16: withVisible(eval(expr, envir))
17: withCallingHandlers(code, error = function (e) rlang::entrace(e), message = function (cnd) {    watcher$capture_plot_and_output()    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) {        cnd <- sanitize_call(cnd)        watcher$push(cnd)    }    if (on_warning$silence) {        invokeRestart("muffleWarning")    }}, 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)})
18: tryCatchList(expr, classes, parentenv, handlers)
 7: 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))})
40: knitr::knit(knit_input, knit_output, envir = envir, quiet = quiet)
41: rmarkdown::render(file, encoding = encoding, quiet = quiet, envir = globalenv(),     output_dir = getwd(), ...)
42: vweave_rmarkdown(...)
43: engine$weave(file, quiet = quiet, encoding = enc)
44: doTryCatch(return(expr), name, parentenv, handler)
45: tryCatchOne(expr, names, parentenv, handlers[[1L]])
46: tryCatchList(expr, classes, parentenv, handlers)
47: 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)    }}, error = function(e) {    OK <<- FALSE    message(gettextf("Error: processing vignette '%s' failed with diagnostics:\n%s",         file, conditionMessage(e)))})
48: tools:::.buildOneVignette("transition-networks.Rmd", "/Volumes/Builds/packages/big-sur-arm64/results/4.5/Nestimate.Rcheck/vign_test/Nestimate",     TRUE, FALSE, "transition-networks", "UTF-8", "/Volumes/Temp/tmp/RtmpxaL00L/file11a94792e0301.rds")
An irrecoverable exception occurred. R is aborting now ...

 8: try(lapply(X = S, FUN = FUN, ...), silent = TRUE)
 9: sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE))
10: FUN(X[[i]], ...)
11: lapply(seq_len(cores), inner.do)
12: parallel::mclapply(inits, .run_screen, mc.cores = n_cores)
13: build_mmm(net_GR, k = 2, covariates = c("Group"))
14: eval(expr, envir)
15: eval(expr, envir)
16: withVisible(eval(expr, envir))
17: withCallingHandlers(code, error = function (e) rlang::entrace(e), message = function (cnd) {eval(call)
19: eval(call)
20: 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)
21: doWithOneRestart(return(expr), restart)
22: withOneRestart(expr, restarts[[1L]])
23: withRestartList(expr, restarts[-nr])
24: doWithOneRestart(return(expr), restart)
25: withOneRestart(withRestartList(expr, restarts[-nr]), restarts[[nr]])
26: withRestartList(expr, restarts)
27: 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)
28: evaluate::evaluate(...)
29: 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))
30: in_dir(input_dir(), expr)
31: 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)))
32: eng_r(options)
33: block_exec(params)
34: call_block(x)
35: process_group(group)
36: 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)    })
37: 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()))
38: 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)
39: process_file(text, output)
40: knitr::knit(knit_input, knit_output, envir = envir, quiet = quiet)
41: rmarkdown::render(file, encoding = encoding, quiet = quiet, envir = globalenv(),     output_dir = getwd(), ...)
42: vweave_rmarkdown(...)
43: engine$weave(file, quiet = quiet, encoding = enc)
44: doTryCatch(return(expr), name, parentenv, handler)
45: tryCatchOne(expr, names, parentenv, handlers[[1L]])
46: tryCatchList(expr, classes, parentenv, handlers)
47: 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)    }}, error = function(e) {    OK <<- FALSE    message(gettextf("Error: processing vignette '%s' failed with diagnostics:\n%s",         file, conditionMessage(e)))})
48: tools:::.buildOneVignette("transition-networks.Rmd", "/Volumes/Builds/packages/big-sur-arm64/results/4.5/Nestimate.Rcheck/vign_test/Nestimate",     TRUE, FALSE, "transition-networks", "UTF-8", "/Volumes/Temp/tmp/RtmpxaL00L/file11a94792e0301.rds")
An irrecoverable exception occurred. R is aborting now ...

Traceback:
 1: .mmm_em(counts, init_state, k, screen_iter, tol, smooth, n_states,     init_posterior = init, from_ind = from_ind, cov_df = NULL)
 2: FUN(X[[i]], ...)
 3: lapply(X = S, FUN = FUN, ...)
 4: doTryCatch(return(expr), name, parentenv, handler)
 5: 
Traceback:
    watcher$capture_plot_and_output()    init_posterior = init, from_ind = from_ind, cov_df = NULL)tryCatchOne(expr, names, parentenv, handlers[[1L]])
 1: .mmm_em(counts, init_state, k, screen_iter, tol, smooth, n_states,     init_posterior = init, from_ind = from_ind, cov_df = NULL)
 2: FUN(X[[i]], ...)
 3: lapply(X = S, FUN = FUN, ...)
 4: doTryCatch(return(expr), name, parentenv, handler)
 5: tryCatchOne(expr, names, parentenv, handlers[[1L]])
 6: tryCatchList(expr, classes, parentenv, handlers)
 7: 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))})
 8: try(lapply(X = S, FUN = FUN, ...), silent = TRUE)
 9: sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE))
10: FUN(X[[i]], ...)
11:     if (on_message$capture) {lapply(seq_len(cores), inner.do)        watcher$push(cnd)
 *** caught segfault ***
address 0x110, cause 'invalid permissions'


Traceback:

    }
 *** caught segfault ***
12:  1: .mmm_em(counts, init_state, k, screen_iter, tol, smooth, n_states,     init_posterior = init, from_ind = from_ind, cov_df = NULL)
 2: FUN(X[[i]], ...)
 3: lapply(X = S, FUN = FUN, ...)
parallel::mclapply(inits, .run_screen, mc.cores = n_cores)address 0x110, cause 'invalid permissions'

 *** caught segfault ***
address 0x110, cause 'invalid permissions'
 6: tryCatchList(expr, classes, parentenv, handlers)
 7:  2: FUN(X[[i]], ...)
 3: lapply(X = S, FUN = FUN, ...)
 4: tryCatch(expr, error = function(e) {doTryCatch(return(expr), name, parentenv, handler)
 5: tryCatchOne(expr, names, parentenv, handlers[[1L]])
 6: tryCatchList(expr, classes, parentenv, handlers)
 7: 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) 4: doTryCatch(return(expr), name, parentenv, handler)
 5:         prefix <- paste("Error in", dcall, ": ")
13: build_mmm(net_GR, k = 2, covariates = c("Group"))        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]))
 *** caught segfault ***
    if (!silent && isTRUE(getOption("show.error.messages"))) {
14: eval(expr, envir)        cat(msg, file = outFile)    if (on_message$silence) {        .Internal(printDeferredWarnings())    }    invisible(structure(msg, class = "try-error", condition = e))})
address 0x110, cause 'invalid permissions'
        invokeRestart("muffleMessage") 8: try(lapply(X = S, FUN = FUN, ...), silent = TRUE)
 9:     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]]tryCatchOne(expr, names, parentenv, handlers[[1L]])
 6: tryCatchList(expr, classes, parentenv, handlers)        w <- 14L + nchar(dcall, type = "w") + nchar(sm[1L], type = "w")
sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE))
    }}, warning = function (cnd) {    if (getOption("warn") >= 2 || getOption("warn") < 0) {
 7: tryCatch(expr, error = function(e) {    call <- conditionCall(e)    if (!is.null(call)) {        if (identical(call[[1L]], quote(doTryCatch)))         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")15: eval(expr, envir)
16:             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  ")        return()    }    watcher$capture_plot_and_output()    if (on_warning$capture) {        cnd <- sanitize_call(cnd)        watcher$push(cnd)    }    if (on_warning$silence) {        invokeRestart("muffleWarning")    }}, error = function (cnd) {    watcher$capture_plot_and_output()    cnd <- sanitize_call(cnd)    .Internal(seterrmessage(msg[1L]))withVisible(eval(expr, envir))
17: withCallingHandlers(code, error = function (e) rlang::entrace(e), message = function (cnd) 10: FUN(X[[i]], ...)
    if (!silent && isTRUE(getOption("show.error.messages"))) {11:     watcher$push(cnd)    switch(on_error, continue = invokeRestart("eval_continue"),         stop = invokeRestart("eval_stop"), error = NULL){
 *** caught segfault ***
    watcher$capture_plot_and_output()    }lapply(seq_len(cores), inner.do)        cat(msg, file = outFile)    if (on_message$capture) {        watcher$push(cnd)    }        .Internal(printDeferredWarnings())
    if (on_message$silence) {        invokeRestart("muffleMessage")    }}, warning = function (cnd)     }{    invisible(structure(msg, class = "try-error", condition = e))12:     if (getOption("warn") >= 2 || getOption("warn") < 0) {        return()    }parallel::mclapply(inits, .run_screen, mc.cores = n_cores)
13: build_mmm(net_GR, k = 2, covariates = c("Group"))
14:     else prefix <- "Error : "eval(expr, envir)
 *** caught segfault ***
    msg <- paste0(prefix, conditionMessage(e), "\n")address 0x110, cause 'invalid permissions'
    watcher$capture_plot_and_output()    if (on_warning$capture) {    .Internal(seterrmessage(msg[1L]))        cnd <- sanitize_call(cnd)
address 0x110, cause 'invalid permissions'
})
18: eval(call)
19: eval(call)
20:         watcher$push(cnd)    }    if (on_warning$silence) {        invokeRestart("muffleWarning")    }}, error = function (cnd) {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)    }    watcher$capture_plot_and_output()    cnd <- sanitize_call(cnd)    watcher$push(cnd)    if (!silent && isTRUE(getOption("show.error.messages"))) {        cat(msg, file = outFile)        .Internal(printDeferredWarnings())    }    TRUE}, handlers)
21:     invisible(structure(msg, class = "try-error", condition = e))
 *** caught segfault ***
doWithOneRestart(return(expr), restart)
22: withOneRestart(expr, restarts[[1L]])})
 8: address 0x110, cause 'invalid permissions'

15: eval(expr, envir)23: })
 8: try(lapply(X = S, FUN = FUN, ...), silent = TRUE)
 9: sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE))try(lapply(X = S, FUN = FUN, ...), silent = TRUE)
 9: sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE))
10:     switch(on_error, continue = invokeRestart("eval_continue"),         stop = invokeRestart("eval_stop"), error = NULL)FUN(X[[i]], ...)})
18: eval(call)
19: eval(call)
20: 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)withRestartList(expr, restarts[-nr])
16: 

11:     }24: 
doWithOneRestart(return(expr), restart)withVisible(eval(expr, envir))
25: withOneRestart(withRestartList(expr, restarts[-nr]), restarts[[nr]])
26: withRestartList(expr, restarts)    TRUE10: FUN(X[[i]], ...)
11: lapply(seq_len(cores), inner.do)
12: parallel::mclapply(inits, .run_screen, mc.cores = n_cores)}, handlers)lapply(seq_len(cores), inner.do)
Traceback:

 1: .mmm_em(counts, init_state, k, screen_iter, tol, smooth, n_states,     init_posterior = init, from_ind = from_ind, cov_df = NULL)
27: 

 2: 21: FUN(X[[i]], ...)doWithOneRestart(return(expr), restart)13: withRestarts(with_handlers({


Traceback:
 3: 17:     for (expr in tle$exprs) {
Traceback:
lapply(X = S, FUN = FUN, ...)        ev <- withVisible(eval(expr, envir))        watcher$capture_plot_and_output() 1: 
build_mmm(net_GR, k = 2, covariates = c("Group"))

 4: doTryCatch(return(expr), name, parentenv, handler)
 5:         watcher$print_value(ev$value, ev$visible, envir).mmm_em(counts, init_state, k, screen_iter, tol, smooth, n_states, withCallingHandlers(code, error = function (e) 
Traceback:
 1: 12: rlang::entrace(e), message = function (cnd) tryCatchOne(expr, names, parentenv, handlers[[1L]])
    init_posterior = init, from_ind = from_ind, cov_df = NULL)
parallel::mclapply(inits, .run_screen, mc.cores = n_cores)22:     }
14:  2:  6: { 1: tryCatchList(expr, classes, parentenv, handlers)    TRUE.mmm_em(counts, init_state, k, screen_iter, tol, smooth, n_states, }, handlers), eval_continue = function() TRUE, eval_stop = function() FALSE)
28: evaluate::evaluate(...)


.mmm_em(counts, init_state, k, screen_iter, tol, smooth, n_states, eval(expr, envir)
15: eval(expr, envir)FUN(X[[i]], ...)    watcher$capture_plot_and_output()withOneRestart(expr, restarts[[1L]]) 7: 
 3: lapply(X = S, FUN = FUN, ...)
 4: doTryCatch(return(expr), name, parentenv, handler)
 5: tryCatchOne(expr, names, parentenv, handlers[[1L]])
tryCatch(expr, error = function(e) {
16: withVisible(eval(expr, envir))
17:     init_posterior = init, from_ind = from_ind, cov_df = NULL)29: 
    init_posterior = init, from_ind = from_ind, cov_df = NULL)13: build_mmm(net_GR, k = 2, covariates = c("Group"))
14: eval(expr, envir)
15: eval(expr, envir)
16: withCallingHandlers(code, error = function (e) rlang::entrace(e), message = function (cnd) {    watcher$capture_plot_and_output()    if (on_message$capture) {        watcher$push(cnd)    }    if (on_message$silence) {23:  6: evaluate(code, envir = env, new_device = FALSE, keep_warning = if (is.numeric(options$warning)) TRUE else options$warning, tryCatchList(expr, classes, parentenv, handlers)
withVisible(eval(expr, envir))    call <- conditionCall(e)        invokeRestart("muffleMessage")    }}, warning = function (cnd) {    if (getOption("warn") >= 2 || getOption("warn") < 0) {        return()    }    watcher$capture_plot_and_output()    if (on_warning$capture) {        cnd <- sanitize_call(cnd)        watcher$push(cnd)    }    if (on_warning$silence) {        invokeRestart("muffleWarning")    }    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
    if (!is.null(call)) {        if (identical(call[[1L]], quote(doTryCatch)))             call <- sys.call(-4L)        dcall <- deparse(call, nlines = 1L)
    if (on_message$capture) {        watcher$push(cnd)}, error = function (cnd) withRestartList(expr, restarts[-nr])        else 2L
Traceback:
 2:  7: {
 2:     }
Traceback:
FUN(X[[i]], ...)    }, output_handler = knit_handlers(options$render, options)) 1:         prefix <- paste("Error in", dcall, ": ")FUN(X[[i]], ...)    if (on_message$silence) {
        invokeRestart("muffleMessage")    }}, warning = function (cnd) {    if (getOption("warn") >= 2 || getOption("warn") < 0) { 1: .mmm_em(counts, init_state, k, screen_iter, tol, smooth, n_states,     init_posterior = init, from_ind = from_ind, cov_df = NULL)        return()    }

 2: FUN(X[[i]], ...)
 3: lapply(X = S, FUN = FUN, ...)
 4: doTryCatch(return(expr), name, parentenv, handler)
 5: tryCatchOne(expr, names, parentenv, handlers[[1L]])        LONG <- 75LtryCatch(expr, error = function(e) {.mmm_em(counts, init_state, k, screen_iter, tol, smooth, n_states,     watcher$capture_plot_and_output()30: 
Traceback:
in_dir(input_dir(), expr)
31: in_input_dir(evaluate(code, envir = env, new_device = FALSE,  3: 17: 
    call <- conditionCall(e)    watcher$capture_plot_and_output() 1: 

        sm <- strsplit(conditionMessage(e), "\n")[[1L]]    init_posterior = init, from_ind = from_ind, cov_df = NULL)    if (on_warning$capture) { 3: lapply(X = S, FUN = FUN, ...)    keep_warning = if (is.numeric(options$warning)) TRUE else options$warning,     cnd <- sanitize_call(cnd)24: 
lapply(X = S, FUN = FUN, ...)        w <- 14L + nchar(dcall, type = "w") + nchar(sm[1L], type = "w")withCallingHandlers(code, error = function (e) .mmm_em(counts, init_state, k, screen_iter, tol, smooth, n_states,         cnd <- sanitize_call(cnd)doWithOneRestart(return(expr), restart)    keep_message = if (is.numeric(options$message)) TRUE else options$message,     watcher$push(cnd)rlang::entrace(e), message = function (cnd)  2:     init_posterior = init, from_ind = from_ind, cov_df = NULL)        watcher$push(cnd) 6:     stop_on_error = if (is.numeric(options$error)) options$error else {
        if (is.na(w)) 
    }{
    if (!is.null(call)) {            w <- 14L + nchar(dcall, type = "b") + nchar(sm[1L],  4: tryCatchList(expr, classes, parentenv, handlers)
 4: 25:     switch(on_error, continue = invokeRestart("eval_continue"), withOneRestart(withRestartList(expr, restarts[-nr]), restarts[[nr]])
        stop = invokeRestart("eval_stop"), error = NULL)})
18: eval(call)
19: eval(call)
20: with_handlers({ 2: FUN(X[[i]], ...)doTryCatch(return(expr), name, parentenv, handler)
26:     for (expr in tle$exprs) {FUN(X[[i]], ...)

 7: withRestartList(expr, restarts)        if (identical(call[[1L]], quote(doTryCatch)))     watcher$capture_plot_and_output()
    if (on_warning$silence) {tryCatch(expr, error = function(e) {        ev <- withVisible(eval(expr, envir)) 3:             call <- sys.call(-4L) 3: 
        invokeRestart("muffleWarning") 5:                 type = "b")        if (options$error && options$include)     call <- conditionCall(e)lapply(X = S, FUN = FUN, ...)lapply(X = S, FUN = FUN, ...)    }doTryCatch(return(expr), name, parentenv, handler)    if (on_message$capture) {        watcher$capture_plot_and_output()    if (!is.null(call)) {
}, error = function (cnd)             0L        dcall <- deparse(call, nlines = 1L)        if (w > LONG)         watcher$print_value(ev$value, ev$visible, envir)
        watcher$push(cnd)27: withRestarts(with_handlers({        if (identical(call[[1L]], quote(doTryCatch))) tryCatchOne(expr, names, parentenv, handlers[[1L]]) 4:             prefix <- paste0(prefix, "\n  "){    }    else prefix <- "Error : "    msg <- paste0(prefix, conditionMessage(e), "\n")    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)    }
doTryCatch(return(expr), name, parentenv, handler)        prefix <- paste("Error in", dcall, ": ")    }        else 2L})            call <- sys.call(-4L)
 6: tryCatchList(expr, classes, parentenv, handlers)
 7: 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], 
    .Internal(seterrmessage(msg[1L])) 5:     if (on_message$silence) {        LONG <- 75L        invokeRestart("muffleMessage")    }}, warning = function (cnd) {    if (getOption("warn") >= 2 || getOption("warn") < 0) {        return()    }    watcher$capture_plot_and_output()    if (on_warning$capture) {        cnd <- sanitize_call(cnd)        watcher$push(cnd)    }    if (on_warning$silence) {        invokeRestart("muffleWarning")    }}, 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)})
18: eval(call)
19: eval(call)
20: 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)    }
                type = "b")    if (!silent && isTRUE(getOption("show.error.messages"))) {        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")        cat(msg, file = outFile)    for (expr in tle$exprs) {        ev <- withVisible(eval(expr, envir)) 5:     TRUE 4:         if (w > LONG)     }, output_handler = knit_handlers(options$render, options)))tryCatchOne(expr, names, parentenv, handlers[[1L]])
 6: tryCatchList(expr, classes, parentenv, handlers)
 7: 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))}, handlers)
21: doWithOneRestart(return(expr), restart)
22: withOneRestart(expr, restarts[[1L]])
23: withRestartList(expr, restarts[-nr])
24: doWithOneRestart(return(expr), restart)
25: tryCatchOne(expr, names, parentenv, handlers[[1L]])        watcher$capture_plot_and_output()            prefix <- paste0(prefix, "\n  ")    TRUE}, handlers)        .Internal(printDeferredWarnings())    }18: })        watcher$print_value(ev$value, ev$visible, envir)withOneRestart(withRestartList(expr, restarts[-nr]), restarts[[nr]])    }doTryCatch(return(expr), name, parentenv, handler)        sm <- strsplit(conditionMessage(e), "\n")[[1L]]

    else prefix <- "Error : "eval(call)        if (w > LONG) 

    invisible(structure(msg, class = "try-error", condition = e))
    } 8:         w <- 14L + nchar(dcall, type = "w") + nchar(sm[1L], type = "w")

26: 32: try(lapply(X = S, FUN = FUN, ...), silent = TRUE)21:  5: 19: withRestartList(expr, restarts)        if (is.na(w)) 
})tryCatchOne(expr, names, parentenv, handlers[[1L]])eval(call)doWithOneRestart(return(expr), restart) 6: eng_r(options)
    msg <- paste0(prefix, conditionMessage(e), "\n")            w <- 14L + nchar(dcall, type = "b") + nchar(sm[1L],  9:     TRUE
            prefix <- paste0(prefix, "\n  ")    .Internal(seterrmessage(msg[1L]))
sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE)) 8:  6: tryCatchList(expr, classes, parentenv, handlers)    if (!silent && isTRUE(getOption("show.error.messages"))) {

try(lapply(X = S, FUN = FUN, ...), silent = TRUE)20: 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)
21: doWithOneRestart(return(expr), restart)
22: withOneRestart(expr, restarts[[1L]])
23: withRestartList(expr, restarts[-nr])
24: doWithOneRestart(return(expr), restart)
27: 
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        cat(msg, file = outFile)        .Internal(printDeferredWarnings())    }    invisible(structure(msg, class = "try-error", condition = e))})
 8: try(lapply(X = S, FUN = FUN, ...), silent = TRUE)
}, handlers), eval_continue = function() TRUE, eval_stop = function() FALSE)10: FUN(X[[i]], ...)
11: lapply(seq_len(cores), inner.do)
12: parallel::mclapply(inits, .run_screen, mc.cores = n_cores)
13: build_mmm(net_GR, k = 2, covariates = c("Group"))
14: eval(expr, envir)
15: eval(expr, envir)
16: withVisible(eval(expr, envir))
17: withCallingHandlers(code, error = function (e) rlang::entrace(e), message = function (cnd) {    watcher$capture_plot_and_output()    if (on_message$capture) {        watcher$push(cnd)    }    if (on_message$silence) {        invokeRestart("muffleMessage")    }}, warning = function (cnd) {    if (getOption("warn") >= 2 || getOption("warn") < 0) {tryCatchList(expr, classes, parentenv, handlers)
 7: 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, ": ")22: 
25: withOneRestart(withRestartList(expr, restarts[-nr]), restarts[[nr]])
26: withRestartList(expr, restarts)
27: withRestarts(with_handlers({    for (expr in tle$exprs) {        ev <- withVisible(eval(expr, envir))        watcher$capture_plot_and_output()withOneRestart(expr, restarts[[1L]])
        return()33:         watcher$print_value(ev$value, ev$visible, envir)}, handlers), eval_continue = function() TRUE, eval_stop = function() FALSE)28: 
 7: 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)
    } 9: 
evaluate::evaluate(...)                type = "b")sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE))        LONG <- 75L    else prefix <- "Error : "    msg <- paste0(prefix, conditionMessage(e), "\n")    .Internal(seterrmessage(msg[1L]))block_exec(params)        prefix <- paste("Error in", dcall, ": ")    }    }        sm <- strsplit(conditionMessage(e), "\n")[[1L]]    if (!silent && isTRUE(getOption("show.error.messages"))) {23: 

    watcher$capture_plot_and_output()        LONG <- 75L 9:     TRUE        if (w > LONG) 
        cat(msg, file = outFile)sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE))29: 
            prefix <- paste0(prefix, "\n  ")        sm <- strsplit(conditionMessage(e), "\n")[[1L]]10:     if (on_warning$capture) {evaluate(code, envir = env, new_device = FALSE, keep_warning = if (is.numeric(options$warning)) TRUE else options$warning, 28: 
}, handlers), eval_continue = function() TRUE, eval_stop = function() FALSE)FUN(X[[i]], ...)34:         .Internal(printDeferredWarnings())        w <- 14L + nchar(dcall, type = "w") + nchar(sm[1L], type = "w")10: withRestartList(expr, restarts[-nr])evaluate::evaluate(...)
24: doWithOneRestart(return(expr), restart)
25: withOneRestart(withRestartList(expr, restarts[-nr]), restarts[[nr]])
26: withRestartList(expr, restarts)
27: call_block(x)    }        w <- 14L + nchar(dcall, type = "w") + nchar(sm[1L], type = "w")    keep_message = if (is.numeric(options$message)) TRUE else options$message, withRestarts(with_handlers({

    invisible(structure(msg, class = "try-error", condition = e))35: process_group(group)
36: 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)    })
37: 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()))
38: xfun:::handle_error(with_options(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group),     error = function(e) {        if (progress && is.function(pb$interrupt))     stop_on_error = if (is.numeric(options$error)) options$error else {
29:         if (is.na(w)) 
        if (is.na(w))         if (options$error && options$include) 11:             pb$interrupt()            w <- 14L + nchar(dcall, type = "b") + nchar(sm[1L], 28:             w <- 14L + nchar(dcall, type = "b") + nchar(sm[1L], })    }evaluate(code, envir = env, new_device = FALSE, keep_warning = if (is.numeric(options$warning)) TRUE else options$warning,                 type = "b")    for (expr in tle$exprs) {                type = "b")
    else prefix <- "Error : "            0Llapply(seq_len(cores), inner.do)        ev <- withVisible(eval(expr, envir))        if (w > LONG) evaluate::evaluate(...)        if (is_R_CMD_build() || is_R_CMD_check())         else 2L
FUN(X[[i]], ...)        if (w > LONG) 
            error <<- format(e)    keep_message = if (is.numeric(options$message)) TRUE else options$message,     msg <- paste0(prefix, conditionMessage(e), "\n")
        cnd <- sanitize_call(cnd) 8:     }), list(rlang_trace_top_env = knit_global())), function(loc) {    stop_on_error = if (is.numeric(options$error)) options$error else {        watcher$capture_plot_and_output()            prefix <- paste0(prefix, "\n  ")12: try(lapply(X = S, FUN = FUN, ...), silent = TRUE)            prefix <- paste0(prefix, "\n  ")    }, output_handler = knit_handlers(options$render, options))        watcher$push(cnd)    }    .Internal(seterrmessage(msg[1L]))parallel::mclapply(inits, .run_screen, mc.cores = n_cores)        watcher$print_value(ev$value, ev$visible, envir)
29:     else prefix <- "Error : "    if (!silent && isTRUE(getOption("show.error.messages"))) {    msg <- paste0(prefix, conditionMessage(e), "\n")    }11: evaluate(code, envir = env, new_device = FALSE, keep_warning = if (is.numeric(options$warning)) TRUE else options$warning,         if (options$error && options$include) 30:     .Internal(seterrmessage(msg[1L]))    TRUElapply(seq_len(cores), inner.do)        cat(msg, file = outFile)            0L
    keep_message = if (is.numeric(options$message)) TRUE else options$message, 
    }        .Internal(printDeferredWarnings())    }}, handlers), eval_continue = function() TRUE, eval_stop = function() FALSE)
 9:         else 2L13: in_dir(input_dir(), expr)    setwd(wd)    else prefix <- "Error : "    }
    if (!silent && isTRUE(getOption("show.error.messages"))) {12: sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE))    stop_on_error = if (is.numeric(options$error)) options$error else {build_mmm(net_GR, k = 2, covariates = c("Group"))
    write_utf8(res, output %n% stdout())    msg <- paste0(prefix, conditionMessage(e), "\n")    invisible(structure(msg, class = "try-error", condition = e))        if (options$error && options$include)     if (on_warning$silence) {parallel::mclapply(inits, .run_screen, mc.cores = n_cores)
    .Internal(seterrmessage(msg[1L]))    }, output_handler = knit_handlers(options$render, options))            0L        invokeRestart("muffleWarning")
})31: 28:         cat(msg, file = outFile)    }    if (!silent && isTRUE(getOption("show.error.messages"))) {

evaluate::evaluate(...)    paste0("\nQuitting from ", loc, if (!is.null(error)) 10: 13: 30: 14: in_input_dir(evaluate(code, envir = env, new_device = FALSE,         cat(msg, file = outFile)        paste0("\n", rule(), error, "\n", rule()))build_mmm(net_GR, k = 2, covariates = c("Group"))

    keep_warning = if (is.numeric(options$warning)) TRUE else options$warning,         .Internal(printDeferredWarnings())
        .Internal(printDeferredWarnings())FUN(X[[i]], ...)14:     keep_message = if (is.numeric(options$message)) TRUE else options$message, }, if (labels[i] != "") sprintf(" [%s]", labels[i]), get_loc) 8:     }in_dir(input_dir(), expr)29:     stop_on_error = if (is.numeric(options$error)) options$error else {        else 2L
}, error = function (cnd) 
evaluate(code, envir = env, new_device = FALSE, keep_warning = if (is.numeric(options$warning)) TRUE else options$warning, try(lapply(X = S, FUN = FUN, ...), silent = TRUE)    }, output_handler = knit_handlers(options$render, options))11: 
eval(expr, envir)    invisible(structure(msg, class = "try-error", condition = e))eval(expr, envir)    }        if (options$error && options$include)     keep_message = if (is.numeric(options$message)) TRUE else options$message, 
{
39: 31: lapply(seq_len(cores), inner.do) 9: 
})
in_input_dir(evaluate(code, envir = env, new_device = FALSE, 
15:     stop_on_error = if (is.numeric(options$error)) options$error else {            0L    invisible(structure(msg, class = "try-error", condition = e))process_file(text, output)15: 
    keep_warning = if (is.numeric(options$warning)) TRUE else options$warning, sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE))12: eval(expr, envir)eval(expr, envir)        else 2L})
parallel::mclapply(inits, .run_screen, mc.cores = n_cores) 8:         if (options$error && options$include)     }, output_handler = knit_handlers(options$render, options)))    watcher$capture_plot_and_output()

try(lapply(X = S, FUN = FUN, ...), silent = TRUE)30: 10: 
    cnd <- sanitize_call(cnd)13: 

FUN(X[[i]], ...)16: 
in_dir(input_dir(), expr)build_mmm(net_GR, k = 2, covariates = c("Group"))40:             0L
 9: 16: 
withVisible(eval(expr, envir))        else 2L

withVisible(eval(expr, envir))11:     watcher$push(cnd)sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE))32:  8: 
    keep_message = if (is.numeric(options$message)) TRUE else options$message, 31: 
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)))
32: eng_r(options)
33: block_exec(params)lapply(seq_len(cores), inner.do)    switch(on_error, continue = invokeRestart("eval_continue"),     stop_on_error = if (is.numeric(options$error)) options$error else {try(lapply(X = S, FUN = FUN, ...), silent = TRUE)17: knitr::knit(knit_input, knit_output, envir = envir, quiet = quiet)

10:     }, output_handler = knit_handlers(options$render, options))
34: 14:         if (options$error && options$include) FUN(X[[i]], ...)eng_r(options)
eval(expr, envir)
15: eval(expr, envir)30: in_dir(input_dir(), expr)
31: 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 2L12: 
            0L        stop = invokeRestart("eval_stop"), error = NULL)call_block(x)
withCallingHandlers(code, error = function (e) 17: 
})

    }, output_handler = knit_handlers(options$render, options)))rlang::entrace(e), message = function (cnd) parallel::mclapply(inits, .run_screen, mc.cores = n_cores) 9:         else 2LwithCallingHandlers(code, error = function (e) 
16: 
41: 
{32: sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE))
rmarkdown::render(file, encoding = encoding, quiet = quiet, envir = globalenv(), 18: withVisible(eval(expr, envir))eng_r(options)rlang::entrace(e), message = function (cnd) 35:     }, output_handler = knit_handlers(options$render, options)))13: process_group(group){    watcher$capture_plot_and_output()    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) {        cnd <- sanitize_call(cnd)        watcher$push(cnd)    }    if (on_warning$silence) {        invokeRestart("muffleWarning")    }}, error = function (cnd) {    output_dir = getwd(), ...)33: 

    watcher$capture_plot_and_output()

build_mmm(net_GR, k = 2, covariates = c("Group"))eval(call)    watcher$capture_plot_and_output()    cnd <- sanitize_call(cnd)block_exec(params)32: 

10:     watcher$push(cnd)
11:     if (on_message$capture) {19: FUN(X[[i]], ...)eng_r(options)42: 33:         watcher$push(cnd)eval(call)14: 
vweave_rmarkdown(...)
lapply(seq_len(cores), inner.do)
eval(expr, envir)11: 

block_exec(params)34: 
36: 17: 20: 
    switch(on_error, continue = invokeRestart("eval_continue"), 43: 
withCallingHandlers(code, error = function (e) lapply(seq_len(cores), inner.do)34:     }
15: rlang::entrace(e), message = function (cnd) 33: engine$weave(file, quiet = quiet, encoding = enc)    if (on_message$silence) {        stop = invokeRestart("eval_stop"), error = NULL)withCallingHandlers(if (tangle) process_tangle(group) else process_group(group), with_handlers({12: 
        invokeRestart("muffleMessage")44: doTryCatch(return(expr), name, parentenv, handler)
45: tryCatchOne(expr, names, parentenv, handlers[[1L]])
46: tryCatchList(expr, classes, parentenv, handlers)
    }}, warning = function (cnd) {    if (getOption("warn") >= 2 || getOption("warn") < 0) {        return()    }    watcher$capture_plot_and_output()    if (on_warning$capture) {        cnd <- sanitize_call(cnd)47: tryCatch({
    error = function(e) {    for (expr in tle$exprs) {{block_exec(params)    engine$weave(file, quiet = quiet, encoding = enc)12:         if (progress && is.function(pb$interrupt)) call_block(x)    watcher$capture_plot_and_output()
eval(expr, envir)})
18: eval(call)
19: eval(call)
20: 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)
21: doWithOneRestart(return(expr), restart)
22: withOneRestart(expr, restarts[[1L]])
23: withRestartList(expr, restarts[-nr])
24: doWithOneRestart(return(expr), restart)
25: withOneRestart(withRestartList(expr, restarts[-nr]), restarts[[nr]])
26: withRestartList(expr, restarts)
27: 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)
28: evaluate::evaluate(...)
29: 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 2Lparallel::mclapply(inits, .run_screen, mc.cores = n_cores)    if (on_message$capture) {        ev <- withVisible(eval(expr, envir))        watcher$push(cnd)        watcher$capture_plot_and_output()        watcher$print_value(ev$value, ev$visible, envir)    }, output_handler = knit_handlers(options$render, options))
        watcher$push(cnd)call_block(x)parallel::mclapply(inits, .run_screen, mc.cores = n_cores)
13: build_mmm(net_GR, k = 2, covariates = c("Group"))
14: eval(expr, envir)
15: eval(expr, envir)
16: 
35: 34: 
withVisible(eval(expr, envir))
            pb$interrupt()16: 35: process_group(group)
36: 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)    })
37: with_options(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group),     }withVisible(eval(expr, envir))        if (is_R_CMD_build() || is_R_CMD_check()) 13:     setwd(startdir)    }    if (on_message$silence) {
call_block(x)build_mmm(net_GR, k = 2, covariates = c("Group"))    output <- find_vignette_product(name, by = "weave", engine = engine)    if (on_warning$silence) {    error = function(e) {17: 

process_group(group)        invokeRestart("muffleWarning")    }withCallingHandlers(code, error = function (e)     if (!have.makefile && vignette_is_tex(output)) {14: 
    }    TRUE        if (progress && is.function(pb$interrupt)) 

30: rlang::entrace(e), message = function (cnd)         texi2pdf(file = output, clean = FALSE, quiet = quiet)35:             pb$interrupt()}, error = function (cnd) }, handlers){36: process_group(group)in_dir(input_dir(), expr)eval(expr, envir)        output <- find_vignette_product(name, by = "texi2pdf", 
15: eval(expr, envir)
16: withVisible(eval(expr, envir))
17: withCallingHandlers(code, error = function (e) rlang::entrace(e), message = function (cnd) {    watcher$capture_plot_and_output()    if (on_message$capture) {        watcher$push(cnd)    }    if (on_message$silence) {        if (is_R_CMD_build() || is_R_CMD_check()) withCallingHandlers(if (tangle) process_tangle(group) else process_group(group),             error <<- format(e)        invokeRestart("muffleMessage")
            engine = engine){    error = function(e) {        invokeRestart("muffleMessage")        if (progress && is.function(pb$interrupt))             pb$interrupt()        if (is_R_CMD_build() || is_R_CMD_check())             error <<- format(e)    })
37: 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()))
38: 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))     watcher$capture_plot_and_output()    })    }
31:         paste0("\n", rule(), error, "\n", rule()))    watcher$capture_plot_and_output()            error <<- format(e)
    }    if (on_message$capture) {
    cnd <- sanitize_call(cnd)36: in_input_dir(evaluate(code, envir = env, new_device = FALSE, 17:     }37: 21: }, error = function(e) {        watcher$push(cnd)}, if (labels[i] != "") sprintf(" [%s]", labels[i]), get_loc)    watcher$push(cnd)withCallingHandlers(if (tangle) process_tangle(group) else process_group(group), }, warning = function (cnd)     OK <<- FALSE}, warning = function (cnd) with_options(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group),     keep_warning = if (is.numeric(options$warning)) TRUE else options$warning,     }{
{    error = function(e) {    keep_message = if (is.numeric(options$message)) TRUE else options$message, doWithOneRestart(return(expr), restart)    error = function(e) {39:         if (progress && is.function(pb$interrupt))         if (progress && is.function(pb$interrupt))     if (getOption("warn") >= 2 || getOption("warn") < 0) {    if (on_message$silence) {        invokeRestart("muffleMessage")    }}, warning = function (cnd)     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)))
            pb$interrupt()    message(gettextf("Error: processing vignette '%s' failed with diagnostics:\n%s", withCallingHandlers(code, error = function (e)     switch(on_error, continue = invokeRestart("eval_continue"), process_file(text, output)32: 
40: knitr::knit(knit_input, knit_output, envir = envir, quiet = quiet)
41: rmarkdown::render(file, encoding = encoding, quiet = quiet, envir = globalenv(),     output_dir = getwd(), ...)eng_r(options)            pb$interrupt()    if (getOption("warn") >= 2 || getOption("warn") < 0) {        file, conditionMessage(e)))
{        return()    }), list(rlang_trace_top_env = knit_global()))        return()rlang::entrace(e), message = function (cnd) 
        if (is_R_CMD_build() || is_R_CMD_check()) 33: block_exec(params)
34: call_block(x)
35: process_group(group)
36: 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)    })
37: 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()))
38: 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)})    }{

        stop = invokeRestart("eval_stop"), error = NULL)38: 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)) 22:             error <<- format(e)    if (getOption("warn") >= 2 || getOption("warn") < 0) {    }), 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)
39: process_file(text, output)
40: knitr::knit(knit_input, knit_output, envir = envir, quiet = quiet)
41: rmarkdown::render(file, encoding = encoding, quiet = quiet, envir = globalenv(),     output_dir = getwd(), ...)
42: vweave_rmarkdown(...)
43: engine$weave(file, quiet = quiet, encoding = enc)
})
        if (is_R_CMD_build() || is_R_CMD_check()) 42:     watcher$capture_plot_and_output()    }withOneRestart(expr, restarts[[1L]])        paste0("\n", rule(), error, "\n", rule()))
23: withRestartList(expr, restarts[-nr])
24: vweave_rmarkdown(...)44:     watcher$capture_plot_and_output()            error <<- format(e)    if (on_message$capture) {doWithOneRestart(return(expr), restart)
}, if (labels[i] != "") sprintf(" [%s]", labels[i]), get_loc)48: tools:::.buildOneVignette("transition-networks.Rmd", "/Volumes/Builds/packages/big-sur-arm64/results/4.5/Nestimate.Rcheck/vign_test/Nestimate",     TRUE, FALSE, "transition-networks", "UTF-8", "/Volumes/Temp/tmp/RtmpxaL00L/file11a94792e0301.rds")
An irrecoverable exception occurred. R is aborting now ...
    }), list(rlang_trace_top_env = knit_global()))
38: xfun:::handle_error(with_options(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group),     watcher$capture_plot_and_output()        return()
    })
    if (on_warning$capture) {doTryCatch(return(expr), name, parentenv, handler)    }18:         watcher$push(cnd)43:     if (on_warning$capture) {

eval(call)        cnd <- sanitize_call(cnd)25: engine$weave(file, quiet = quiet, encoding = enc)39:     }    error = function(e) {    watcher$capture_plot_and_output()withOneRestart(withRestartList(expr, restarts[-nr]), restarts[[nr]])

    if (on_message$silence) {        if (progress && is.function(pb$interrupt)) 37: process_file(text, output)19:         cnd <- sanitize_call(cnd)
            pb$interrupt()with_options(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group), 45:         watcher$push(cnd)        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)
    error = function(e) {        invokeRestart("muffleMessage")    }}, warning = function (cnd) {
        watcher$push(cnd)tryCatchOne(expr, names, parentenv, handlers[[1L]])    if (on_warning$capture) {26: eval(call)39:     }        if (progress && is.function(pb$interrupt))     if (getOption("warn") >= 2 || getOption("warn") < 0) {withRestartList(expr, restarts)

process_file(text, output)            pb$interrupt()
40: knitr::knit(knit_input, knit_output, envir = envir, quiet = quiet)
41: rmarkdown::render(file, encoding = encoding, quiet = quiet, envir = globalenv(),     output_dir = getwd(), ...)
42: vweave_rmarkdown(...)
43: engine$weave(file, quiet = quiet, encoding = enc)
44: doTryCatch(return(expr), name, parentenv, handler)
45: tryCatchOne(expr, names, parentenv, handlers[[1L]])
46: tryCatchList(expr, classes, parentenv, handlers)
47: 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)    }}, error = function(e) {    OK <<- FALSE    message(gettextf("Error: processing vignette '%s' failed with diagnostics:\n%s",         file, conditionMessage(e)))})
48: tools:::.buildOneVignette("transition-networks.Rmd", "/Volumes/Builds/packages/big-sur-arm64/results/4.5/Nestimate.Rcheck/vign_test/Nestimate",     TRUE, FALSE, "transition-networks", "UTF-8", "/Volumes/Temp/tmp/RtmpxaL00L/file11a94792e0301.rds")
An irrecoverable exception occurred. R is aborting now ...
        if (is_R_CMD_build() || is_R_CMD_check())             error <<- format(e)    }), list(rlang_trace_top_env = knit_global()))40: 
44:         return()
knitr::knit(knit_input, knit_output, envir = envir, quiet = quiet)    if (on_warning$silence) {20: with_handlers({doTryCatch(return(expr), name, parentenv, handler)        invokeRestart("muffleWarning")    }}, 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)})
18: eval(call)
19: eval(call)
20: with_handlers({    for (expr in tle$exprs) {        ev <- withVisible(eval(expr, envir))        watcher$capture_plot_and_output()
45: tryCatchOne(expr, names, parentenv, handlers[[1L]])
46: 
    for (expr in tle$exprs) {    }        cnd <- sanitize_call(cnd)tryCatchList(expr, classes, parentenv, handlers)        watcher$push(cnd)    }    if (on_warning$silence) {        invokeRestart("muffleWarning")38: 

    watcher$capture_plot_and_output()    }27:     }47: 41:     if (on_warning$capture) {46:         cnd <- sanitize_call(cnd)tryCatchList(expr, classes, parentenv, handlers)
47: 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)    }}, error = function(e) {    OK <<- FALSE    message(gettextf("Error: processing vignette '%s' failed with diagnostics:\n%s",         file, conditionMessage(e)))})
48: tools:::.buildOneVignette("transition-networks.Rmd", "/Volumes/Builds/packages/big-sur-arm64/results/4.5/Nestimate.Rcheck/vign_test/Nestimate",     TRUE, FALSE, "transition-networks", "UTF-8", "/Volumes/Temp/tmp/RtmpxaL00L/file11a94792e0301.rds")
An irrecoverable exception occurred. R is aborting now ...
        watcher$push(cnd)    }    if (on_warning$silence) {        invokeRestart("muffleWarning")    }}, 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)})
18: eval(call)
19: eval(call)
20: 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)
}, error = function (cnd) rmarkdown::render(file, encoding = encoding, quiet = quiet, envir = globalenv(),     output_dir = getwd(), ...)
42: vweave_rmarkdown(...)
43: engine$weave(file, quiet = quiet, encoding = enc)
44: doTryCatch(return(expr), name, parentenv, handler)
45: tryCatchOne(expr, names, parentenv, handlers[[1L]])
46: withRestarts(with_handlers({{xfun:::handle_error(with_options(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group),         ev <- withVisible(eval(expr, envir))    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())        watcher$capture_plot_and_output()        watcher$print_value(ev$value, ev$visible, envir)    }    TRUE}, handlers)
21: doWithOneRestart(return(expr), restart)
22: withOneRestart(expr, restarts[[1L]])
23: withRestartList(expr, restarts[-nr])
        watcher$print_value(ev$value, ev$visible, envir)21: doWithOneRestart(return(expr), restart)
22: withOneRestart(expr, restarts[[1L]])
23: withRestartList(expr, restarts[-nr])
24: doWithOneRestart(return(expr), restart)
25: withOneRestart(withRestartList(expr, restarts[-nr]), restarts[[nr]])
26: withRestartList(expr, restarts)
27: withRestarts(with_handlers({    watcher$capture_plot_and_output()    paste0("\nQuitting from ", loc, if (!is.null(error)) tryCatch({    if (on_warning$silence) {    cnd <- sanitize_call(cnd)        invokeRestart("muffleWarning")    }    }        paste0("\n", rule(), error, "\n", rule()))    engine$weave(file, quiet = quiet, encoding = enc)    for (expr in tle$exprs) {tryCatchList(expr, classes, parentenv, handlers)    for (expr in tle$exprs) {
47: 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)    }}, error = function(e) {    OK <<- FALSE    message(gettextf("Error: processing vignette '%s' failed with diagnostics:\n%s",         file, conditionMessage(e)))})
}, if (labels[i] != "") sprintf(" [%s]", labels[i]), get_loc)    watcher$push(cnd)}, error = function (cnd)     switch(on_error, continue = invokeRestart("eval_continue"),         stop = invokeRestart("eval_stop"), error = NULL)})
18: eval(call)
19: eval(call)
20:         ev <- withVisible(eval(expr, envir))24: 
48: {    TRUE        watcher$capture_plot_and_output()doWithOneRestart(return(expr), restart)39: tools:::.buildOneVignette("transition-networks.Rmd", "/Volumes/Builds/packages/big-sur-arm64/results/4.5/Nestimate.Rcheck/vign_test/Nestimate",     watcher$capture_plot_and_output()}, handlers)        watcher$print_value(ev$value, ev$visible, envir)with_handlers({    setwd(startdir)        ev <- withVisible(eval(expr, envir))    cnd <- sanitize_call(cnd)
    }    for (expr in tle$exprs) {    output <- find_vignette_product(name, by = "weave", engine = engine)        watcher$capture_plot_and_output()    TRUE, FALSE, "transition-networks", "UTF-8", "/Volumes/Temp/tmp/RtmpxaL00L/file11a94792e0301.rds")        watcher$print_value(ev$value, ev$visible, envir)    }    TRUE}, handlers), eval_continue = function() TRUE, eval_stop = function() FALSE)
28: evaluate::evaluate(...)
29: 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))
30: process_file(text, output)        ev <- withVisible(eval(expr, envir))    if (!have.makefile && vignette_is_tex(output)) {        watcher$capture_plot_and_output()    watcher$push(cnd)in_dir(input_dir(), expr)

25:         watcher$print_value(ev$value, ev$visible, envir)withOneRestart(withRestartList(expr, restarts[-nr]), restarts[[nr]])
26: withRestartList(expr, restarts)
27: withRestarts(with_handlers({    for (expr in tle$exprs) {        ev <- withVisible(eval(expr, envir))
21:     switch(on_error, continue = invokeRestart("eval_continue"), doWithOneRestart(return(expr), restart)
22: withOneRestart(expr, restarts[[1L]])
23: withRestartList(expr, restarts[-nr])
    }        stop = invokeRestart("eval_stop"), error = NULL)})
18: eval(call)
19: eval(call)
20: 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)
21: doWithOneRestart(return(expr), restart)
22: withOneRestart(expr, restarts[[1L]])    TRUE        watcher$capture_plot_and_output()An irrecoverable exception occurred. R is aborting now ...
24: 31:     TRUE}, handlers), eval_continue = function() TRUE, eval_stop = function() FALSE)}, handlers)
21: doWithOneRestart(return(expr), restart)
22: withOneRestart(expr, restarts[[1L]])
23: withRestartList(expr, restarts[-nr])
24: doWithOneRestart(return(expr), restart)
25: withOneRestart(withRestartList(expr, restarts[-nr]), restarts[[nr]])
26: withRestartList(expr, restarts)
27: 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)
28: evaluate::evaluate(...)
29: evaluate(code, envir = env, new_device = FALSE, keep_warning = if (is.numeric(options$warning)) TRUE else options$warning, 

in_input_dir(evaluate(code, envir = env, new_device = FALSE,         watcher$print_value(ev$value, ev$visible, envir)    }    TRUE}, handlers), eval_continue = function() TRUE, eval_stop = function() FALSE)
28: evaluate::evaluate(...)
29: evaluate(code, envir = env, new_device = FALSE, keep_warning = if (is.numeric(options$warning)) TRUE else options$warning, 28:         texi2pdf(file = output, clean = FALSE, quiet = quiet)    keep_message = if (is.numeric(options$message)) TRUE else options$message,     keep_message = if (is.numeric(options$message)) TRUE else options$message,         output <- find_vignette_product(name, by = "texi2pdf",     keep_warning = if (is.numeric(options$warning)) TRUE else options$warning, 
    stop_on_error = if (is.numeric(options$error)) options$error else {evaluate::evaluate(...)40:     keep_message = if (is.numeric(options$message)) TRUE else options$message,     stop_on_error = if (is.numeric(options$error)) options$error else {doWithOneRestart(return(expr), restart)23:     stop_on_error = if (is.numeric(options$error)) options$error else {

        if (options$error && options$include)             0L29: evaluate(code, envir = env, new_device = FALSE, keep_warning = if (is.numeric(options$warning)) TRUE else options$warning,         if (options$error && options$include) withRestartList(expr, restarts[-nr])knitr::knit(knit_input, knit_output, envir = envir, quiet = quiet)            0L        else 2L    }, output_handler = knit_handlers(options$render, options)))
32: eng_r(options)            engine = engine)        if (options$error && options$include) 
41: rmarkdown::render(file, encoding = encoding, quiet = quiet, envir = globalenv(),     output_dir = getwd(), ...)
42: vweave_rmarkdown(...)
43: engine$weave(file, quiet = quiet, encoding = enc)
44:     }        else 2L
            0L
33: block_exec(params)
34: call_block(x)
        else 2L24:     }, output_handler = knit_handlers(options$render, options))
25: doWithOneRestart(return(expr), restart)35: process_group(group)withOneRestart(withRestartList(expr, restarts[-nr]), restarts[[nr]])30:     keep_message = if (is.numeric(options$message)) TRUE else options$message, 
    stop_on_error = if (is.numeric(options$error)) options$error else {
36: 
25: withOneRestart(withRestartList(expr, restarts[-nr]), restarts[[nr]])        if (options$error && options$include) 26:             0L        else 2LwithRestartList(expr, restarts)
27: 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)    }    TRUEin_dir(input_dir(), expr)withCallingHandlers(if (tangle) process_tangle(group) else process_group(group),     }, output_handler = knit_handlers(options$render, options))    error = function(e) {        if (progress && is.function(pb$interrupt))             pb$interrupt()        if (is_R_CMD_build() || is_R_CMD_check())             error <<- format(e)    })
    }, output_handler = knit_handlers(options$render, options))}, error = function(e) {doTryCatch(return(expr), name, parentenv, handler)
37: 

30: 30: 31: with_options(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group), 
in_dir(input_dir(), expr)in_dir(input_dir(), expr)    error = function(e) {
in_input_dir(evaluate(code, envir = env, new_device = FALSE,     OK <<- FALSE}, handlers), eval_continue = function() TRUE, eval_stop = function() FALSE)    message(gettextf("Error: processing vignette '%s' failed with diagnostics:\n%s",         file, conditionMessage(e)))})
48: tools:::.buildOneVignette("transition-networks.Rmd", "/Volumes/Builds/packages/big-sur-arm64/results/4.5/Nestimate.Rcheck/vign_test/Nestimate",     TRUE, FALSE, "transition-networks", "UTF-8", "/Volumes/Temp/tmp/RtmpxaL00L/file11a94792e0301.rds")        if (progress && is.function(pb$interrupt)) 
    keep_warning = if (is.numeric(options$warning)) TRUE else options$warning, 26: withRestartList(expr, restarts)
27: withRestarts(with_handlers({
31: 
            pb$interrupt()28: evaluate::evaluate(...)
29: 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))
30: in_dir(input_dir(), expr)
31: 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)))
32: eng_r(options)
33: block_exec(params)
34: call_block(x)
    keep_message = if (is.numeric(options$message)) TRUE else options$message, 31: 45: 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)             0LAn irrecoverable exception occurred. R is aborting now ...
tryCatchOne(expr, names, parentenv, handlers[[1L]])
46: tryCatchList(expr, classes, parentenv, handlers)
47: 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)    }}, error = function(e) {    OK <<- FALSE    message(gettextf("Error: processing vignette '%s' failed with diagnostics:\n%s",         file, conditionMessage(e)))})    for (expr in tle$exprs) {    stop_on_error = if (is.numeric(options$error)) options$error else {        if (is_R_CMD_build() || is_R_CMD_check()) in_input_dir(evaluate(code, envir = env, new_device = FALSE,             error <<- format(e)    }), list(rlang_trace_top_env = knit_global()))

        ev <- withVisible(eval(expr, envir))
38:         else 2L        watcher$capture_plot_and_output()    }, output_handler = knit_handlers(options$render, options)))
32: eng_r(options)
33: block_exec(params)
34: call_block(x)
35: process_group(group)
36: 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)        watcher$print_value(ev$value, ev$visible, envir)    }xfun:::handle_error(with_options(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group), 35:         if (options$error && options$include) process_group(group)
36: 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)    })
37: 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()))
38: 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)
39: process_file(text, output)            0L        else 2L    }, output_handler = knit_handlers(options$render, options)))
32: eng_r(options)
33: block_exec(params)
34:     TRUE    error = function(e) {}, handlers), eval_continue = function() TRUE, eval_stop = function() FALSE)
28: evaluate::evaluate(...)
29: 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))
30: in_dir(input_dir(), expr)
31: 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)))
32:         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)
39: process_file(text, output)
40: knitr::knit(knit_input, knit_output, envir = envir, quiet = quiet)
41:     keep_warning = if (is.numeric(options$warning)) TRUE else options$warning, rmarkdown::render(file, encoding = encoding, quiet = quiet, envir = globalenv(),     output_dir = getwd(), ...)
42: vweave_rmarkdown(...)
43: engine$weave(file, quiet = quiet, encoding = enc)
44: doTryCatch(return(expr), name, parentenv, handler)
45: tryCatchOne(expr, names, parentenv, handlers[[1L]])
46: tryCatchList(expr, classes, parentenv, handlers)
47: tryCatch({    })    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)))
32: eng_r(options)
33: block_exec(params)
34: call_block(x)
35: process_group(group)
36: withCallingHandlers(if (tangle) process_tangle(group) else process_group(group),     error = function(e) {        if (progress && is.function(pb$interrupt)) 
eng_r(options)call_block(x)

40: 48: tools:::.buildOneVignette("transition-networks.Rmd", "/Volumes/Builds/packages/big-sur-arm64/results/4.5/Nestimate.Rcheck/vign_test/Nestimate",     TRUE, FALSE, "transition-networks", "UTF-8", "/Volumes/Temp/tmp/RtmpxaL00L/file11a94792e0301.rds")
An irrecoverable exception occurred. R is aborting now ...
    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)35: process_group(group)
36: withCallingHandlers(if (tangle) process_tangle(group) else process_group(group),     error = function(e) {        if (progress && is.function(pb$interrupt))             pb$interrupt()33:             pb$interrupt()knitr::knit(knit_input, knit_output, envir = envir, quiet = quiet)

41: rmarkdown::render(file, encoding = encoding, quiet = quiet, envir = globalenv(),     output_dir = getwd(), ...)
42: vweave_rmarkdown(...)block_exec(params)    }}, error = function(e) {        if (is_R_CMD_build() || is_R_CMD_check()) 37: 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()))
38: xfun:::handle_error(with_options(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group),     error = function(e) {        if (is_R_CMD_build() || is_R_CMD_check())             error <<- format(e)    OK <<- FALSE            error <<- format(e)        if (progress && is.function(pb$interrupt)) 
    message(gettextf("Error: processing vignette '%s' failed with diagnostics:\n%s",         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) {34: 
37: 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()) })
48: tools:::.buildOneVignette("transition-networks.Rmd", "/Volumes/Builds/packages/big-sur-arm64/results/4.5/Nestimate.Rcheck/vign_test/Nestimate",     TRUE, FALSE, "transition-networks", "UTF-8", "/Volumes/Temp/tmp/RtmpxaL00L/file11a94792e0301.rds")
An irrecoverable exception occurred. R is aborting now ...

            error <<- format(e)call_block(x)    }), list(rlang_trace_top_env = knit_global()))

35: 43: engine$weave(file, quiet = quiet, encoding = enc)
44: 38: process_group(group)
    setwd(wd)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))     write_utf8(res, output %n% stdout())    paste0("\nQuitting from ", loc, if (!is.null(error)) 36: doTryCatch(return(expr), name, parentenv, handler)        paste0("\n", rule(), error, "\n", rule()))37: 
        paste0("\n", rule(), error, "\n", rule()))}, if (labels[i] != "") sprintf(" [%s]", labels[i]), get_loc)
with_options(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group),     error = function(e) {        if (progress && is.function(pb$interrupt))             pb$interrupt()}, if (labels[i] != "") sprintf(" [%s]", labels[i]), get_loc)withCallingHandlers(if (tangle) process_tangle(group) else process_group(group), 
39: process_file(text, output)
40: knitr::knit(knit_input, knit_output, envir = envir, quiet = quiet)
        if (is_R_CMD_build() || is_R_CMD_check()) 41:     error = function(e) {45: tryCatchOne(expr, names, parentenv, handlers[[1L]])
46: tryCatchList(expr, classes, parentenv, handlers)
47: 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", rmarkdown::render(file, encoding = encoding, quiet = quiet, envir = globalenv(), 39: process_file(text, output)
40: knitr::knit(knit_input, knit_output, envir = envir, quiet = quiet)
41: rmarkdown::render(file, encoding = encoding, quiet = quiet, envir = globalenv(),         if (progress && is.function(pb$interrupt))             error <<- format(e)            pb$interrupt()        if (is_R_CMD_build() || is_R_CMD_check())             error <<- format(e)    })
37:     output_dir = getwd(), ...)    output_dir = getwd(), ...)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()))
38: xfun:::handle_error(with_options(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group),     error = function(e) {
42: vweave_rmarkdown(...)
43: engine$weave(file, quiet = quiet, encoding = enc)
44: doTryCatch(return(expr), name, parentenv, handler)
45: tryCatchOne(expr, names, parentenv, handlers[[1L]])

42: vweave_rmarkdown(...)
43: engine$weave(file, quiet = quiet, encoding = enc)
44: doTryCatch(return(expr), name, parentenv, handler)
45: tryCatchOne(expr, names, parentenv, handlers[[1L]])
46: tryCatchList(expr, classes, parentenv, handlers)
47:             engine = engine)        if (progress && is.function(pb$interrupt))     }}, error = function(e) {    OK <<- FALSE    message(gettextf("Error: processing vignette '%s' failed with diagnostics:\n%s",         file, conditionMessage(e)))})
48: tools:::.buildOneVignette("transition-networks.Rmd", "/Volumes/Builds/packages/big-sur-arm64/results/4.5/Nestimate.Rcheck/vign_test/Nestimate",     TRUE, FALSE, "transition-networks", "UTF-8", "/Volumes/Temp/tmp/RtmpxaL00L/file11a94792e0301.rds")
An irrecoverable exception occurred. R is aborting now ...
    }), list(rlang_trace_top_env = knit_global()))
38:             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)
39: process_file(text, output)
40: knitr::knit(knit_input, knit_output, envir = envir, quiet = quiet)
41: rmarkdown::render(file, encoding = encoding, quiet = quiet, envir = globalenv(),     output_dir = getwd(), ...)
42: vweave_rmarkdown(...)
43: engine$weave(file, quiet = quiet, encoding = enc)
44: doTryCatch(return(expr), name, parentenv, handler)
45: xfun:::handle_error(with_options(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group), 46: tryCatch({tryCatchList(expr, classes, parentenv, handlers)tryCatchOne(expr, names, parentenv, handlers[[1L]])
    error = function(e) {        if (progress && is.function(pb$interrupt)) 46:     engine$weave(file, quiet = quiet, encoding = enc)
    setwd(startdir)            pb$interrupt()tryCatchList(expr, classes, parentenv, handlers)
47: 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)    }}, error = function(e) {    OK <<- FALSE    message(gettextf("Error: processing vignette '%s' failed with diagnostics:\n%s",         file, conditionMessage(e)))})
48: tools:::.buildOneVignette("transition-networks.Rmd", "/Volumes/Builds/packages/big-sur-arm64/results/4.5/Nestimate.Rcheck/vign_test/Nestimate",     TRUE, FALSE, "transition-networks", "UTF-8", "/Volumes/Temp/tmp/RtmpxaL00L/file11a94792e0301.rds")
An irrecoverable exception occurred. R is aborting now ...
    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", 47: 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)    }}, error = function(e) {    OK <<- FALSE    message(gettextf("Error: processing vignette '%s' failed with diagnostics:\n%s",         file, conditionMessage(e)))})
48: tools:::.buildOneVignette("transition-networks.Rmd", "/Volumes/Builds/packages/big-sur-arm64/results/4.5/Nestimate.Rcheck/vign_test/Nestimate",     TRUE, FALSE, "transition-networks", "UTF-8", "/Volumes/Temp/tmp/RtmpxaL00L/file11a94792e0301.rds")
An irrecoverable exception occurred. R is aborting now ...
            engine = engine)    }}, error = function(e) {    OK <<- FALSE    message(gettextf("Error: processing vignette '%s' failed with diagnostics:\n%s",         file, conditionMessage(e)))})
48: tools:::.buildOneVignette("transition-networks.Rmd", "/Volumes/Builds/packages/big-sur-arm64/results/4.5/Nestimate.Rcheck/vign_test/Nestimate",     TRUE, FALSE, "transition-networks", "UTF-8", "/Volumes/Temp/tmp/RtmpxaL00L/file11a94792e0301.rds")
An irrecoverable exception occurred. R is aborting now ...
        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)
39: process_file(text, output)
40: knitr::knit(knit_input, knit_output, envir = envir, quiet = quiet)
41: rmarkdown::render(file, encoding = encoding, quiet = quiet, envir = globalenv(),     output_dir = getwd(), ...)
42: vweave_rmarkdown(...)
43: engine$weave(file, quiet = quiet, encoding = enc)
44: doTryCatch(return(expr), name, parentenv, handler)
45: tryCatchOne(expr, names, parentenv, handlers[[1L]])
46: tryCatchList(expr, classes, parentenv, handlers)
47: 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)    }}, error = function(e) {    OK <<- FALSE    message(gettextf("Error: processing vignette '%s' failed with diagnostics:\n%s",         file, conditionMessage(e)))})
48: tools:::.buildOneVignette("transition-networks.Rmd", "/Volumes/Builds/packages/big-sur-arm64/results/4.5/Nestimate.Rcheck/vign_test/Nestimate",     TRUE, FALSE, "transition-networks", "UTF-8", "/Volumes/Temp/tmp/RtmpxaL00L/file11a94792e0301.rds")
An irrecoverable exception occurred. R is aborting now ...

Quitting from transition-networks.Rmd:208-217 [mmm]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
<error/rlang_error>
Error in `matrix()`:
! 'data' must be of a vector type, was 'NULL'
---
Backtrace:
    ▆
 1. └─Nestimate::build_mmm(net_GR, k = 2, covariates = c("Group"))
 2.   └─base::lapply(...)
 3.     └─Nestimate (local) FUN(X[[i]], ...)
 4.       ├─base::t(matrix(P_vec, nrow = n_states, ncol = n_states))
 5.       └─base::matrix(P_vec, nrow = n_states, ncol = n_states)
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Error: processing vignette 'transition-networks.Rmd' failed with diagnostics:
'data' must be of a vector type, was 'NULL'
--- failed re-building ‘transition-networks.Rmd’

SUMMARY: processing the following file failed:
  ‘transition-networks.Rmd’

Error: Vignette re-building failed.
Execution halted