 		let (eSig, eSink) = Signal<NSError>.pipe()
 		errorsObserver = eSink
 		errors = eSig
-
-		enabledIf.producer
-			|> combineLatestWith(executing.producer)
-			|> map(shouldBeEnabled)
-			// FIXME: Workaround for <~ being disabled on SignalProducers.
-			|> startWithSignal { signal, disposable in
-				let bindDisposable = self._enabled <~ signal
-				disposable.addDisposable(bindDisposable)
-			}
 	}
 
 	/// Initializes an action that will be enabled by default, and create a

	/// SignalProducer for each input.
	public init<P: PropertyType where P.Value == Bool>(enabledIf: P, _ execute: Input -> SignalProducer<Output>) {
		executeClosure = execute

		let (vSig, vSink) = Signal<Output>.pipe()
		valuesObserver = vSink

	/// `RACError.ActionNotEnabled`, and nothing will be sent upon `values` or
	/// `errors` for that particular signal.
	public func apply(input: Input) -> SignalProducer<Output> {
		return SignalProducer { observer, disposable in
			var startedExecuting = false

			dispatch_sync(self.executingQueue) {
				if self.dynamicType.shouldBeEnabled(userEnabled: self.userEnabled.value, executing: self._executing.value) {
					self._executing.value = true
					startedExecuting = true
				}
			}

			if !startedExecuting {
				sendError(observer, RACError.ActionNotEnabled.error)
				return
			}

			self.executeClosure(input).startWithSignal { signal, signalDisposable in
				disposable.addDisposable(signalDisposable)
				signal.observe(observer)

				signal.observe(next: { value in
					sendNext(self.valuesObserver, value)
				}, error: { error in
					sendNext(self.errorsObserver, error)
				})
			}

			disposable.addDisposable {
				self._executing.value = false
			}
		}
	}
}
