             guard !oldState.isStrictSuperset(of: .cancellable) else { return }
             bnr_atomic_fetch_or(&state, State.cancelled.rawValue, .relaxed)
 
-            for key in Observation.attributes {
+            for key in Observation.fractionKeyPaths {
+                observee.removeObserver(self, forKeyPath: key, context: &Observation.fractionContext)
+            }
+
+            for key in Observation.attributesKeyPaths {
                 observee.removeObserver(self, forKeyPath: key, context: &Observation.attributesContext)
             }
             observee.removeObserver(self, forKeyPath: #keyPath(Progress.cancelled), context: &Observation.cancelledContext)
             observee.removeObserver(self, forKeyPath: #keyPath(Progress.paused), context: &Observation.pausedContext)
         }
 
-        override func observeValue(forKeyPath keyPath: String?, of _: Any?, change _: [NSKeyValueChangeKey: Any]?, context: UnsafeMutableRawPointer?) {
+        override func observeValue(forKeyPath keyPath: String?, of object: Any?, change: [NSKeyValueChangeKey: Any]?, context: UnsafeMutableRawPointer?) {
             let state = State(rawValue: bnr_atomic_load(&self.state, .relaxed))
             guard state.contains(.ready), let observer = observer else { return }
             // This would be prettier as a switch.
             // https://bugs.swift.org/browse/SR-7877
-            if context == &Observation.cancelledContext {
+            if context == &Observation.fractionContext {
+                observer.inheritFraction()
+            } else if context == &Observation.attributesContext, let keyPath = keyPath {
+                observer.inheritAttribute(change?[.newKey], forKeyPath: keyPath)
+            } else if context == &Observation.cancelledContext {
                 observer.inheritCancelled()
             } else if context == &Observation.pausedContext {
                 observer.inheritPaused()
-            } else if context == &Observation.attributesContext {
-                observer.inheritValue(forKeyPath: keyPath)
             }
         }
     }

            static let cancelled = State(rawValue: 1 << 2)
        }

        private var state = UInt8() // see State
        private weak var observer: ProxyProgress?

        init(observing observee: Progress, observer: ProxyProgress) {
            self.observer = observer
            bnr_atomic_init(&state, State.ready.rawValue)
            super.init()
            activate(observing: observee)
        }

        func activate(observing observee: Progress) {
            for key in Observation.attributes {
                observee.addObserver(self, forKeyPath: key, options: .initial, context: &Observation.attributesContext)
            }
            observee.addObserver(self, forKeyPath: #keyPath(Progress.cancelled), options: .initial, context: &Observation.cancelledContext)
            observee.addObserver(self, forKeyPath: #keyPath(Progress.paused), options: .initial, context: &Observation.pausedContext)

        }
    }

    /// A side-table object to weakify the progress observer and prevent
    /// delivery of notifications after deinit.
    final class Observation: NSObject {
        static var fractionContext = false
        static var attributesContext = false
        static var cancelledContext = false
        static var pausedContext = false

        static let fractionKeyPaths = [
            #keyPath(Progress.fractionCompleted),
            #keyPath(Progress.isIndeterminate)
        ]

        static let attributesKeyPaths = [
            #keyPath(Progress.localizedDescription),
            #keyPath(Progress.localizedAdditionalDescription),
            #keyPath(Progress.cancellable),
