 	}
 	
 	public func transform<U>(context: Exec = .direct, handler: @escaping (Result<T>, SignalNext<U>) -> Void) -> SignalChannel<I, U> {
-		return nextStage { $0.transform(context: context, handler: handler) }
+		return next { $0.transform(context: context, handler: handler) }
 	}
 	
 	public func transform<S, U>(initialState: S, context: Exec = .direct, handler: @escaping (inout S, Result<T>, SignalNext<U>) -> Void) -> SignalChannel<I, U> {
-		return nextStage { $0.transform(initialState: initialState, context: context, handler: handler) }
+		return next { $0.transform(initialState: initialState, context: context, handler: handler) }
 	}
 	
 	public func combine<U, V>(second: Signal<U>, context: Exec = .direct, handler: @escaping (EitherResult2<T, U>, SignalNext<V>) -> Void) -> SignalChannel<I, V> {
-		return nextStage { $0.combine(second: second, context: context, handler: handler) }
+		return next { $0.combine(second: second, context: context, handler: handler) }
 	}
 	
 	public func combine<U, V, W>(second: Signal<U>, third: Signal<V>, context: Exec = .direct, handler: @escaping (EitherResult3<T, U, V>, SignalNext<W>) -> Void) -> SignalChannel<I, W> {
-		return nextStage { $0.combine(second: second, third: third, context: context, handler: handler) }
+		return next { $0.combine(second: second, third: third, context: context, handler: handler) }
 	}
 	
 	public func combine<U, V, W, X>(second: Signal<U>, third: Signal<V>, fourth: Signal<W>, context: Exec = .direct, handler: @escaping (EitherResult4<T, U, V, W>, SignalNext<X>) -> Void) -> SignalChannel<I, X> {
-		return nextStage { $0.combine(second: second, third: third, fourth: fourth, context: context, handler: handler) }
+		return next { $0.combine(second: second, third: third, fourth: fourth, context: context, handler: handler) }
 	}
 	
 	public func combine<U, V, W, X, Y>(second: Signal<U>, third: Signal<V>, fourth: Signal<W>, fifth: Signal<X>, context: Exec = .direct, handler: @escaping (EitherResult5<T, U, V, W, X>, SignalNext<Y>) -> Void) -> SignalChannel<I, Y> {
-		return nextStage { $0.combine(second: second, third: third, fourth: fourth, fifth: fifth, context: context, handler: handler) }
+		return next { $0.combine(second: second, third: third, fourth: fourth, fifth: fifth, context: context, handler: handler) }
 	}
 	
 	public func combine<S, U, V>(initialState: S, second: Signal<U>, context: Exec = .direct, handler: @escaping (inout S, EitherResult2<T, U>, SignalNext<V>) -> Void) -> SignalChannel<I, V> {
-		return nextStage { $0.combine(initialState: initialState, second: second, context: context, handler: handler) }
+		return next { $0.combine(initialState: initialState, second: second, context: context, handler: handler) }
 	}
 	
 	public func combine<S, U, V, W>(initialState: S, second: Signal<U>, third: Signal<V>, context: Exec = .direct, handler: @escaping (inout S, EitherResult3<T, U, V>, SignalNext<W>) -> Void) -> SignalChannel<I, W> {
-		return nextStage { $0.combine(initialState: initialState, second: second, third: third, context: context, handler: handler) }
+		return next { $0.combine(initialState: initialState, second: second, third: third, context: context, handler: handler) }
 	}
 	
 	public func combine<S, U, V, W, X>(initialState: S, second: Signal<U>, third: Signal<V>, fourth: Signal<W>, context: Exec = .direct, handler: @escaping (inout S, EitherResult4<T, U, V, W>, SignalNext<X>) -> Void) -> SignalChannel<I, X> {
-		return nextStage { $0.combine(initialState: initialState, second: second, third: third, fourth: fourth, context: context, handler: handler) }
+		return next { $0.combine(initialState: initialState, second: second, third: third, fourth: fourth, context: context, handler: handler) }
 	}
 	
 	public func combine<S, U, V, W, X, Y>(initialState: S, second: Signal<U>, third: Signal<V>, fourth: Signal<W>, fifth: Signal<X>, context: Exec = .direct, handler: @escaping (inout S, EitherResult5<T, U, V, W, X>, SignalNext<Y>) -> Void) -> SignalChannel<I, Y> {
-		return nextStage { $0.combine(initialState: initialState, second: second, third: third, fourth: fourth, fifth: fifth, context: context, handler: handler) }
+		return next { $0.combine(initialState: initialState, second: second, third: third, fourth: fourth, fifth: fifth, context: context, handler: handler) }
 	}
 	
 	public func continuous(initialValue: T) -> (I, SignalMulti<T>) {
-		return (input, signal.continuous(initialValue: initialValue))
+		return final { $0.continuous(initialValue: initialValue) }
 	}
 	
 	public func continuous() -> (I, SignalMulti<T>) {
-		return (input, signal.continuous())
+		return final { $0.continuous() }
 	}
 	
 	public func continuousWhileActive() -> (I, SignalMulti<T>) {
-		return (input, signal.continuousWhileActive())
+		return final { $0.continuousWhileActive() }
 	}
 	
 	public func playback() -> (I, SignalMulti<T>) {
-		return (input, signal.playback())
+		return final { $0.playback() }
 	}
 	
 	public func cacheUntilActive() -> (I, SignalMulti<T>) {
-		return (input, signal.playback())
+		return final { $0.playback() }
 	}
 	
 	public func multicast() -> (I, SignalMulti<T>) {
-		return (input, signal.playback())
+		return final { $0.playback() }
 	}
 	
 	public func capture() -> (I, SignalCapture<T>) {
-		return (input, signal.capture())
+		return final { $0.capture() }
 	}
 	
 	public func customActivation(initialValues: Array<T> = [], context: Exec = .direct, updater: @escaping (_ cachedValues: inout Array<T>, _ cachedError: inout Error?, _ incoming: Result<T>) -> Void) -> (I, SignalMulti<T>) {
-		return (input, signal.customActivation(initialValues: initialValues, context: context, updater: updater))
+		return final { $0.customActivation(initialValues: initialValues, context: context, updater: updater) }
 	}
 }
 
 // Implementation of SignalExtensions.swift
 extension SignalChannel {
 	public func subscribeValues(context: Exec = .direct, handler: @escaping (T) -> Void) -> (I, SignalEndpoint<T>) {
-		return (input, signal.subscribeValues(context: context, handler: handler))
+		return final { $0.subscribeValues(context: context, handler: handler) }
 	}
 	
 	public func subscribeValuesAndKeepAlive(context: Exec = .direct, handler: @escaping (ValueType) -> Bool) -> I {

extension SignalChannel {
	
	public func all(context: Exec = .direct, test: @escaping (T) -> Bool) -> SignalChannel<I, Bool> {
		return nextStage { $0.all(context: context, test: test) }
	}
	
	public func some(context: Exec = .direct, test: @escaping (T) -> Bool) -> SignalChannel<I, Bool> {
		return nextStage { $0.some(context: context, test: test) }
		}
}

extension SignalChannel where T: Equatable {
	
	public func contains(value: T) -> SignalChannel<I, Bool> {
		return nextStage { $0.contains(value: value) }
	}
}

extension SignalChannel {
	
	public func defaultIfEmpty(value: T) -> SignalChannel<I, T> {
		return nextStage { $0.defaultIfEmpty(value: value) }
	}
	
	public func switchIfEmpty(alternate: Signal<T>) -> SignalChannel<I, T> {
		return nextStage { $0.switchIfEmpty(alternate: alternate) }
		}
}

extension SignalChannel where T: Equatable {
	
	public func sequenceEqual(to: Signal<T>) -> SignalChannel<I, Bool> {
		return nextStage { $0.sequenceEqual(to: to) }
	}
}

extension SignalChannel {
	
	public func skipUntil<U>(_ other: Signal<U>) -> SignalChannel<I, T> {
		return nextStage { $0.skipUntil(other) }
	}
	
	public func skipWhile(context: Exec = .direct, condition: @escaping (T) -> Bool) -> SignalChannel<I, T> {
		return nextStage { $0.skipWhile(context: context, condition: condition) }
		}
	
	public func skipWhile<U>(initialState initial: U, context: Exec = .direct, condition: @escaping (inout U, T) -> Bool) -> SignalChannel<I, T> {
		return nextStage { $0.skipWhile(initialState: initial, context: context, condition: condition) }
		}
	
	public func takeUntil<U>(_ other: Signal<U>) -> SignalChannel<I, T> {
		return nextStage { $0.takeUntil(other) }
		}
	
	public func takeWhile(context: Exec = .direct, condition: @escaping (T) -> Bool) -> SignalChannel<I, T> {
		return nextStage { $0.takeWhile(context: context, condition: condition) }
		}
	
	public func takeWhile<U>(initialState initial: U, context: Exec = .direct, condition: @escaping (inout U, T) -> Bool) -> SignalChannel<I, T> {
		return nextStage { $0.takeWhile(initialState: initial, context: context, condition: condition) }
		}
	
	public func foldAndFinalize<U, V>(_ initial: V, context: Exec = .direct, finalize: @escaping (V) -> U?, fold: @escaping (V, T) -> V) -> SignalChannel<I, U> {
		return nextStage { $0.foldAndFinalize(initial, context: context, finalize: finalize, fold: fold) }
		}
}

extension SignalChannel where T: BinaryInteger {
	
	public func average() -> SignalChannel<I, T> {
		return nextStage { $0.average() }
	}
}

extension SignalChannel {
	
	public func concat(_ other: Signal<T>) -> SignalChannel<I, T> {
		return nextStage { $0.concat(other) }
	}
	
	public func count() -> SignalChannel<I, Int> {
		return nextStage { $0.count() }
		}
}

extension SignalChannel where T: Comparable {
	
	public func min() -> SignalChannel<I, T> {
		return nextStage { $0.min() }
	}
	
	public func max() -> SignalChannel<I, T> {
		return nextStage { $0.max() }
		}
}

extension SignalChannel {
	
	public func reduce<U>(_ initial: U, context: Exec = .direct, fold: @escaping (U, T) -> U) -> SignalChannel<I, U> {
		return nextStage { $0.reduce(initial, context: context, fold: fold) }
	}
}

extension SignalChannel where T: Numeric {
	
	public func sum() -> SignalChannel<I, T> {
		return nextStage { $0.sum() }
	}
}


		return try Signal<T>.channel().join(to: to, onError: onError)
	}
	
	public static func subscribeValuesAndKeepAlive(context: Exec = .direct, handler: @escaping (ValueType) -> Bool) -> SignalInput<T> {
		return Signal<T>.channel().subscribeValuesAndKeepAlive(context: context, handler: handler)
	}
	
	public static func join(to: SignalMergeSet<T>, closePropagation: SignalClosePropagation = .none, removeOnDeactivate: Bool = false) throws -> SignalInput<T> {
		return try Signal<T>.channel().join(to: to, closePropagation: closePropagation, removeOnDeactivate: removeOnDeactivate)
	}
