Error(s) in re-building vignettes:
--- re-building ‘clustering.Rmd’ using rmarkdown
2026-04-15 17:05:58.393 R[68953:645037] 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-15 17:06:04.843 R[72359:650395] 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)

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: 
 *** caught segfault ***
address 0x110, cause 'invalid permissions'
FUN(X[[i]], ...)
 3: lapply(X = S, FUN = FUN, ...)
 *** caught segfault ***
address 0x110, cause 'invalid permissions'

 4: doTryCatch(return(expr), name, parentenv, handler)

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(...)
 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)
 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(), ...)

Traceback:
40: knitr::knit(knit_input, knit_output, envir = envir, quiet = quiet)
41: 43: 
Traceback:

Traceback:
rmarkdown::render(file, encoding = encoding, quiet = quiet, envir = globalenv(),     output_dir = getwd(), ...)

 *** caught segfault ***
address 0x110, cause 'invalid permissions'
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/RtmpkBrGSE/file106f03e6428fd.rds")
An irrecoverable exception occurred. R is aborting now ...
 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 {engine$weave(file, quiet = quiet, encoding = enc) 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)
Traceback:

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/RtmpkBrGSE/file106f03e6428fd.rds")
An irrecoverable exception occurred. R is aborting now ...
        dcall <- deparse(call, nlines = 1L)        prefix <- paste("Error in", dcall, ": ")        LONG <- 75L        sm <- strsplit(conditionMessage(e), "\n")[[1L]]
 *** caught segfault ***
42:         if (options$error && options$include)  1: 44: address 0x110, cause 'invalid permissions'
.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))vweave_rmarkdown(...) 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) {})
 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:     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)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", block_exec(params)            0L
 *** caught segfault ***
        w <- 14L + nchar(dcall, type = "w") + nchar(sm[1L], type = "w")})
18: eval(call)
19: eval(call)
20:         if (is.na(w)) 
 *** 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/RtmpkBrGSE/file106f03e6428fd.rds")
An irrecoverable exception occurred. R is aborting now ...
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)

            engine = engine)
34: call_block(x)
43: engine$weave(file, quiet = quiet, encoding = enc)address 0x110, cause 'invalid permissions'

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/RtmpkBrGSE/file106f03e6428fd.rds")
An irrecoverable exception occurred. R is aborting now ...
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/RtmpkBrGSE/file106f03e6428fd.rds")
An irrecoverable exception occurred. R is aborting now ...
        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)
Traceback:

    }            w <- 14L + nchar(dcall, type = "b") + nchar(sm[1L], 34: 35: process_group(group)
36:                 type = "b")
 *** caught segfault ***
        if (w > LONG) }, error = function(e) { 1:     OK <<- FALSE.mmm_em(counts, init_state, k, screen_iter, tol, smooth, n_states, withCallingHandlers(if (tangle) process_tangle(group) else process_group(group), address 0x110, cause 'invalid permissions'
    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),     message(gettextf("Error: processing vignette '%s' failed with diagnostics:\n%s",         file, conditionMessage(e)))    error = function(e) {        if (progress && is.function(pb$interrupt))             pb$interrupt()        if (is_R_CMD_build() || is_R_CMD_check())             error <<- format(e)    }), list(rlang_trace_top_env = knit_global()))
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) {    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"))) {            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)call_block(x)
35: process_group(group)
})
48:         cat(msg, file = outFile)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)        .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]], ...)tools:::.buildOneVignette("transition-networks.Rmd", "/Volumes/Builds/packages/big-sur-arm64/results/4.5/Nestimate.Rcheck/vign_test/Nestimate",     }}, 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/RtmpkBrGSE/file106f03e6428fd.rds")
An irrecoverable exception occurred. R is aborting now ...
    OK <<- FALSE
 *** caught segfault ***
address 0x110, cause 'invalid permissions'

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:     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/RtmpkBrGSE/file106f03e6428fd.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: 
 *** caught segfault ***
address 0x110, cause 'invalid permissions'
        .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:     TRUE, FALSE, "transition-networks", "UTF-8", "/Volumes/Temp/tmp/RtmpkBrGSE/file106f03e6428fd.rds")
withVisible(eval(expr, envir))
17: FUN(X[[i]], ...)withCallingHandlers(code, error = function (e) 
doWithOneRestart(return(expr), restart)An irrecoverable exception occurred. R is aborting now ...
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) {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"))        cnd <- sanitize_call(cnd)        watcher$push(cnd)    }    if (on_warning$silence) {        invokeRestart("muffleWarning")    }}, error = function (cnd) {
22: withOneRestart(expr, restarts[[1L]])
23:     watcher$capture_plot_and_output()    cnd <- sanitize_call(cnd)    watcher$push(cnd)    switch(on_error, continue = invokeRestart("eval_continue"), withRestartList(expr, restarts[-nr])
24: doWithOneRestart(return(expr), restart)
25: withOneRestart(withRestartList(expr, restarts[-nr]), restarts[[nr]])
26: withRestartList(expr, restarts)
14: eval(expr, envir)

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

15:  2:         stop = invokeRestart("eval_stop"), error = NULL)27: withRestarts(with_handlers({FUN(X[[i]], ...)
 3: lapply(X = S, FUN = FUN, ...)
 4: doTryCatch(return(expr), name, parentenv, handler)})
18:     for (expr in tle$exprs) {        ev <- withVisible(eval(expr, envir))
 *** caught segfault ***
address 0x110, cause 'invalid permissions'

 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)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)
        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)) eval(call)
19: eval(call)        watcher$capture_plot_and_output()        watcher$print_value(ev$value, ev$visible, envir)    }    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)
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}, handlers), eval_continue = function() TRUE, eval_stop = function() FALSE)20: with_handlers({    for (expr in tle$exprs) {        else 2L
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]], ...)
        ev <- withVisible(eval(expr, envir)) 3: 
            w <- 14L + nchar(dcall, type = "b") + nchar(sm[1L],     }, output_handler = knit_handlers(options$render, options))
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]]                type = "b")        if (w > LONG)             prefix <- paste0(prefix, "\n  ")    }    else prefix <- "Error : "    msg <- paste0(prefix, conditionMessage(e), "\n")    .Internal(seterrmessage(msg[1L]))28: evaluate::evaluate(...)
        w <- 14L + nchar(dcall, type = "w") + nchar(sm[1L], type = "w")lapply(X = S, FUN = FUN, ...)        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))})

 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")29:         watcher$capture_plot_and_output()        watcher$print_value(ev$value, ev$visible, envir)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    .Internal(seterrmessage(msg[1L]))    if (!silent && isTRUE(getOption("show.error.messages"))) {        cat(msg, file = outFile)        .Internal(printDeferredWarnings())30: in_dir(input_dir(), expr)
31: in_input_dir(evaluate(code, envir = env, new_device = FALSE,     if (!silent && isTRUE(getOption("show.error.messages"))) {        cat(msg, file = outFile)    keep_warning = if (is.numeric(options$warning)) TRUE else options$warning,     }, 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)
Traceback:

        .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))    keep_message = if (is.numeric(options$message)) TRUE else options$message,  8: try(lapply(X = S, FUN = FUN, ...), silent = TRUE)
 9: sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE))
    TRUE10: 
    }
10: FUN(X[[i]], ...)37:     invisible(structure(msg, class = "try-error", condition = e))}, handlers)
 1: with_options(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group), 11:     error = function(e) {FUN(X[[i]], ...)    stop_on_error = if (is.numeric(options$error)) options$error else {        if (options$error && options$include)             0L        else 2L.mmm_em(counts, init_state, k, screen_iter, tol, smooth, n_states, })
11:     init_posterior = init, from_ind = from_ind, cov_df = NULL)lapply(seq_len(cores), inner.do)lapply(seq_len(cores), inner.do)
12:     }, output_handler = knit_handlers(options$render, options)))
32: parallel::mclapply(inits, .run_screen, mc.cores = n_cores)
21: doWithOneRestart(return(expr), restart)eng_r(options)
33: block_exec(params)


13: build_mmm(net_GR, k = 2, covariates = c("Group"))
34: 
Traceback:
 1: 14: 22: withOneRestart(expr, restarts[[1L]])
23: withRestartList(expr, restarts[-nr])
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)})eval(expr, envir)
15: eval(expr, envir)
.mmm_em(counts, init_state, k, screen_iter, tol, smooth, n_states, call_block(x)
        if (progress && is.function(pb$interrupt))             pb$interrupt()        if (is_R_CMD_build() || is_R_CMD_check())             error <<- format(e)18:     init_posterior = init, from_ind = from_ind, cov_df = NULL)eval(call)
35: 

16:     }), list(rlang_trace_top_env = knit_global()))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)    })
withVisible(eval(expr, envir))
38: xfun:::handle_error(with_options(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group),  2: 
17: FUN(X[[i]], ...)    error = function(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()))
        if (progress && is.function(pb$interrupt)) 24: withCallingHandlers(code, error = function (e) 
            pb$interrupt()38:  3:  2: doWithOneRestart(return(expr), restart)        if (is_R_CMD_build() || is_R_CMD_check()) lapply(X = S, FUN = FUN, ...)
            error <<- format(e)
    }), list(rlang_trace_top_env = knit_global())), function(loc) {FUN(X[[i]], ...)xfun:::handle_error(with_options(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group),     error = function(e) {    setwd(wd) 4: rlang::entrace(e), message = function (cnd) 
 3: lapply(X = S, FUN = FUN, ...)
 4: doTryCatch(return(expr), name, parentenv, handler)
19: {    watcher$capture_plot_and_output()    if (on_message$capture) {    write_utf8(res, output %n% stdout())doTryCatch(return(expr), name, parentenv, handler)
 5: tryCatchOne(expr, names, parentenv, handlers[[1L]])        watcher$push(cnd)    }    if (on_message$silence) {

eval(call)
20: with_handlers({    for (expr in tle$exprs) {        ev <- withVisible(eval(expr, envir))        watcher$capture_plot_and_output()25:         invokeRestart("muffleMessage")        watcher$print_value(ev$value, ev$visible, envir) 8:  5:  6:     }withOneRestart(withRestartList(expr, restarts[-nr]), restarts[[nr]])    paste0("\nQuitting from ", loc, if (!is.null(error)) try(lapply(X = S, FUN = FUN, ...), silent = TRUE)
26: withRestartList(expr, restarts)
27: withRestarts(with_handlers({    for (expr in tle$exprs) {        ev <- withVisible(eval(expr, envir))    }}, warning = function (cnd)         paste0("\n", rule(), error, "\n", rule()))tryCatchOne(expr, names, parentenv, handlers[[1L]])}, if (labels[i] != "") sprintf(" [%s]", labels[i]), get_loc)        if (progress && is.function(pb$interrupt))             pb$interrupt()        if (is_R_CMD_build() || is_R_CMD_check())             error <<- format(e)    }), list(rlang_trace_top_env = knit_global())), function(loc) {        watcher$capture_plot_and_output()tryCatchList(expr, classes, parentenv, handlers)

39: process_file(text, output)
40: knitr::knit(knit_input, knit_output, envir = envir, quiet = quiet)
    setwd(wd)
41: rmarkdown::render(file, encoding = encoding, quiet = quiet, envir = globalenv(),     output_dir = getwd(), ...)
 7: tryCatch(expr, error = function(e) {    write_utf8(res, output %n% stdout()) 9:     call <- conditionCall(e){    if (getOption("warn") >= 2 || getOption("warn") < 0) {    if (!is.null(call)) { 6:     TRUE
tryCatchList(expr, classes, parentenv, handlers)        return()    }42:     paste0("\nQuitting from ", loc, if (!is.null(error))         watcher$print_value(ev$value, ev$visible, envir)    }    TRUE        paste0("\n", rule(), error, "\n", rule()))    watcher$capture_plot_and_output()
vweave_rmarkdown(...)}, handlers)
21: doWithOneRestart(return(expr), restart)
22: withOneRestart(expr, restarts[[1L]])
43:         if (identical(call[[1L]], quote(doTryCatch))) }, handlers), eval_continue = function() TRUE, eval_stop = function() FALSE)}, if (labels[i] != "") sprintf(" [%s]", labels[i]), get_loc) 7: tryCatch(expr, error = function(e) {
    if (on_warning$capture) {28: evaluate::evaluate(...)
29: evaluate(code, envir = env, new_device = FALSE, keep_warning = if (is.numeric(options$warning)) TRUE else options$warning, engine$weave(file, quiet = quiet, encoding = enc)            call <- sys.call(-4L)        dcall <- deparse(call, nlines = 1L)        prefix <- paste("Error in", dcall, ": ")        cnd <- sanitize_call(cnd)
        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  ")39:     }    call <- conditionCall(e)    else prefix <- "Error : "sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE))
    msg <- paste0(prefix, conditionMessage(e), "\n")    if (!is.null(call)) {    .Internal(seterrmessage(msg[1L]))23: process_file(text, output)    keep_message = if (is.numeric(options$message)) TRUE else options$message, 44: 
doTryCatch(return(expr), name, parentenv, handler)        if (identical(call[[1L]], quote(doTryCatch))) withRestartList(expr, restarts[-nr])
    stop_on_error = if (is.numeric(options$error)) options$error else {        watcher$push(cnd)    }    if (on_warning$silence) {        if (options$error && options$include)             0L        else 2L    }, output_handler = knit_handlers(options$render, options))
            call <- sys.call(-4L)10:         invokeRestart("muffleWarning")    }}, error = function (cnd) 30: 40:     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")in_dir(input_dir(), expr)        cat(msg, file = outFile)FUN(X[[i]], ...)

31: in_input_dir(evaluate(code, envir = env, new_device = FALSE, 11: knitr::knit(knit_input, knit_output, envir = envir, quiet = quiet)
41: rmarkdown::render(file, encoding = encoding, quiet = quiet, envir = globalenv(),     output_dir = getwd(), ...)

42: lapply(seq_len(cores), inner.do)
12: 24: doWithOneRestart(return(expr), restart)    keep_warning = if (is.numeric(options$warning)) TRUE else options$warning,     keep_message = if (is.numeric(options$message)) TRUE else options$message,         if (is.na(w))         .Internal(printDeferredWarnings())parallel::mclapply(inits, .run_screen, mc.cores = n_cores)    }    invisible(structure(msg, class = "try-error", condition = e))})
 8: try(lapply(X = S, FUN = FUN, ...), silent = TRUE)    stop_on_error = if (is.numeric(options$error)) options$error else {{            w <- 14L + nchar(dcall, type = "b") + nchar(sm[1L], 
                type = "b")
 9: sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE))45:         if (options$error && options$include) 
10:         if (w > LONG) 
13:             prefix <- paste0(prefix, "\n  ")    watcher$capture_plot_and_output()    }vweave_rmarkdown(...)
43: build_mmm(net_GR, k = 2, covariates = c("Group"))engine$weave(file, quiet = quiet, encoding = enc)            0L
        else 2L    cnd <- sanitize_call(cnd)tryCatchOne(expr, names, parentenv, handlers[[1L]])    }, output_handler = knit_handlers(options$render, options)))
    else prefix <- "Error : "    msg <- paste0(prefix, conditionMessage(e), "\n")44:     .Internal(seterrmessage(msg[1L]))    if (!silent && isTRUE(getOption("show.error.messages"))) {        cat(msg, file = outFile)        .Internal(printDeferredWarnings())    }    watcher$push(cnd)doTryCatch(return(expr), name, parentenv, handler)46: 
