         if let service = service {
             self.add(service: service.baseService)
             self.dispatch(.added(tag: anyTag, service: service))
-            if let serviceObserver = self.serviceObservers[anyTag]?.observer as? AnyObserver<Service> {
-                serviceObserver.onNext(service.baseService as! Service)
-                serviceObserver.onCompleted()
-                self.serviceObservers[anyTag] = nil
-            }
+            self.variable(for: anyTag)?.value = service
         }
     }
 

    }
}

private struct ServiceObserverWrapper {

    let observer: Any

    public init<Service: ContextService>(observer: AnyObserver<Service>) {
        self.observer = observer
    }
}

private struct ServiceObservableWrapper {

    let observable: Any

    public init<Service: ContextService>(observable: Observable<Service>) {
        self.observable = observable
    }
}

private struct ServiceDispatchCallback {

    private let _callback: (AnyContextService) -> Void

    init<Service: ContextService>(callback: @escaping (Service, Service.Component) -> Void) {
        self._callback = { anyService in
            guard let service = anyService.baseService as? Service else { return }
            callback(service, service.component)
        }
    }

    func invoke(with service: AnyContextService) {
        self._callback(service)
    }
}


        return self.service(for: tag)?.component
    }

    private func variableAndObservable<Tag: ContextServiceTag, Service>(for tag: Tag) -> (Variable<Service?>, Observable<Service?>) where Service == Tag.Service {
        let anyTag = tag as? AnyContextServiceTag ?? AnyContextServiceTag(tag: tag)
        let variable: Variable<Service?>
        let observable: Observable<Service?>
        if let wrapper = self.serviceVariableWrappers[anyTag] {
            variable = wrapper.variable as! Variable<Service?>
            observable = wrapper.observable as! Observable<Service?>
        } else {
            variable = Variable<Service?>(nil)
            observable = variable.asObservable().do(onDispose: { [weak self] in
                self?.serviceVariableWrappers[anyTag] = nil
            })
            let wrapper = ServiceVariableWrapper(variable: variable, observable: observable)
            self.serviceVariableWrappers[anyTag] = wrapper
        }
        return (variable, observable)
    }

    private func variable<Tag: ContextServiceTag, Service>(for tag: Tag) -> Variable<Service?>? where Service == Tag.Service {
        let anyTag = tag as? AnyContextServiceTag ?? AnyContextServiceTag(tag: tag)
        return self.serviceVariableWrappers[anyTag]?.variable as? Variable<Service?>
    }

    public func observable<Tag: ContextServiceTag, Service>(for tag: Tag) -> Observable<Service?> where Service == Tag.Service {
        return self.variableAndObservable(for: tag).1
    }

    public func whenAvailable<Tag: ContextServiceTag, Service>(for tag: Tag) -> Observable<Service> where Service == Tag.Service {
        return self.observable(for: tag).unwrap()
    }


    fileprivate func dispatch(_ serviceEvent: ServiceEvent) {
        // TODO:
