 							observer.action(event)
 						}
 
+						// Check if a downstream consumer or a concurrent sender has
+						// interrupted the signal.
 						if !isTerminating, let state = interruptedState.swap(nil) {
 							for observer in state.observers {
 								observer.sendInterrupted()


					sendLock.unlock()

					// Based on the implicit memory order, any disposal of `interrupted`
					// should always be visible after `sendLock` is released. So we
					// check `interrupted` here again and handle the interruption if
					// necessary.
					if !shouldDispose && !terminated && !isTerminating, let state = interruptedState.swap(nil) {
						sendLock.lock()


			}

			if case .interrupted = event {
				// Recursive events are generally disallowed. But `interrupted` is kind
				// of a special snowflake, since it can inadvertently be sent by
				// downstream consumers.
				//
				// So we would treat `interrupted` events specially. If it happens
				// to occur while the `sendLock` is acquired, the observer call-out and
				// the disposal would be delegated to the current sender, or
				// occasionally one of the senders waiting on `sendLock`.
				if let state = signal.state.swap(nil) {
					interruptedState.value = state

