anchor.diff:  
     void _dispatch(List<List> calls) async {
       final n = calls.length;
  -    final results = List<Future>(n);
  -    for (var i = 0; i < n; i++) {
  -      results[i] = _process(calls[i]);
  -    }
  -    try {
  -      await client.invoke('=', [await Future.wait(results)]);
  -    } catch (e) {
  -      if (e is! TimeoutException) {
  -        if (retryInterval > Duration.zero) {
  -          await Future.delayed(retryInterval);
  -        }
  -        if (onError != null) {
  -          onError(e);
  +    final results = List<Future<List<dynamic>>>.generate(
  +        n, (i) => _process(calls[i]),
  +        growable: false);
  +    while (true) {
  +      try {
  +        await client.invoke('=', [await Future.wait(results)]);
  +        return;
  +      } catch (e) {
  +        if (e is! TimeoutException) {
  +          if (retryInterval > Duration.zero) {
  +            await Future.delayed(retryInterval);
  +          }
  +          if (onError != null) {
  +            onError(e);
  +          }
           }
         }
       }
     }
   
     Future<void> listen() async {
  +    if (!_closed) return;
       _closed = false;
  -    do {
  +    while (!_closed) {
         try {
           final calls = await client.invoke<List<List>>('!');
           if (calls == null) return;
  
positive.code:   final Map<String, List<List>> _calls = {};
    final Map<String, Map<int, Completer>> _results = {};
    final Map<String, Completer<List<List>>> _responders = {};
    final Map<String, bool> _onlines = {};
    final Service service;
    var heartbeat = const Duration(minutes: 2);
    var timeout = const Duration(seconds: 30);
    Caller(this.service) {
      Method.registerContextType('CallerContext');
      service
  
negative.code:     _onlines.remove(id);
    }
  
    void doHeartbeat(String id, Completer<bool> online) {
      if (heartbeat > Duration.zero) {
        var timeoutTimer = Timer(heartbeat, () {
          if (!online.isCompleted) {
            online.complete(false);
          }
        });
        online.future.then((value) {
          timeoutTimer.cancel();
          if (!value) {
            _onlines.remove(id);
          }
        });
      }
    }
  
    Future<List<List>> _begin(ServiceContext context) async {
      final id = _stop(context);
      var online = _onlines.remove(id);
      if (online != null) {
        online.complete(true);
      }
      online = Completer<bool>();
      _onlines[id] =online;
      try {
        final responder = Completer<List<List>>();
        if (!_send(id, responder)) {
          _responders[id] = responder;
          if (idleTimeout > Duration.zero) {
            var timeoutTimer = Timer(idleTimeout, () {
              if (_responders[id] == responder) {
                _responders.remove(id);
                responder.complete([]);
              }
            });
            await responder.future.then((value) {
              timeoutTimer.cancel();
            });
          }
        }
        return await responder.future;
      } finally {
        doHeartbeat(id, online);
      }
    }
  
    void _end(List<List> results, ServiceContext context) {
  