tryCatchList(expr, classes, parentenv, handlers)    invisible(structure(msg, class = "try-error", condition = e))FUN(X[[i]], ...)
11: lapply(seq_len(cores), inner.do)

    switch(on_error, continue = invokeRestart("eval_continue"),         stop = invokeRestart("eval_stop"), error = NULL)})
47: 
tryCatch({    engine$weave(file, quiet = quiet, encoding = enc)    setwd(startdir)
45: 14: })
eval(expr, envir)18: eval(call)
19: eval(call)
    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/RtmpkBrGSE/file106f03e6428fd.rds")
An irrecoverable exception occurred. R is aborting now ...
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) {tryCatchOne(expr, names, parentenv, handlers[[1L]])
    if (getOption("warn") >= 2 || getOption("warn") < 0) {
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: 12:         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) parallel::mclapply(inits, .run_screen, mc.cores = n_cores){    watcher$capture_plot_and_output()
13: build_mmm(net_GR, k = 2, covariates = c("Group"))
14: eval(expr, envir)
15: eval(expr, envir)
16: withVisible(eval(expr, envir))
    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)
17: withCallingHandlers(code, error = function (e) rlang::entrace(e), message = function (cnd) {    watcher$capture_plot_and_output()    if (on_message$capture) {        watcher$push(cnd)    }25: 
46:  8: 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/RtmpkBrGSE/file106f03e6428fd.rds")
An irrecoverable exception occurred. R is aborting now ...
21: 32: withOneRestart(expr, restarts[[1L]])eng_r(options)try(lapply(X = S, FUN = FUN, ...), silent = TRUE)doWithOneRestart(return(expr), restart)
33: 

22: withOneRestart(expr, restarts[[1L]])
23: withRestartList(expr, restarts[-nr])
24: withOneRestart(withRestartList(expr, restarts[-nr]), restarts[[nr]])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    if (on_message$silence) {}, handlers), eval_continue = function() TRUE, eval_stop = function() FALSE)block_exec(params)
34: call_block(x)
35: process_group(group)

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)
 9:         invokeRestart("muffleMessage")
    }28: 
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))
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 2L30: 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:     }, output_handler = knit_handlers(options$render, options)))}, warning = function (cnd) {    if (getOption("warn") >= 2 || getOption("warn") < 0) {        return()    }    watcher$capture_plot_and_output()
32: eng_r(options)
33: block_exec(params)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(), ...)    if (on_warning$capture) {        cnd <- sanitize_call(cnd)        watcher$push(cnd)    }    if (on_warning$silence) {        invokeRestart("muffleWarning")    }
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/RtmpkBrGSE/file106f03e6428fd.rds")}, 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))sendMaster(try(lapply(X = S, FUN = FUN, ...), silent = TRUE))
10: 36: 
23: 
withRestartList(expr, restarts[-nr])
24: doWithOneRestart(return(expr), restart)
25: withOneRestart(withRestartList(expr, restarts[-nr]), restarts[[nr]])
        watcher$capture_plot_and_output()withCallingHandlers(if (tangle) process_tangle(group) else process_group(group), An irrecoverable exception occurred. R is aborting now ...
        watcher$print_value(ev$value, ev$visible, envir)    }    TRUE}, handlers)
