 	let updater: Updater?
 	var activationValues: Array<T>
 	var preclosed: Error?
-	let isUserUpdated: Bool
+	let userUpdated: Bool
+	let alwaysActive: Bool
 	
 	/// Rather than using different subclasses for each of the "multi" `Signal`s, this one subclass is used for all. However, that requires a few different parameters to enable different behaviors.
-	init(signal: Signal<T>, values: (Array<T>, Error?), isUserUpdated: Bool, dw: inout DeferredWork, context: Exec, updater: Updater?) {
+	init(signal: Signal<T>, values: (Array<T>, Error?), userUpdated: Bool, alwaysActive: Bool, dw: inout DeferredWork, context: Exec, updater: Updater?) {
 		precondition((values.1 == nil && values.0.isEmpty) || updater != nil, "Non empty activation values requires always active.")
 		self.updater = updater
 		self.activationValues = values.0
 		self.preclosed = values.1
-		self.isUserUpdated = isUserUpdated
+		self.userUpdated = userUpdated
+		self.alwaysActive = alwaysActive
 		super.init(signal: signal, dw: &dw, context: context)
 	}
 	
-	/// Multicast is not preactivated but all other types are
+	/// Multicast and continuousWhileActive are not preactivated but all others are not.
 	fileprivate override var alwaysActiveInternal: Bool {
 		assert(signal.mutex.unbalancedTryLock() == false)
-		return updater != nil
+		return alwaysActive
 	}
 	
 	/// Multiprocessor can handle multiple outputs

		return { [weak self] r in
			if let s = self {
				if let u = s.updater {
					if s.isUserUpdated {
						var values = [T]()
						var error: Error?
						

	/// - returns: a continuous `SignalMulti`
	public final func continuous() -> SignalMulti<T> {
		return SignalMulti<T>(processor: attach { (s, dw) in
			SignalMultiProcessor(signal: s, values: ([], nil), userUpdated: false, alwaysActive: true, dw: &dw, context: .direct, updater: { a, p, r -> (Array<T>, Error?) in
				let previous: (Array<T>, Error?) = (a, p)
				switch r {
				case .success(let v): a = [v]; p = nil
