 	/// - returns: an `SignalMulti`
 	public static func preclosed<S: Sequence>(values: S, error: Error = SignalError.closed) -> SignalMulti<T> where S.Iterator.Element == T {
 		return SignalMulti<T>(processor: Signal<T>().attach { (s, dw) in
-			SignalMultiProcessor(signal: s, values: (Array(values), error), isUserUpdated: false, dw: &dw, context: .direct, updater: { a, p, r in ([], nil) })
+			SignalMultiProcessor(signal: s, values: (Array(values), error), userUpdated: false, alwaysActive: true, dw: &dw, context: .direct, updater: { a, p, r in ([], nil) })
 		})
 	}
 	

	/// - returns: an `SignalMulti`
	public static func preclosed(error: Error = SignalError.closed) -> SignalMulti<T> {
		return SignalMulti<T>(processor: Signal<T>().attach { (s, dw) in
			SignalMultiProcessor(signal: s, values: ([], error), isUserUpdated: false, dw: &dw, context: .direct, updater: { a, p, r in ([], nil) })
		})
	}
	

	let updater: Updater?
	var activationValues: Array<T>
	var preclosed: Error?
	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?), 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.userUpdated = userUpdated
		self.alwaysActive = alwaysActive
		super.init(signal: signal, dw: &dw, context: context)
	}
	
	/// Multicast and continuousWhileActive are not preactivated but all others are not.
	fileprivate override var alwaysActiveInternal: Bool {
		assert(signal.mutex.unbalancedTryLock() == false)
		return alwaysActive
	}
	
	/// Multiprocessor can handle multiple outputs
