 		}
 	}
 	
-	// Method must be called from *INSIDE* mutex.
+	// The method returns `false` if there are subsequent `KeyValueObserver`s observing part of the path between us and the observed property and `true` if we are directly observing the property.
+	//
+	// Mutex notes: Safe for invocation in or out of mutex
+	private var isObservingTail: Bool {
+		return tailPath == nil || tailPath == "self"
+	}
+	
+	// Weak properties need `self` observed, as well as the property, to correctly detect changes.
+	//
+	// Mutex notes: Safe for invocation in or out of mutex
+	private var needsWeakTailObserver: Bool {
+		return tailPath == "self"
+	}
+	
+	// Accessor for the observed property value. This will correctly get the value from the end of the key path if we are using a tailObserver.
+	//
+	// Mutex notes: Method must be called from *INSIDE* mutex.
 	private func sourceValue() -> Any? {
 		if let t = tailObserver, !isObservingTail {
 			return t.sourceValue()

		cancel(.cancelled)
	}
	
	// Method is called *OUTSIDE* mutex
	private func cancel(_ reason: CallbackReason) {
		let cb = mutex.sync { () -> Callback? in
			guard let c = callback else { return nil }

///	1. don't need to implement `observeValue` yourself, you can instead handle changes in a closure
///	2. you get a `CallbackReason` for each change which includes `valueChanged`, `pathChanged`, `sourceDeleted`.
///	3. observation is automatically cancelled if you release the KeyValueObserver or the source is released
///
/// A majority of the complexity in this class comes from the fact that we turn key-value observing on keyPaths into a series of chained KeyValueObservers that we manage ourselves. This gives us more information when things change but we're re-implementing a number of things that Cococa key-value observing normally gives us for free. Generally in this class, anything involving the `tailPath` is managing observations of the path.
///
/// THREAD SAFETY:
/// This class is memory safe even when observations are triggered concurrently from different threads.
