public static Message DeserialiseMsg(RemoteMessageDTO msg, ProcessId actorId)
        {
            var sender = String.IsNullOrEmpty(msg.Sender) ? ProcessId.NoSender : new ProcessId(msg.Sender);
            var replyTo = String.IsNullOrEmpty(msg.ReplyTo) ? ProcessId.NoSender : new ProcessId(msg.ReplyTo);

            switch ((Message.TagSpec)msg.Tag)
            {
                case Message.TagSpec.UserReply:
                    var content = DeserialiseMsgContent(msg);
                    return new ActorResponse(content, content.GetType().AssemblyQualifiedName, actorId, sender, msg.RequestId, msg.Exception == "RESPERR");

                case Message.TagSpec.UserAsk:           return new ActorRequest(DeserialiseMsgContent(msg), actorId, replyTo, msg.RequestId);
                case Message.TagSpec.User:              return new UserMessage(DeserialiseMsgContent(msg), sender, replyTo);
                case Message.TagSpec.UserTerminated:    return (TerminatedMessage)DeserialiseMsgContent(msg);

                case Message.TagSpec.GetChildren:       return UserControlMessage.GetChildren;
                case Message.TagSpec.StartupProcess:    return SystemMessage.StartupProcess;
                case Message.TagSpec.ShutdownProcess:   return (ShutdownProcessMessage)DeserialiseMsgContent(msg);

                case Message.TagSpec.Restart:           return SystemMessage.Restart;
                case Message.TagSpec.Pause:             return SystemMessage.Pause;
                case Message.TagSpec.Unpause:           return SystemMessage.Unpause;

                case Message.TagSpec.DispatchWatch:    return (SystemDispatchWatchMessage)DeserialiseMsgContent(msg);
                case Message.TagSpec.DispatchUnWatch:  return (SystemDispatchUnWatchMessage)DeserialiseMsgContent(msg);
                case Message.TagSpec.Watch:            return (SystemAddWatcherMessage)DeserialiseMsgContent(msg);
                case Message.TagSpec.UnWatch:          return (SystemRemoveWatcherMessage)DeserialiseMsgContent(msg);
            }

            throw new Exception($"Unknown Message Tag: {msg.Tag}");
        }

        public static ProcessId Inbox(ProcessId hub, RelayMsg msg)
        {
            try
            {
                switch (msg.Tag)
                {
                    case RelayMsg.MsgTag.Connected:
                        SpawnConnection(msg, hub);
                        break;

                    case RelayMsg.MsgTag.Disconnected:
                        kill(Self[msg.ConnectionId]);
                        break;

                    case RelayMsg.MsgTag.Inbound:
                    case RelayMsg.MsgTag.Subscribe:
                    case RelayMsg.MsgTag.Unsubscribe:
                        fwd(SpawnConnection(msg, hub), msg);
                        break;
                }
            }
            catch (Exception e)
            {
                tell(Errors, e);
            }
            return hub;
        }

        StrategyContext(
            StrategyState global,
            Exception exception,
            object message,
            ProcessId sender,
            ProcessId failedProcess,
            ProcessId parentProcess,
            IEnumerable<ProcessId> siblings,
            IEnumerable<ProcessId> affects,
            Time pause,
            Option<Directive> directive,
            Option<MessageDirective> messageDirective
            )
        {
            bool isStop = directive == LanguageExt.Directive.Stop;

            Global = isStop ? StrategyState.Empty : global;
            Exception = exception;
            Message = message;
            Sender = sender;
            Self = failedProcess;
            ParentProcess = parentProcess;
            Siblings = siblings ?? Siblings;
            Affects = affects ?? Affects;
            Pause = isStop ? 0 * s : pause;
            Directive = directive;
            MessageDirective = messageDirective;
        }

 public ActorRequest(object message, ProcessId to, ProcessId replyTo, long requestId)
 {
     Message = message;
     To = to;
     ReplyTo = replyTo;
     RequestId = requestId;
 }

        /// <summary>
        /// Creates a new State computation that is primed with the data of a particular
        /// failure event.  
        /// </summary>
        /// <param name="strategy">Strategy as a State computation</param>
        /// <param name="pid">Process ID that failed</param>
        /// <param name="sender">Process that sent the message that cause the failure</param>
        /// <param name="parent">Supervisor of the failed Process</param>
        /// <param name="siblings">The siblings of the failed Process</param>
        /// <param name="ex">Exception</param>
        /// <param name="msg">Message that caused the failure</param>
        /// <returns>State computation that can be invoked by passing it
        /// an object of StrategyState.  This will result in a StateResult that contains
        /// the mutated StrategyState and a StrategyDecision.  The StrategyDecision 
        /// contains all the information needed to decide the fate of a Process (and
        /// related processes)</returns>
        public static State<StrategyState, StrategyDecision> Failure(
            this State<StrategyContext, Unit> strategy,
            ProcessId pid,
            ProcessId sender,
            ProcessId parent,
            IEnumerable<ProcessId> siblings,
            Exception ex,
            object msg
            )
        {
            return stateInst =>
            {
                var now = DateTime.UtcNow;

                var state = strategy(StrategyContext.Empty.With(
                    Global: stateInst.With(Failures: stateInst.Failures + 1),
                    FailedProcess: pid,
                    ParentProcess: parent,
                    Sender: sender,
                    Siblings: siblings,
                    Exception: ex,
                    Message: msg)).State;

                var decision = new StrategyDecision(
                    state.Directive.IfNone(Directive.Restart),
                    state.MessageDirective.IfNone(MessageDirective.ForwardToDeadLetters),
                    state.Affects,
                    state.Pause
                );

                return StateResult.Return(state.Global.With(LastFailure: now), decision);
            };
        }

 public AskActorReq(object msg, Subject<object> subject, ProcessId to, ProcessId replyTo)
 {
     Message = msg;
     Subject = subject;
     To = to;
     ReplyTo = replyTo;
 }

 public SystemChildFaultedMessage(ProcessId child, ProcessId sender, Exception exception, object message)
 {
     Child = child;
     Sender = sender;
     Exception = exception;
     Message = message;
 }

 public ActorResponse(ProcessId replyTo, object message, ProcessId replyFrom, long requestId)
 {
     Message = message;
     ReplyTo = replyTo;
     ReplyFrom = replyFrom;
     RequestId = requestId;
 }

 void SpawnResolver()
 {
     resolver = spawn<Map<ProcessId, BallState>, Tuple<ProcessId, BallState>>(
         "resolver",
         () => Map<ProcessId, BallState>(),
         Resolver.Inbox
     );
 }

 private DeadLetter(ProcessId sender, ProcessId recipient, Exception ex, string reason, object message)
 {
     Sender = sender;
     Recipient = recipient;
     Exception = Optional(ex);
     Reason = Optional(reason);
     Message = Optional(message);
 }

 internal static RemoteMessageDTO Create(object message, ProcessId to, ProcessId sender, Message.Type type, Message.TagSpec tag, Option<SessionId> sessionId) =>
     map(message as ActorRequest, req =>
         req == null
             ? map(message as ActorResponse, res =>
                 res == null
                     ? CreateMessage(message, to, sender, type, tag, sessionId)
                     : CreateResponse(res, to, sender, sessionId))
             : CreateRequest(req, to, sender, sessionId));

 /// <summary>
 /// Shutdown the process log
 /// </summary>
 public static Unit shutdown()
 {
     if (processId.IsValid)
     {
         kill(processId);
         processId = ProcessId.None;
     }
     return unit;
 }

 public ActorResponse(object message, string responseMessageType, ProcessId replyTo, ProcessId replyFrom, long requestId, bool isFaulted = false)
 {
     Message = message;
     ResponseMessageType = responseMessageType;
     ReplyTo = replyTo;
     ReplyFrom = replyFrom;
     RequestId = requestId;
     IsFaulted = isFaulted;
 }

        public static ProcessId ConnectionInbox(ProcessId hub, RelayMsg rmsg)
        {
            switch (rmsg.Tag)
            {
                case RelayMsg.MsgTag.Inbound:
                    var inmsg = rmsg as InboundRelayMsg;
                    if (rmsg.IsAsk)
                    {
                        // Ask not supported
                        tell(Errors, "'ask' not supported from JS to server.");
                    }
                    else
                    {
                        tell(rmsg.To, inmsg.Message, rmsg.Sender.IsValid ? Self.Append(rmsg.Sender) : ProcessId.NoSender);
                    }
                    break;

                case RelayMsg.MsgTag.Outbound:
                    fwd(hub, rmsg);
                    break;

                case RelayMsg.MsgTag.Subscribe:
                    var pid          = rmsg.To;
                    var subscriber   = rmsg.Sender;
                    var connectionId = rmsg.ConnectionId;

                    ActorContext.SelfProcess.Actor.AddSubscription(
                        rmsg.To,
                        ActorContext.Observe<object>(pid).Subscribe(x =>
                            tell(hub, 
                                 new OutboundRelayMsg(
                                     connectionId,
                                     new RemoteMessageDTO {
                                        MessageId   = Guid.NewGuid(),
                                        Content     = JsonConvert.SerializeObject(x),
                                        Sender      = pid.Path,
                                        To          = subscriber.Path,
                                        ContentType = x.GetType().AssemblyQualifiedName,
                                        ReplyTo     = pid.Path,
                                        Tag         = (int)Message.TagSpec.User,
                                        Type        = (int)Message.Type.User
                                     },
                                     subscriber,
                                     pid,
                                     false),
                                 pid)));
                    break;

                case RelayMsg.MsgTag.Unsubscribe:
                    ActorContext.SelfProcess.Actor.RemoveSubscription(rmsg.To);
                    break;
            }
            return hub;
        }

 public static Unit RemoveFromStore(ProcessId id)
 {
     lock (storeLock)
     {
         var path = id.Value;
         if (Store.ContainsKey(path))
         {
             Store = Store.Remove(path);
         }
     }
     return unit;
 }

 internal static ProcessId WatchWorkers(ProcessId router, IEnumerable<ProcessId> workers, RouterOption option)
 {
     if ((option & RouterOption.RemoveLocalWorkerWhenTerminated) == RouterOption.RemoveLocalWorkerWhenTerminated)
     {
         workers.Where(w => ActorContext.IsLocal(w)).Iter(w => watch(router, w));
     }
     if ((option & RouterOption.RemoveRemoteWorkerWhenTerminated) == RouterOption.RemoveRemoteWorkerWhenTerminated)
     {
         workers.Where(w => !ActorContext.IsLocal(w)).Iter(w => watch(router, w));
     }
     return router;
 }

 public static Unit AddToStore(ProcessId id, IProcess process)
 {
     lock (storeLock)
     {
         var path = id.Value;
         if (Store.ContainsKey(path))
         {
             Store[path].Dispose();
             Store = Store.Remove(path);
         }
         Store = Store.Add(path, process);
     }
     return unit;
 }

 internal static RemoteMessageDTO CreateRequest(ActorRequest req, ProcessId to, ProcessId sender) =>
     new RemoteMessageDTO()
     {
         Type        = (int)Message.Type.User,
         Tag         = (int)Message.TagSpec.UserAsk,
         Child       = null,
         Exception   = null,
         To          = to.Path,
         RequestId   = req.RequestId,
         MessageId   = Guid.NewGuid(),
         Sender      = sender.ToString(),
         ReplyTo     = req.ReplyTo.ToString(),
         ContentType = req.Message.GetType().AssemblyQualifiedName,
         Content     = JsonConvert.SerializeObject(req.Message, ActorConfig.Default.JsonSerializerSettings)
     };

 public ActorRequestContext(
     ActorItem self,
     ProcessId sender,
     ActorItem parent,
     object currentMsg,
     ActorRequest currentRequest,
     ProcessFlags processFlags
     )
 {
     Self = self;
     Sender = sender;
     Parent = parent;
     CurrentMsg = currentMsg;
     CurrentRequest = currentRequest;
     ProcessFlags = processFlags;
 }

 internal static RemoteMessageDTO CreateMessage(object message, ProcessId to, ProcessId sender, Message.Type type, Message.TagSpec tag) =>
     new RemoteMessageDTO
     {
         Type        = (int)type,
         Tag         = (int)tag,
         To          = to.Path,
         RequestId   = -1,
         MessageId   = Guid.NewGuid(),
         Sender      = sender.ToString(),
         ReplyTo     = sender.ToString(),
         ContentType = message == null
                         ? null
                         : message.GetType().AssemblyQualifiedName,
         Content     = message == null
                         ? null
                         : JsonConvert.SerializeObject(message, ActorSystemConfig.Default.JsonSerializerSettings)
     };