 // Implementation of Signal.swift
 extension SignalChannel {
 	public func subscribe(context: Exec = .direct, handler: @escaping (Result<T>) -> Void) -> (I, SignalEndpoint<T>) {
-		return (input, signal.subscribe(context: context, handler: handler))
+		return final { $0.subscribe(context: context, handler: handler) }
 	}
 	
 	public func subscribeAndKeepAlive(context: Exec = .direct, handler: @escaping (Result<T>) -> Bool) -> I {
-		signal.subscribeAndKeepAlive(context: context, handler: handler)
-		return input
+		return final { $0.subscribeAndKeepAlive(context: context, handler: handler) }.0
 	}
 	
 	public func join(to: SignalInput<T>) throws -> I {
-		try signal.join(to: to)
-		return input
+		return try final { try $0.join(to: to) }.0
 	}
 	
 	public func join(to: SignalInput<T>, onError: @escaping (SignalJunction<T>, Error, SignalInput<T>) -> ()) throws -> I {
-		try signal.join(to: to, onError: onError)
-		return input
+		return try final { try $0.join(to: to, onError: onError) }.0
 	}
 	
 	public func junction() -> (I, SignalJunction<T>) {
-		return (input, signal.junction())
+		return final { $0.junction() }
 	}
 	
 	public func junctionSignal() -> SignalChannel<(I, SignalJunction<T>), T> {

extension SignalChannel {
	
	public func timeInterval(context: Exec = .direct) -> SignalChannel<I, Double> {
		return nextStage { $0.timeInterval(context: context) }
	}
	
	public func timeout(interval: DispatchTimeInterval, resetOnValue: Bool = true, context: Exec = .direct) -> SignalChannel<I, T> {
		return nextStage { $0.timeout(interval: interval, resetOnValue: resetOnValue, context: context) }
		}
	
	public func timestamp(context: Exec = .direct) -> SignalChannel<I, (T, DispatchTime)> {
		return nextStage { $0.timestamp(context: context) }
		}
}


	}
	
	public func transform<U>(context: Exec = .direct, handler: @escaping (Result<T>, SignalNext<U>) -> Void) -> SignalChannel<I, U> {
		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 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 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 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 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 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 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 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 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 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 final { $0.continuous(initialValue: initialValue) }
	}
	
	public func continuous() -> (I, SignalMulti<T>) {
		return final { $0.continuous() }
	}
	
	public func continuousWhileActive() -> (I, SignalMulti<T>) {
		return final { $0.continuousWhileActive() }
	}
	
	public func playback() -> (I, SignalMulti<T>) {
		return final { $0.playback() }
	}
	
	public func cacheUntilActive() -> (I, SignalMulti<T>) {
		return final { $0.playback() }
	}
	
	public func multicast() -> (I, SignalMulti<T>) {
		return final { $0.playback() }
	}
	
	public func capture() -> (I, SignalCapture<T>) {
		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 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 final { $0.subscribeValues(context: context, handler: handler) }
	}
	
	public func subscribeValuesAndKeepAlive(context: Exec = .direct, handler: @escaping (ValueType) -> Bool) -> I {
