 			return error;
 		}
 		
-		private function setBusy(busy:Boolean):void
-		{
-			if (busy)
-			{
-				WeaveAPI.ProgressIndicator.addTask(rootPromise, relevantContext as ILinkableObject);
-			}
-			else
-			{
-				WeaveAPI.ProgressIndicator.removeTask(rootPromise);
-			}
-		}
-		
 		private function callHandlers(newHandlersOnly:Boolean = false):void
 		{
+			// stop if depenencies are busy because we will call handlers when they become unbusy
 			if (dependencies.some(Weave.isBusy))
-			{
-				if (handlers.length)
-					setBusy(true);
 				return;
-			}
-			
-			// if there are no more handlers, remove the task
-			if (handlers.length == 0)
-				setBusy(false);
-			
-			if (Weave.wasDisposed(relevantContext))
-			{
-				setBusy(false);
+			
+			// stop if the promise has not been resolved yet
+			if (result === undefined && error === undefined)
 				return;
-			}
 			
 			for (var i:int = 0; i < handlers.length; i++)
 			{

		protected var relevantContext:Object;
		private var result:* = undefined;
		private var error:* = undefined;
		private var handlers:Array = []; // array of Handler objects
		private var dependencies:Array = [];
		
		/**
		 * @return This WeavePromise
		 */
		public function setResult(result:Object):WeavePromise
		{
			if (WeaveAPI.debugAsyncStack)
				stackTrace_resolved = new Error("WeavePromise resolved");
			
			if (Weave.wasDisposed(relevantContext))
			{
				setBusy(false);
				return this;
			}
			
			this.result = undefined;
			this.error = undefined;

		
		public function then(onFulfilled:Function = null, onRejected:Function = null):WeavePromise
		{
			if (Weave.wasDisposed(relevantContext))
				return this;
			
			if (onFulfilled == null)
				onFulfilled = noop;
			if (onRejected == null)
				onRejected = noop;
			
			var next:WeavePromise = new WeavePromise(this);
			handlers.push(new WeavePromiseHandler(onFulfilled, onRejected, next));
			
			// call new handler(s) if promise has already been resolved
			if (result !== undefined || error !== undefined)
				WeaveAPI.Scheduler.callLater(relevantContext, callHandlers, [true]);
			
			return next;
		}
		
		public function depend(...linkableObjects):WeavePromise
		{
			for each (var dependency:ILinkableObject in linkableObjects)
			{
				if (dependencies.indexOf(dependency) < 0)
					dependencies.push(dependency);
				Weave.getCallbacks(dependency).addGroupedCallback(relevantContext, callHandlers, true);
			}
			return this;
