 			]
 
 			for project in dependencies {
-				let (outputSignal, schemeSignals) = buildDependencyProject(project, directoryURL, withConfiguration: "Debug")
-				let result = schemeSignals
-					.concat(identity)
-					.on(next: { (project, scheme) in
+				let (outputSignal, schemeProducers) = buildDependencyProject(project, directoryURL, withConfiguration: "Debug")
+				let result = schemeProducers
+					|> join(.Concat)
+					|> on(next: { (project, scheme) in
 						NSLog("Building scheme \"\(scheme)\" in \(project)")
 					})
-					.wait()
+					|> wait
 
-				expect(result.error()).to(beNil())
+				expect(result.error).to(beNil())
 			}
 
-			let (outputSignal, schemeSignals) = buildInDirectory(directoryURL, withConfiguration: "Debug")
-			let result = schemeSignals
-				.concat(identity)
-				.on(next: { (project, scheme) in
+			let (outputSignal, schemeProducers) = buildInDirectory(directoryURL, withConfiguration: "Debug")
+			let result = schemeProducers
+				|> join(.Concat)
+				|> on(next: { (project, scheme) in
 					NSLog("Building scheme \"\(scheme)\" in \(project)")
 				})
-				.wait()
+				|> wait
 
-			expect(result.error()).to(beNil())
+			expect(result.error).to(beNil())
 
 			// Verify that the build products exist at the top level.
 			var projectNames = dependencies.map { project in project.name }

			// Verify that the iOS framework is a universal binary for device
			// and simulator.
			let architectures = architecturesInFramework(frameworkFolderURL)
				.reduce(initial: []) { $0 + [ $1 ] }
				.single()
				.value()

			expect(architectures).to(contain("i386"))
			expect(architectures).to(contain("armv7"))
			expect(architectures).to(contain("arm64"))

			// Verify that our dummy framework in the RCL iOS scheme built as
			// well.

			// Copy ReactiveCocoaLayout.framework to the temporary folder.
			let targetURL = targetFolderURL.URLByAppendingPathComponent("ReactiveCocoaLayout.framework", isDirectory: true)

			let resultURL = copyFramework(frameworkFolderURL, targetURL) |> single
			expect(resultURL?.value).to(equal(targetURL))

			expect(NSFileManager.defaultManager().fileExistsAtPath(targetURL.path!, isDirectory: &isDirectory)).to(beTruthy())
			expect(isDirectory).to(beTruthy())

			let strippingResult = stripFramework(targetURL, keepingArchitectures: [ "armv7" , "arm64" ], codesigningIdentity: "-") |> wait
			expect(strippingResult.isSuccess).to(beTruthy())

			let strippedArchitectures = architecturesInFramework(targetURL)
				|> reduce([]) { $0 + [ $1 ] }
				|> single

			expect(strippedArchitectures?.value).notTo(contain("i386"))
			expect(strippedArchitectures?.value).to(contain("armv7"))
			expect(strippedArchitectures?.value).to(contain("arm64"))

			var output: String = ""
			let codeSign = TaskDescription(launchPath: "/usr/bin/xcrun", arguments: [ "codesign", "--verify", "--verbose", targetURL.path! ])

			let codesignResult = launchTask(codeSign, standardError: SinkOf<NSData> { data -> () in
					output += NSString(data: data, encoding: NSStringEncoding(NSUTF8StringEncoding))! as String
				})
				|> wait

			expect(codesignResult.isSuccess).to(beTruthy())

			expect(output).to(contain("satisfies its Designated Requirement"))
		}

		it("should build for one platform") {
			let project = ProjectIdentifier.GitHub(GitHubRepository(owner: "github", name: "Archimedes"))
			let (outputSignal, schemeProducers) = buildDependencyProject(project, directoryURL, withConfiguration: "Debug", platform: .Mac)
			let result = schemeProducers
				|> join(.Concat)
				|> on(next: { (project, scheme) in
					NSLog("Building scheme \"\(scheme)\" in \(project)")
				})
				|> wait

			expect(result.error).to(beNil())

			// Verify that the build product exists at the top level.
			let path = buildFolderURL.URLByAppendingPathComponent("Mac/\(project.name).framework").path!
