 					state = .terminated
 					stateLock.unlock()
 
-					defer { sendLock.unlock() }
-
 					if let event = terminationKind.materialize() {
 						for observer in observers {
 							observer.action(event)
 						}
 					}
 
-					return .shouldDispose
+					sendLock.unlock()
+					disposable.dispose()
+					return
 				}
 			}
 
 			stateLock.unlock()
-			return .none
 		}
 
 		/// Try to dispose of the signal silently if the `Signal` has deinitialized and

		/// method as a result of a false positive `terminating` check is permitted.
		///
		/// - precondition: `stateLock` must not be acquired by the caller.
		///
		/// - returns: `.shouldDispose` if the attempt succeeds. `.none` otherwise.
		private func tryToCommitTermination() -> OperationResult {
			// Acquire `stateLock`. If the termination has still not yet been
			// handled, take it over and bump the status to `terminated`.
			stateLock.lock()

	private let core: Core

	private final class Core {
		/// The disposable associated with the signal.
		///
		/// Disposing of `disposable` is assumed to remove the generator
		/// observer from its attached `Signal`, so that the generator observer
		/// as the last +1 retain of the `Signal` core may deinitialize.
		private let disposable: SerialDisposable

		/// The state of the signal.
