NSScrollView: Overriding "scrollWheel(with:)" can cause a never-ending live scroll

That's a gesture, not a scroll. This method was designed for a mouse wheel and may or may not be simulated properly on modern systems. There are many historical layers of hacks on top of each other to support mice, mouse wheels, trackpads, elasticity, etc.

Obviously your overridden method does nothing, so you shouldn't override it.

The question you want to answer is what are you trying to accomplish by overriding scrollWheel(with:)? There's probably a better way to do it. The only time I ever override scrollWheel(with:) is to prevent scrolling, or otherwise hack some other system bug that would be worse.

Thanks for the reduced test case and for filing FB25362729. I ran your NSScrollViewTest project, built with Xcode 27.1, in macOS 27.0.1 and reproduced the stuck live scroll. After about a dozen horizontal trackpad scrolls, the last live scroll didn't end. When I quit the app 48 seconds later, didEndLiveScrollNotification still hadn't arrived. So the problem isn't limited to macOS 27.2. That might be worth adding to your report.

In a test app of my own with your configuration, two variations of the override also misbehaved. One zooms on Option-scroll and calls super for everything else. The other puts the override in the document view instead of the scroll view. In both, live scrolls kept running across several separate gestures, and some pinches made during them didn't start a live magnify.

Handling Option-scroll in a local event monitor, with no scrollWheel(with:) override at all, avoided the problem in my tests. Trackpad scrolling arrives as scroll-wheel events that carry a phase. The code uses the phase to decide once per gesture, when the gesture begins, whether to zoom, and keeps that decision through momentum:

private var scrollWheelMonitor: Any?

private var isOptionZoomGesture = false

// In viewDidLoad():
scrollWheelMonitor = NSEvent.addLocalMonitorForEvents(matching: .scrollWheel) { [weak self] event in
    guard let self, self.zoomIfOptionScroll(event) else { return event }
    return nil
}

/// Zooms for Option-scroll and returns true, so the scroll view never sees the event.
/// A trackpad gesture is decided once, when it begins, and keeps that decision through momentum.
private func zoomIfOptionScroll(_ event: NSEvent) -> Bool {
    guard event.window === scrollView.window else { return false }

    let isOverScrollView = scrollView.bounds.contains(scrollView.convert(event.locationInWindow, from: nil))
    let wantsZoom = isOverScrollView && event.modifierFlags.contains(.option)

    if event.phase.contains(.mayBegin) || event.phase.contains(.began) {
        isOptionZoomGesture = wantsZoom
    }
    let isGestureEvent = !event.phase.isEmpty || !event.momentumPhase.isEmpty
    guard isGestureEvent ? isOptionZoomGesture : wantsZoom else { return false }

    if event.momentumPhase.isEmpty {
        let delta = event.hasPreciseScrollingDeltas ? event.scrollingDeltaY : event.scrollingDeltaY * 8
        let point = scrollView.contentView.convert(event.locationInWindow, from: nil)
        scrollView.setMagnification(scrollView.magnification * pow(1.01, delta), centeredAt: point)
    }
    return true
}

I removed the override from your ScrollView and added this code to your ViewController. In a test run after that, all 40 live scrolls ended, each within 3 seconds. Option-zoom worked with both the trackpad and a mouse wheel, and so did pinching. I haven't tried this on macOS 27.2. The addLocalMonitorForEvents(matching:handler:) documentation says you must call removeMonitor(_:) to stop the monitor. If your view controller can be released before the app quits, remove the monitor at that point.

So the problem isn't limited to macOS 27.2. That might be worth adding to your report.

I forgot to add that it behaves the same in Sequoia.