Order of execution of observers in Shiny - r

Question

Goal and Current Approach
I have a module, which can delete its own UI. I also want to be able to call this killing functionality from outside the module, hence I pass an additional reactive to the module's server logic and call the killing routine when this reactive fires.
So far so good. Now I want to implement a function which first kills all instances of my module and then adds new instances of this module and this is where I struggle with the design I have chosen.
Issue
What I would need is that before my input$add5 observer adds any new instances, all old instances are killed. This would be done by setting kill_switch(TRUE), but the problem is that before the observer in my module can react to that, the input$add5 observer continues to add new modules, which reset the kill_switch to FALSE and basically the old instances are never killed.
Basically, in the current design I would like that the observer on kill_switch reacts immediately after I change the flag and only after this is done, my add5 observer continues.
What I need
I think that my design is not optimal, thus any recommendations of how to set up the interface between the main application and the module would be highly appreciated.
Code
library(shiny)
boxer_ui <- function(id) {
ns <- NS(id)
div(
id,
id = ns("killme"),
style = "background-color:steelblue; font-size: xx-large; color: white")
}
boxer <- function(input, output, session, kill_switch) {
ns <- session$ns
observe({
req(kill_switch())
removeUI(paste0("#", ns("killme")))
})
}
ui <- fluidPage(actionButton("new", "new"),
actionButton("killall", "Kill All"),
actionButton("add5", "Kill All & Add 5"),
fluidRow(id = "content"))
server <- function(input, output, session) {
ids <- reactiveVal(0)
kill_switch <- reactiveVal(FALSE)
handler <- reactiveValues()
add_new <- function() {
kill_switch(FALSE)
ids(ids() + 1)
new_id <- paste0("id", ids())
insertUI("#content", "beforeEnd", boxer_ui(new_id))
handler[[new_id]] <- callModule(boxer, new_id, kill_switch)
}
observeEvent(input$new, {
isolate({
add_new()
})})
observeEvent(input$add5, {
isolate({
kill_switch(TRUE)
replicate(5, add_new())
})})
observeEvent(input$killall, kill_switch(TRUE))
}
shinyApp(ui, server)

Answer 1

One solution I could think of is to split remove / add as follows:
server <- function(input, output, session) {
ids <- reactiveVal(0)
kill_switch <- reactiveVal(FALSE)
add5 <- reactiveVal(FALSE)
handler <- reactiveValues()
add_new <- function() {
kill_switch(FALSE)
ids(ids() + 1)
new_id <- paste0("id", ids())
insertUI("#content", "beforeEnd", boxer_ui(new_id))
handler[[new_id]] <- callModule(boxer, new_id, kill_switch)
}
observeEvent(input$new, {
isolate({
add_new()
})})
observeEvent(input$add5, {
isolate({
kill_switch(TRUE)
add5(TRUE)
})})
observe({
req(add5())
isolate({
replicate(5, add_new())
add5(FALSE)
})
})
observeEvent(input$killall, kill_switch(TRUE))
}
This is however based on the assumption that the observer will never be interrupted by any other observer. Is that true? In this case I could also add priority parameters to ensure that the inner observer is fired first.
Can anybody conform that my assumption is right?