21: doWithOneRestart(return(expr), restart)FUN(X[[i]], ...)
11: lapply(seq_len(cores), inner.do)
12: 34: 
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))
26: 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)) withRestartList(expr, restarts)    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: 
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,             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)30:     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: 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()process_file(text, output)parallel::mclapply(inits, .run_screen, mc.cores = n_cores)

    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)
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]])
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)    }), 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(), ...)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)
        if (is_R_CMD_build() || is_R_CMD_check()) 
            error <<- format(e)13:     })
46: 35: tryCatchList(expr, classes, parentenv, handlers)process_group(group)42: vweave_rmarkdown(...)
43: build_mmm(net_GR, k = 2, covariates = c("Group"))
47: tryCatch({    engine$weave(file, quiet = quiet, encoding = enc)    setwd(startdir)engine$weave(file, quiet = quiet, encoding = enc)
14: eval(expr, envir)
    output <- find_vignette_product(name, by = "weave", engine = engine)
37: 44: doTryCatch(return(expr), name, parentenv, handler)
45: 
15: eval(expr, envir)
16: tryCatchOne(expr, names, parentenv, handlers[[1L]])    if (!have.makefile && vignette_is_tex(output)) {36: 
46: withVisible(eval(expr, envir))tryCatchList(expr, classes, parentenv, handlers)
        texi2pdf(file = output, clean = FALSE, quiet = quiet)
17: withCallingHandlers(code, error = function (e) rlang::entrace(e), message = function (cnd) {    watcher$capture_plot_and_output()        output <- find_vignette_product(name, by = "texi2pdf", 47: with_options(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group),     error = function(e) {tryCatch({    if (on_message$capture) {    engine$weave(file, quiet = quiet, encoding = enc)withCallingHandlers(if (tangle) process_tangle(group) else process_group(group),     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)        if (progress && is.function(pb$interrupt))     error = function(e) {    }            engine = engine)            pb$interrupt()        if (is_R_CMD_build() || is_R_CMD_check())     }            error <<- format(e)}, error = function(e) {    }), list(rlang_trace_top_env = knit_global()))    OK <<- FALSE
        if (progress && is.function(pb$interrupt))             pb$interrupt()    message(gettextf("Error: processing vignette '%s' failed with diagnostics:\n%s",         file, conditionMessage(e)))}, error = function(e) {38:         watcher$push(cnd)        if (is_R_CMD_build() || is_R_CMD_check()) })
48:     }xfun:::handle_error(with_options(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group),     error = function(e) {        if (progress && is.function(pb$interrupt))             error <<- format(e)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/RtmpkBrGSE/file106f03e6428fd.rds")
            pb$interrupt()    })
37: with_options(withCallingHandlers(if (tangle) process_tangle(group) else process_group(group),     error = function(e) {        if (progress && is.function(pb$interrupt))         if (is_R_CMD_build() || is_R_CMD_check())     if (on_message$silence) {    OK <<- FALSE            pb$interrupt()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()))
        invokeRestart("muffleMessage")    }}, warning = function (cnd) {    message(gettextf("Error: processing vignette '%s' failed with diagnostics:\n%s", 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))         file, conditionMessage(e)))            error <<- format(e)    if (getOption("warn") >= 2 || getOption("warn") < 0) {        return()    }    watcher$capture_plot_and_output()})    }), list(rlang_trace_top_env = knit_global())), function(loc) {
            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)
    if (on_warning$capture) {    setwd(wd)        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)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/RtmpkBrGSE/file106f03e6428fd.rds")40:     write_utf8(res, output %n% stdout())    watcher$push(cnd)
