Don't make lazy transformers eager when an asset is requested.

pkg/barback/lib/src/asset_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.asset_node;
 
 import 'dart:async';
 
 import 'asset.dart';
 import 'asset_id.dart';
@@ skipping 40 matching lines @@
   Asset _asset;
 
   /// The callback to be called to notify this asset node's creator that the
   /// concrete asset should be generated.
   ///
   /// This is null for non-lazy asset nodes (see [AssetNodeController.lazy]).
   /// Once this is called, it's set to null and [this] is no longer considered
   /// lazy.
   Function _lazyCallback;
 
-  /// Whether this is lazy and needs [force] to be called before it will be
-  /// marked available.
-  bool get isLazy => _lazyCallback != null;
+  /// Whether this asset's transform is deferred.
+  ///
+  /// See [TransformNode.deferred].
+  bool get deferred => transform != null && transform.deferred;
 
   /// A broadcast stream that emits an event whenever the node changes state.
   ///
   /// This stream is synchronous to ensure that when a source asset is modified
   /// or removed, the appropriate portion of the asset graph is dirtied before
   /// any [Barback.getAssetById] calls emit newly-incorrect values.
   Stream<AssetState> get onStateChange => _stateChangeController.stream;
 
   /// This is synchronous so that a source being updated will always be
   /// propagated through the build graph before anything that depends on it is
@@ skipping 114 matching lines @@
     if (node.state.isAvailable) {
       setAvailable(node.asset);
     } else if (node.state.isRemoved) {
       setRemoved();
     }
   }
 
   /// Marks the node as [AssetState.DIRTY].
   void setDirty() {
     assert(node._state != AssetState.REMOVED);
-    node._state = AssetState.DIRTY;
     node._asset = null;
     node._lazyCallback = null;
+
+    // Don't re-emit a dirty event to avoid cases where we try to dispatch an
+    // event while handling another event (e.g. an output is marked lazy, which
+    // causes it to be forced, which causes it to be marked dirty).
+    if (node._state.isDirty) return;
+    node._state = AssetState.DIRTY;
     node._stateChangeController.add(AssetState.DIRTY);
   }
 
   /// Marks the node as [AssetState.REMOVED].
   ///
   /// Once a node is marked as removed, it can't be marked as any other state.
   /// If a new asset is created with the same id, it will get a new node.
   void setRemoved() {
     assert(node._state != AssetState.REMOVED);
     node._state = AssetState.REMOVED;
@@ skipping 58 matching lines @@
 
   /// Whether this state is [AssetState.DIRTY].
   bool get isDirty => this == AssetState.DIRTY;
 
   final String name;
 
   const AssetState._(this.name);
 
   String toString() => name;
 }