 
 				signal.sendLock.lock()
 
-				if case .green = signal.status {
+				if case .alive = signal.status {
 					for observer in observers {
 						observer.action(event)
 					}
 
 					// Check if a downstream consumer or a concurrent sender has
 					// interrupted the signal.
-					if case let .yellow(state) = signal.status {
+					if case let .terminating(state) = signal.status {
 						state.send()
-						signal.status = .red
+						signal.status = .terminated
 						shouldDispose = true
 					}
 				}
 
 				signal.sendLock.unlock()
 
-				// Based on the implicit memory order, any updates to the
-				// `terminationSnapshot` should always be visible after `sendLock` is
-				// released. So we check it again and handle the termination if
-				// it has not been taken over.
-				if !shouldDispose, case let .yellow(state) = signal.status {
+				// Based on the implicit memory order, any updates to `status` should
+				// always be visible after `sendLock` is released. So we check it again
+				// and handle the termination if it has not been taken over.
+				if !shouldDispose, case .terminating = signal.status {
 					signal.sendLock.lock()
 
-					// The status check before acquring `sendLock` could be a false
+					// The `terminating` check before acquring `sendLock` could be a false
 					// positive, since it might race against other concurrent senders
 					// until the lock acquisition above succeeds. So we have to check
-					// again if the signal is still at `yellow`.
-					if case .yellow = signal.status {
+					// again if the status is still `terminating`.
+					if case let .terminating(state) = signal.status {
 						state.send()
-						signal.status = .red
+						signal.status = .terminated
 						shouldDispose = true
 					}
 

/// The status of a `Signal`.
private enum SignalStatus<Value, Error: Swift.Error> {
	/// The `Signal` is alive.
	case green

	/// The `Signal` has received a termination event, and is about to be
	/// terminated.
	case yellow(SignalTerminationSnapshot<Value, Error>)

	/// The `Signal` has terminated.
	case red
}

/// A snapshot of the state of a `Signal` when it receives a termination event.

	/// The state of the signal. `nil` if the signal has terminated.
	private let state: Atomic<SignalState<Value, Error>?>

	/// The status of the signal. It synchronizes with `sendLock`.
	private var status: SignalStatus<Value, Error>

	/// Used to ensure that events are serialized during delivery to observers.