An irrecoverable exception occurred. R is aborting now ...
    paste0("\nQuitting from ", loc, if (!is.null(error))         paste0("\n", rule(), error, "\n", rule()))knitr::knit(knit_input, knit_output, envir = envir, quiet = quiet)
41: rmarkdown::render(file, encoding = encoding, quiet = quiet, envir = globalenv(),     output_dir = getwd(), ...)
    switch(on_error, continue = invokeRestart("eval_continue"),         stop = invokeRestart("eval_stop"), error = NULL)})
18: eval(call)
19: eval(call)
}, if (labels[i] != "") sprintf(" [%s]", labels[i]), get_loc)20: with_handlers({    for (expr in tle$exprs) {        ev <- withVisible(eval(expr, envir))
39: process_file(text, output)        watcher$capture_plot_and_output()        watcher$print_value(ev$value, ev$visible, envir)    }    TRUE}, handlers)
42: vweave_rmarkdown(...)
43: 
40: knitr::knit(knit_input, knit_output, envir = envir, quiet = quiet)
41: rmarkdown::render(file, encoding = encoding, quiet = quiet, envir = globalenv(), 21: engine$weave(file, quiet = quiet, encoding = enc)
doWithOneRestart(return(expr), restart)
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)    output_dir = getwd(), ...)
42: vweave_rmarkdown(...)
    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", 22: withOneRestart(expr, restarts[[1L]])
23: 43: engine$weave(file, quiet = quiet, encoding = enc)
44:     TRUE, FALSE, "transition-networks", "UTF-8", "/Volumes/Temp/tmp/RtmpkBrGSE/file106f03e6428fd.rds")withRestartList(expr, restarts[-nr])

An irrecoverable exception occurred. R is aborting now ...
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)doTryCatch(return(expr), name, parentenv, handler)
    }    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, 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/RtmpkBrGSE/file106f03e6428fd.rds")
An irrecoverable exception occurred. R is aborting now ...
    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/RtmpkBrGSE/file106f03e6428fd.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