 	/// - 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) })
+			SignalMultiProcessor(signal: s, values: ([], error), userUpdated: false, alwaysActive: true, dw: &dw, context: .direct, updater: { a, p, r in ([], nil) })
 		})
 	}
 	

	/// - Returns: a buffered `SignalMulti`
	public final func customActivation(initial: Array<T> = [], context: Exec = .direct, updater: @escaping (_ cachedValues: inout Array<T>, _ cachedError: inout Error?, _ incoming: Result<T>) -> Void) -> SignalMulti<T> {
		return SignalMulti<T>(processor: attach { (s, dw) in
			SignalMultiProcessor(signal: s, values: (initial, nil), isUserUpdated: true, dw: &dw, context: context) { (bufferedValues: inout Array<T>, bufferedError: inout Error?, incoming: Result<T>) -> (Array<T>, Error?) in
				let oldActivationValues = bufferedValues
				let oldError = bufferedError
				updater(&bufferedValues, &bufferedError, incoming)

		})
	}
	
	/// Appends a new `SignalMulti` to this `Signal`. The new `SignalMulti` does not immediately activate (it waits until an endpoint activates it normally). The first activator receives no cached values but subsequent activators will receive the most recent value. Upon deactivation, the cached value is discarded and deactivation is propagated normally to antecedents.
	///
	/// - returns: a continuous `SignalMulti`
	public final func continuousWhileActive() -> SignalMulti<T> {
		return SignalMulti<T>(processor: attach { (s, dw) in
			SignalMultiProcessor(signal: s, values: ([], nil), userUpdated: false, alwaysActive: false, 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
				case .failure(let e): a = []; p = e
				}
				return previous
			})
		})
	}
	
	/// Appends a new `SignalMulti` to this `Signal`. The new `SignalMulti` immediately activates its antecedents and offers full "playback" (multiple listeners can be attached to the `SignalMulti` and each new listener receives the entire history of values previously sent through this `Signal` upon "activation").
	///
	/// - returns: a playback `SignalMulti`
	public final func playback() -> 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
				switch r {
				case .success(let v): a.append(v)
				case .failure(let e): p = e
