machine.processEvent(OutgoingMessage(command))

Recovering from a crash: java.lang.IllegalStateException: Transitioning to state ExpectingResponse(outgoingMessage=OutgoingMessage(data=PingCard(callback=CancellableContinuation(DispatchedContinuation[Dispatchers.IO, Continuation at ...{Active}..., cardType=6)), queue=[], retryCount=0) from another state machine is not possible

state("ble") {
    addInitialState(CommandStates.Waiting) {
        transition<IncomingBleMessage> {
            onTriggered {
                val value = it.event.data
                val parsed = parseSingle(value)
                Timber.tag("StateMachine").w { "Got errant message: ${parsed.commandByte} with data: ${value.dump()}" }
                }
            }
        }
        transitionOn<OutgoingMessage> {
            targetState = {
                CommandStates.ExpectingResponse(event, listOf())
            }
        }
    }

    dataState<CommandStates.ExpectingResponse> {
        val supervisor = SupervisorJob()
        onEntry {
            bleManager.writeToReader(data.outgoingMessage.data)
        }

        val state = this
        transitionConditionally<IncomingBleMessage> {
            type = TransitionType.EXTERNAL
            direction = {
                val value = event.data
                val parsed = parseSingle(value)
                when (val commandByte = (parsed.cmd - 1).toByte()) {
                    state.data.outgoingMessage.data.commandByte -> {
                        if (parsed.isSuccessful()) {
                            state.data.outgoingMessage.data.callback.resume(parsed) {
                                Timber.tag("StateMachine").w { "Resumed too late! $commandByte with data: ${value.dump()}" }
                            }
                            popQueue(state)
                        } else {
                            targetState(CommandStates.ExpectingResponse(state.data.outgoingMessage, state.data.queue, state.data.retryCount + 1))
                        }

                    }

                    else -> {
                        Timber.w { "Got errant message: $commandByte with data: ${value.dump()}" }
                        noTransition()
                    }
                }
            }
        }

        transitionOn<OutgoingMessage> {
            type = TransitionType.EXTERNAL
            targetState = {
                CommandStates.ExpectingResponse(state.data.outgoingMessage, state.data.queue + event)
            }
        }
    }
}


private suspend fun <T : Event> EventAndArgument<T>.popQueue(
    state: DataState<CommandStates.ExpectingResponse>
) = if (state.data.queue.isEmpty()) {
    targetState(CommandStates.Waiting)
} else {
    targetState(
        CommandStates.ExpectingResponse(
            state.data.queue[0],
            state.data.queue.drop(1)
        )
    )
}

data class OutgoingMessage(override val data: Command): DataEvent<Command>
data class Command(val callback: CancellableContinuation<ParsingState.ParsingSuccessful>)

sealed class CommandStates: DefaultState() {
    data object Waiting : CommandStates()
    data class ExpectingResponse(
        val outgoingMessage: OutgoingMessage,
        val queue: List<OutgoingMessage>,
        val retryCount: Int = 0,
    ): CommandStates()
}