Fix a deadlock.

lib/src/graph/transform_node.dart

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library barback.graph.transform_node;
 
 import 'dart:async';
 
 import '../asset/asset.dart';
 import '../asset/asset_id.dart';
@@ skipping 316 matching lines @@
         // node in the graph. It will be re-created by its
         // [TransformerClassifier] if a new input with [key] is added.
         remove();
         return;
       }
 
       // Any change to the number of primary inputs requires that we re-run the
       // transformation.
       _restartRun();
     } else if (input.state.isAvailable) {
+      if (_state == _State.DECLARED) {
+        // If we're passing through this input and its contents don't matter,
+        // update the pass-through controller.
+        var controller = _passThroughControllers[input.id];
+        if (controller != null) controller.setAvailable(input.asset);
+      }
+
       if (_state == _State.DECLARED && _canRunDeclaringEagerly) {
         // If [this] is fully declared but hasn't started applying, this input
         // becoming available may mean that all inputs are available, in which
         // case we can run apply eagerly.
         _apply();
         return;
       }
 
       // If we're not actively passing concrete assets to the transformer, the
       // distinction between a dirty asset and an available one isn't relevant.
       if (_state != _State.APPLYING) return;
 
       if (_applyController.isDone) {
         // If we get a new asset after we've closed the asset stream, we need to
         // re-run declare and then apply.
         _restartRun();
       } else {
         // If the new asset comes before the asset stream is done, we can just
         // pass it to the stream.
         _applyController.addInput(input.asset);
         _maybeFinishApplyController();
       }
     } else {
       if (_forced) input.force();
+
+      var controller = _passThroughControllers[input.id];
+      if (controller != null) controller.setDirty();
+
       if (_state == _State.APPLYING && !_applyController.addedId(input.id) &&
           (_forced || !input.isLazy)) {
         // If the input hasn't yet been added to the transform's input stream,
         // there's no need to consider the transformation dirty. However, if the
         // input is lazy and we're running eagerly, we need to restart the
         // transformation.
         return;
       }
       _dirty();
     }
@@ skipping 495 matching lines @@
   /// declaring and [APPLYING] otherwise. If a primary input is added or
   /// removed, this will transition to [DECLARING].
   static const APPLIED = const _State._("applied");
 
   final String name;
 
   const _State._(this.name);
 
   String toString() => name;
 }