         }
     }
 
-    private func inheritValue(forKeyPath keyPath: String?) {
-        guard let keyPath = keyPath else { return }
-        setValue(observee.value(forKeyPath: keyPath), forKeyPath: keyPath)
-    }
-
-    // MARK: - Derived values
-
-    override func cancel() {
-        observee.cancel()
-    }
-
-    override func pause() {
-        observee.pause()
-    }
-
-    @available(macOS 10.11, iOS 9.0, watchOS 2.0, tvOS 9.0, *)
-    override func resume() {
-        observee.resume()
-    }
-
-    @objc static var keyPathsForValuesAffectingUserInfo: Set<String> {
-        return [ #keyPath(observee.userInfo) ]
-    }
-
-    override var userInfo: [ProgressUserInfoKey: Any] {
-        return observee.userInfo
-    }
-
-    override func setUserInfoObject(_ objectOrNil: Any?, forKey key: ProgressUserInfoKey) {
-        observee.setUserInfoObject(objectOrNil, forKey: key)
-    }
-
-    // MARK: - KVO babysitting
-
     /// A side-table object to weakify the progress observer and prevent
     /// delivery of notifications after deinit.
-    private final class Observation: NSObject {
-        private static var cancelledContext = false
-        private static var pausedContext = false
-        private static var attributesContext = false
-        private static let attributes = [
-            #keyPath(Progress.completedUnitCount),
-            #keyPath(Progress.totalUnitCount),
+    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),

/// tree.
private final class ProxyProgress: Progress {

    @objc dynamic private let observee: Progress
    private var token: Observation?

    init(attachingTo observee: Progress) {
        self.observee = observee
        super.init(parent: .current(), userInfo: nil)
        token = Observation(observing: observee, observer: self)
    }

    deinit {
        token?.invalidate(observing: observee)
    }

    private func inheritCancelled() {
        if observee.isCancelled {
            super.cancel()
        }
    }

    private func inheritPaused() {
        if observee.isPaused {
            super.pause()
        } else if #available(macOS 10.11, iOS 9.0, watchOS 2.0, tvOS 9.0, *) {

            #keyPath(Progress.kind)
        ]

        struct State: OptionSet {
            let rawValue: UInt8
            static let ready = State(rawValue: 1 << 0)
            static let observing = State(rawValue: 1 << 1)
