 				// 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`.
-				signal.stateLock.lock()
+				signal.updateLock.lock()
 
 				if case let .alive(snapshot) = signal.state {
 					signal.state = .terminating(SignalStateSnapshot(observers: snapshot.observers,
 					                                                retaining: snapshot.retaining,
 					                                                associatedStorage: event))
-					signal.stateLock.unlock()
+					signal.updateLock.unlock()
 
 					if signal.sendLock.try() {
-						// Acquire `stateLock`. If the termination has still not yet been
+						// Acquire `updateLock`. If the termination has still not yet been
 						// handled, take it over and bump the status to `terminated`.
-						signal.stateLock.lock()
+						signal.updateLock.lock()
 
 						if case let .terminating(snapshot) = signal.state {
 							signal.state = .terminated
-							signal.stateLock.unlock()
+							signal.updateLock.unlock()
 
 							snapshot.sendTerminated()
 						} else {
-							signal.stateLock.unlock()
+							signal.updateLock.unlock()
 						}
 
 						signal.sendLock.unlock()
 						signal.swapDisposable()?.dispose()
 					}
 				} else {
-					signal.stateLock.unlock()
+					signal.updateLock.unlock()
 				}
 			} else {
 				var shouldDispose = false

			// - Replace the snapshot of a signal that is alive.
			//   (e.g. observers bag manipulation)
			//
			//   `stateLock` must be acquired.
			//
			// - Transit from `alive` to `terminating`.
			//
			//   `stateLock` must be acquired.
			//
			// - Extract the snapshot of a terminating signal to deliver the
			//   termination event, and transit from `terminating` to `terminated`.
			//
			//   Both `sendLock` and `stateLock` must be acquired. The state must 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 {

					// Check if the status has been bumped to `terminating` due to a
					// concurrent or a recursive termination event.
					//
					// Note that as the check happens before acquiring `updateLock`, it
					// could be a false positive, and thus a second check after the lock
					// is acquired is mandatory.
					if case .terminating = signal.state {
						// Acquire `updateLock`. If the termination has still not yet been
						// handled, take it over and bump the status to `terminated`.
						signal.updateLock.lock()

						if case let .terminating(snapshot) = signal.state {
							signal.state = .terminated
							signal.updateLock.unlock()

							snapshot.sendTerminated()
							shouldDispose = true
						} else {
							signal.updateLock.unlock()
						}
					}
				}
