 		generatorDisposable = generator(observer)
 	}
 
+	/// Return the state snapshot if the signal is in the `terminating` state, or
+	/// `nil` otherwise.
+	///
+	/// Calling this method as a result of a false positive `terminating` check
+	/// is permitted. `nil` would be returned in this case.
+	///
+	/// - note: The `updateLock` would be acquired.
+	///
+	/// - returns:
+	///   The state snapshot associated with a termination event, or `nil`.
+	private func shouldReallyTerminate() -> SignalStateSnapshot<Value, Error, Event<Value, Error>>? {
+		// Acquire `updateLock`. If the termination has still not yet been
+		// handled, take it over and bump the status to `terminated`.
+		updateLock.lock()
+
+		if case let .terminating(snapshot) = state {
+			state = .terminated
+			updateLock.unlock()
+			return snapshot
+		}
+
+		updateLock.unlock()
+		return nil
+	}
+
 	/// Swap the generator disposable with `nil`.
 	///
 	/// - returns:
 	///   The generator disposable, or `nil` if it has been disposed of.
-	@inline(__always)
 	private func swapDisposable() -> Disposable? {
 		if let d = generatorDisposable {
 			generatorDisposable = nil

			//   also be checked again after the locks are acquired. Fail gracefully
			//   if the state has changed since the relaxed read, i.e. a concurrent
			//   sender has already handled the termination event.

			if event.isTerminating {
				// Recursive events are disallowed for `value` events, but are permitted

				// Check if the status has been bumped to `terminating` due to a
				// concurrent termination event that has not been caught in the main
				// protected section.
				if !shouldDispose, case .terminating = signal.state {
					signal.sendLock.lock()

					if let snapshot = signal.shouldReallyTerminate() {
						for observer in snapshot.observers {
							observer.action(snapshot.associated)
						}

						shouldDispose = true
					}

					signal.sendLock.unlock()
