addMiddleware(node, (call, next) => {
        // only actions for now
        const skip = call.type !== "action"

        // skip this middleware?
        if (skip) {
          return next(call)
        }

        // userland opt-out
        const shouldSend = mstFilter(call)
        if (!shouldSend) {
          return next(call)
        }

        // grab the arguments
        const args = convertUnsafeArguments(call.args)
        const path = getPath(call.context)

        // action related data
        const action = { args: args, name: call.name, path }

        // mst internal data
        const mstPayload = {
          id: call.id,
          parentId: call.parentId,
          rootId: call.rootId,
          type: call.type,
          modelType: getType(node),
          alive: isAlive(node),
          root: isRoot(node),
          protected: isProtected(node),
        }

        // start a timer
        const elapsed = reactotron.startTimer()

        // chain off to the next middleware
        const result = next(call)

        // measure the speed
        const ms = elapsed()

        // add nice display name
        const displayPath = replace(/^\./, "", replace(/\//g, ".", path))
        let name = replace(/^\./, "", `${nodeName ? nodeName : ""}${displayPath}.${call.name}()`)
        name = replace("/", ".", name)
        // fire this off to reactotron
        if (!restoring) {
          reactotron.send("state.action.complete", {
            name,
            action,
            mst: mstPayload,
            ms,
          })
        }

        // return the result of the next middlware
        return result
      })

    // --- Connecting MST to Reactotron ---------------------------------

    /**
     * The entry point for integrating a mobx-state-tree node with Reactotron. Currently
     * one 1 root node is supported.
     *
     * @param node The mobx-state-tree node to track
     * @param nodeName The name to call it if we have more than 1.
     */
    function trackMstNode(node: IStateTreeNode, nodeName: string = "default") {
      // sanity
      if (!node) {
        return { kind: "required" }
      }

      // prevent double tracking
      if (trackedNodes[nodeName]) {
        return { kind: "already-tracking" }
      }

      try {
        // grab the mst model type
        const modelType = getType<any, any>(node)

        // we only want types
        if (modelType.isType) {
          try {
            attachReactotronToMstNode(node)
            // track this
            trackedNodes[nodeName] = { node, modelType }
            return { kind: "ok" }
          } catch (e) {
            return { kind: "tracking-error", message: e.message }
          }
        } else {
          return { kind: "invalid-node" }
        }
      } catch (e) {
        return { kind: "invalid-node" }
      }
    }

export const connectReduxDevtools = function connectReduxDevtools(remoteDevDep: any, model: any) {
    // Connect to the monitor
    const remotedev = remoteDevDep.connectViaExtension({ name: mst.getType(model).name })
    let applyingSnapshot = false

    // Subscribe to change state (if need more than just logging)
    remotedev.subscribe((message: any) => {
        if (message.type === "DISPATCH") {
            handleMonitorActions(remotedev, model, message)
        }
    })

    const initialState = mst.getSnapshot(model)
    remotedev.init(initialState)

    // Send changes to the remote monitor
    mst.onAction(
        model,
        action => {
            if (applyingSnapshot) return
            const copy: any = {}
            copy.type = action.name
            if (action.args) action.args.forEach((value, index) => (copy[index] = value))
            remotedev.send(copy, mst.getSnapshot(model))
        },
        true
    )

    function handleMonitorActions(remotedev: any, model: any, message: any) {
        switch (message.payload.type) {
            case "RESET":
                applySnapshot(model, initialState)
                return remotedev.init(initialState)
            case "COMMIT":
                return remotedev.init(mst.getSnapshot(model))
            case "ROLLBACK":
                return remotedev.init(remoteDevDep.extractState(message))
            case "JUMP_TO_STATE":
            case "JUMP_TO_ACTION":
                applySnapshot(model, remoteDevDep.extractState(message))
                return
            case "IMPORT_STATE":
                const nextLiftedState = message.payload.nextLiftedState
                const computedStates = nextLiftedState.computedStates
                applySnapshot(model, computedStates[computedStates.length - 1].state)
                remotedev.send(null, nextLiftedState)
                return
            default:
        }
    }

    function applySnapshot(model: any, state: any) {
        applyingSnapshot = true
        mst.applySnapshot(model, state)
        applyingSnapshot = false
    }
}

    // --- Connecting MST to Reactotron ---------------------------------

    /**
     * The entry point for integrating a mobx-state-tree node with Reactotron. Currently
     * one 1 root node is supported.
     *
     * @param node The mobx-state-tree node to track
     * @param nodeName The name to call it if we have more than 1.
     */
    function trackMstNode(node: IStateTreeNode, nodeName: string = "default") {
      // sanity
      if (!node) {
        return
      }

      // prevent double tracking
      if (trackedNodes[nodeName]) {
        return
      }

      try {
        // grab the mst model type
        const modelType = getType<any, any>(node)

        // we only want types
        if (modelType.isType) {
          // track this
          trackedNodes[nodeName] = { node, modelType }
          attachReactotronToMstNode(node)
        }
      } catch {}
    }