anchor.diff:    void addOutput(Asset output) {
       _call(_port, {
         'type': 'addOutput',
  -      'output': _serializeAsset(output)
  +      'output': serializeAsset(output)
       });
     }
   }
  
positive.code: 
    return {
      'port': receivePort.sendPort,
      'primaryInput': _serializeAsset(transform.primaryInput)
    };
  }
  
  /// Converts a serializable map into an [Asset].
  Asset _deserializeAsset(Map asset) {
    return new Asset.fromStream(
        _deserializeId(asset['id']),
        _deserializeStream(asset['stream']));
  }
  
  /// A transformer that deserializes the values in a stream sent by
  /// [_serializeStream].
  StreamSubscription _deserializeTransformer(Stream input, bool cancelOnError) {
    var subscription;
    var transformed = input.transform(new StreamTransformer.fromHandlers(
        handleData: (data, sink) {
      if (data['type'] == 'data') {
        sink.add(data['data']);
      } else if (data['type'] == 'error') {
        sink.addError(CrossIsolateException.deserialize(data['error']));
      } else {
        assert(data['type'] == 'done');
        sink.close();
        subscription.cancel();
      }
    }));
    subscription = transformed.listen(null, cancelOnError: cancelOnError);
    return subscription;
  }
  
  /// Convert a [SendPort] whose opposite is waiting to send us a stream into a
  /// [Stream].
  ///
  /// No stream data will actually be sent across the isolate boundary until
  /// someone subscribes to the returned stream.
  Stream _deserializeStream(SendPort sendPort) {
    return callbackStream(() {
      var receivePort = new ReceivePort();
      sendPort.send(receivePort.sendPort);
      return receivePort.transform(
          const StreamTransformer(_deserializeTransformer));
    });
  }
  
  /// Converts a serializable map into an [AssetId].
  
negative.code:   assert(location['type'] == 'fixed');
    return new FixedLocation(location['offset'], location['sourceUrl'],
        location['line'], location['column']);
  }
  
  /// Converts [id] into a serializable map.
  