From b70bb2187cd8f1b1ed96770fc04409d4e71f11d8 Mon Sep 17 00:00:00 2001 From: Kyle Date: Sun, 13 Sep 2026 20:07:28 +0800 Subject: [PATCH 1/6] feat: add HitTestingDebug --- .../Event/HitTest/HitTestingDebug.swift | 54 +++++++++++++++++++ 1 file changed, 54 insertions(+) create mode 100644 Sources/OpenSwiftUI/Event/HitTest/HitTestingDebug.swift diff --git a/Sources/OpenSwiftUI/Event/HitTest/HitTestingDebug.swift b/Sources/OpenSwiftUI/Event/HitTest/HitTestingDebug.swift new file mode 100644 index 000000000..c2a87bc79 --- /dev/null +++ b/Sources/OpenSwiftUI/Event/HitTest/HitTestingDebug.swift @@ -0,0 +1,54 @@ +// +// HitTestingDebug.swift +// OpenSwiftUI +// +// Audited for 6.5.4 +// Status: WIP +// ID: DB5E6F06E13FF0259F656B4E03BE4F79 (SwiftUI) + +import COpenSwiftUI +@_spi(ForOpenSwiftUIOnly) +import OpenSwiftUICore + +// MARK: - HitTestTracing + +private protocol HitTestTracing { + var propertiesAffectingHitTest: [(key: String?, value: String)] { get } + func isEqual(to other: Self) -> Bool +} + +// MARK: - HitTestTrace + +private struct HitTestTrace where Value: HitTestTracing { + let value: Value + let name: String + let identifier: String + let point: CGPoint + let result: Value? + let children: [HitTestTrace] + + func map(_ transform: (Value) -> Other) -> HitTestTrace { + HitTestTrace( + value: transform(value), + name: name, + identifier: identifier, + point: point, + result: result.map(transform), + children: children.map { $0.map(transform) } + ) + } + + func recursiveDescription(annotating values: [Value], depth: Int = 0) -> String { + let annotated = values.contains { value.isEqual(to: $0) } + let prefix = String(repeating: annotated ? "├─" : "│ ", count: depth) + + (annotated ? "▶" : result == nil ? "✕" : "✓") + let properties = value.propertiesAffectingHitTest.map { key, value in + key.map { "\($0): \(value)" } ?? value + } + let description = "\(name)(\(([identifier] + properties).joined(separator: ", ")))" + return (["\(prefix) \(point) \(description)"] + children.map { + $0.recursiveDescription(annotating: values, depth: depth + 1) + }).joined(separator: "\n") + } +} + From 75e188f4d4b95cbf651e53dd8a99cc9b6eb61761 Mon Sep 17 00:00:00 2001 From: Kyle Date: Sun, 13 Sep 2026 21:29:04 +0800 Subject: [PATCH 2/6] feat: add ResponderBasedHitTestTracing --- .../Event/HitTest/HitTestingDebug.swift | 101 ++++++++++++++++++ 1 file changed, 101 insertions(+) diff --git a/Sources/OpenSwiftUI/Event/HitTest/HitTestingDebug.swift b/Sources/OpenSwiftUI/Event/HitTest/HitTestingDebug.swift index c2a87bc79..a4d869628 100644 --- a/Sources/OpenSwiftUI/Event/HitTest/HitTestingDebug.swift +++ b/Sources/OpenSwiftUI/Event/HitTest/HitTestingDebug.swift @@ -52,3 +52,104 @@ private struct HitTestTrace where Value: HitTestTracing { } } +// MARK: - ResponderBasedHitTestTracing + +private enum ResponderBasedHitTestTracing: HitTestTracing { + case view(PlatformView) + case responder(ViewResponder) + + var propertiesAffectingHitTest: [(key: String?, value: String)] { + switch self { + case let .view(view): view.propertiesAffectingHitTest + case let .responder(responder): responder.propertiesAffectingHitTest + } + } + + func isEqual(to other: Self) -> Bool { + switch (self, other) { + case let (.view(lhs), .view(rhs)): lhs === rhs + case let (.responder(lhs), .responder(rhs)): lhs === rhs + default: false + } + } + + func traceHitTest( + point: CGPoint, + radius: CGFloat, + options: ViewResponder.ContainsPointsOptions, + result: Self? + ) -> HitTestTrace { + let trace: HitTestTrace + switch self { + case let .view(view): + let viewResult: PlatformView? = if case let .view(value) = result { + value + } else { + nil + } + trace = view.traceHitTest(point: point, radius: radius, result: viewResult).map(Self.view) + case let .responder(responder): + let responderResult: ViewResponder? = if case let .responder(value) = result { + value + } else { + nil + } + trace = responder.traceHitTest( + point: point, radius: radius, options: options, result: responderResult + ).map(Self.responder) + } + let children: [HitTestTrace]? = { + switch self { + case let .view(view): + if let leaf = view as? any HitTestingLeafPlatformView { + return Update.perform { + guard let responder = leaf.responderForHitTesting else { + return nil + } + // [AI] Both identity operands read the responder's host view. + if let viewResponder = responder as? PlatformViewResponder, + let hostView = viewResponder.hostView, + hostView === viewResponder.hostView + { + return nil + } + return [Self.responder(responder).traceHitTest( + point: view.convert(point, to: nil), radius: radius, options: options, result: result + )] + } + } + case let .responder(responder): + if let viewResponder = responder as? PlatformViewResponder, + let hostView = viewResponder.hostView, + hostView.window != nil + { + if !trace.children.isEmpty { + guard case let .view(resultView) = result else { + break + } + if let hitResponder = responder.hitTest( + globalPoint: point, radius: radius, cacheKey: nil, options: options + ) as? PlatformViewResponder, + hitResponder !== responder, + let hitView = hitResponder.hostView, + resultView.isDescendant(of: hitView) + { + break + } + } + return [Self.view(hostView).traceHitTest( + point: hostView.convert(point, from: nil), radius: radius, options: options, result: result + )] + } + } + return nil + }() + return HitTestTrace( + value: trace.value, name: trace.name, identifier: trace.identifier, + point: trace.point, result: trace.result, + children: children ?? trace.children.map { + $0.value.traceHitTest(point: $0.point, radius: radius, options: options, result: result) + } + ) + } +} From 3055ee8891a524e3644dea4bfdff9111338496aa Mon Sep 17 00:00:00 2001 From: Kyle Date: Sun, 13 Sep 2026 21:49:33 +0800 Subject: [PATCH 3/6] feat(event): add responder hit-test tracing --- .../Event/HitTest/HitTestingDebug.swift | 56 +++++++++++++++++++ 1 file changed, 56 insertions(+) diff --git a/Sources/OpenSwiftUI/Event/HitTest/HitTestingDebug.swift b/Sources/OpenSwiftUI/Event/HitTest/HitTestingDebug.swift index a4d869628..537ef4ec2 100644 --- a/Sources/OpenSwiftUI/Event/HitTest/HitTestingDebug.swift +++ b/Sources/OpenSwiftUI/Event/HitTest/HitTestingDebug.swift @@ -52,6 +52,62 @@ private struct HitTestTrace where Value: HitTestTracing { } } +// MARK: - ViewResponder + HitTestTracing + +extension ViewResponder: HitTestTracing { + fileprivate var propertiesAffectingHitTest: [(key: String?, value: String)] { + var properties: [(key: String?, value: String)] = [] + if self is any AnyGestureContainingResponder, let container = gestureContainer { + properties.append(contentsOf: [ + ("gestureRecognizerContainer", "\(type(of: container))(\(address(of: container)))") + ]) + } + if !(self is any AnyGestureResponder) { + var string = "" + extendPrintTree(string: &string) + if !string.isEmpty { + properties.append(contentsOf: [(nil, string)]) + } + } + return properties + } + + fileprivate func isEqual(to other: ViewResponder) -> Bool { + self === other + } + + fileprivate func traceHitTest( + point: CGPoint, + radius: CGFloat, + options: ContainsPointsOptions, + result: ViewResponder? + ) -> HitTestTrace { + let name = String(describing: type(of: self)) + let identifier = "\(address(of: self))" + let hit = hitTest(globalPoint: point, radius: radius, cacheKey: nil, options: options) + let children = children.compactMap { child -> HitTestTrace? in + let containment = child.containsGlobalPoints([point], cacheKey: nil, options: []) + guard containment.mask != [] || result?.isDescendant(of: self) == true else { + return nil + } + return child.traceHitTest( + point: point, + radius: radius, + options: .platformDefault, + result: result + ) + } + return HitTestTrace( + value: self, + name: name, + identifier: identifier, + point: point, + result: hit, + children: children + ) + } +} + // MARK: - ResponderBasedHitTestTracing private enum ResponderBasedHitTestTracing: HitTestTracing { From caacd642d75c76009c7e43f26a6b040e291bd75d Mon Sep 17 00:00:00 2001 From: Kyle Date: Sun, 13 Sep 2026 22:02:29 +0800 Subject: [PATCH 4/6] feat(event): add UIKit hit-test diagnostics --- .../Shims/UIKit/_UIHitTestContext.h | 36 ++++++++++ .../Event/HitTest/HitTestingDebug.swift | 68 +++++++++++++++++++ 2 files changed, 104 insertions(+) create mode 100644 Sources/COpenSwiftUI/Shims/UIKit/_UIHitTestContext.h diff --git a/Sources/COpenSwiftUI/Shims/UIKit/_UIHitTestContext.h b/Sources/COpenSwiftUI/Shims/UIKit/_UIHitTestContext.h new file mode 100644 index 000000000..6928bec73 --- /dev/null +++ b/Sources/COpenSwiftUI/Shims/UIKit/_UIHitTestContext.h @@ -0,0 +1,36 @@ +// +// _UIHitTestContext.h +// COpenSwiftUI +// +// Audited for 6.5.4 +// Status: Complete + +#ifndef _UIHitTestContext_h +#define _UIHitTestContext_h + +#include "OpenSwiftUIBase.h" +#include "UIGestureRecognizer_Private.h" + +#if __has_include() + +#import + +NS_HEADER_AUDIT_BEGIN(nullability, sendability) + +@interface _UIHitTestContext : NSObject ++ (instancetype)contextWithPoint:(CGPoint)point radius:(CGFloat)radius; +@property (nonatomic, readonly) CGFloat radius; +@end + +@interface UIView (OpenSwiftUI_HitTesting) +- (nullable id<_UIGestureRecognizerContainer>)_hitTestWithContext:(_UIHitTestContext *)context; +@end + +OPENSWIFTUI_EXPORT +_UIHitTestContext * _Nullable _UICurrentHitTestContext(void) OPENSWIFTUI_SWIFT_NAME(getter:_UIHitTestContext.current); + +NS_HEADER_AUDIT_END(nullability, sendability) + +#endif /* __has_include() */ + +#endif /* _UIHitTestContext_h */ diff --git a/Sources/OpenSwiftUI/Event/HitTest/HitTestingDebug.swift b/Sources/OpenSwiftUI/Event/HitTest/HitTestingDebug.swift index 537ef4ec2..04997394e 100644 --- a/Sources/OpenSwiftUI/Event/HitTest/HitTestingDebug.swift +++ b/Sources/OpenSwiftUI/Event/HitTest/HitTestingDebug.swift @@ -52,6 +52,74 @@ private struct HitTestTrace where Value: HitTestTracing { } } +#if os(iOS) || os(visionOS) +import UIKit + +// MARK: - UIView + HitTestTracing + +extension UIView: HitTestTracing { + func printHitTest(_ point: CGPoint, radius: CGFloat) { + guard let hitView = hitTest(point, with: nil) else { return } + let context = _UIHitTestContext(point: convert(point, to: nil), radius: radius) + let hit = hitView._hitTest(with: context) + let resolvedHitView = (hit as? UIView) ?? hitView + let hitResponder = (hit as? UIKitGestureContainer)?.responder + let description = { + if GestureContainerFeature.isEnabled { + let result = hitResponder.map { ResponderBasedHitTestTracing.responder($0) } ?? .view(resolvedHitView) + return ResponderBasedHitTestTracing.view(self) + .traceHitTest(point: point, radius: radius, options: .platformDefault, result: result) + .recursiveDescription(annotating: [result, .view(resolvedHitView)]) + } else { + return traceHitTest(point: point, radius: radius, result: resolvedHitView) + .recursiveDescription(annotating: [resolvedHitView]) + } + }() + Log.eventDebug("HIT TEST\n\(description)\n") + } + + fileprivate var propertiesAffectingHitTest: [(key: String?, value: String)] { + var properties: [(key: String?, value: String)] = [("frame", "\(frame)")] + if isHidden { + properties.append(("isHidden", "true")) + } + if alpha < ViewResponder.minOpacityForHitTest { + properties.append(("alpha", "\(alpha)")) + } + if !isUserInteractionEnabled { + properties.append(("isUserInteractionEnabled", "false")) + } + return properties + } + + fileprivate func isEqual(to other: UIView) -> Bool { + self === other + } + + fileprivate func traceHitTest( + point: CGPoint, + radius: CGFloat, + result: UIView? + ) -> HitTestTrace { + let name = String(describing: type(of: self)) + let identifier = String(format: "%p", self) + let hit = hitTest(point, with: nil) + let children = subviews.compactMap { child -> HitTestTrace? in + let childPoint = child.convert(point, from: self) + guard child.bounds.contains(childPoint) || result?.isDescendant(of: child) == true else { + return nil + } + return child.traceHitTest(point: childPoint, radius: radius, result: result) + } + return HitTestTrace( + value: self, name: name, identifier: identifier, point: point, result: hit, children: children + ) + } +} +#elseif os(macOS) +// TODO: NSView +#endif + // MARK: - ViewResponder + HitTestTracing extension ViewResponder: HitTestTracing { From 0c4a55d72754be4e7a1d4d73dd020050a41e782f Mon Sep 17 00:00:00 2001 From: Kyle Date: Mon, 14 Sep 2026 00:06:24 +0800 Subject: [PATCH 5/6] feat(event): add AppKit hit-test diagnostics --- Package.resolved | 2 +- Package.swift | 5 +- .../Overlay/Accessibility/AXRequest.c | 20 ++++ Sources/COpenSwiftUI/Shims/HIServicesSPI.h | 44 ++++++++ .../Event/HitTest/HitTestingDebug.swift | 104 +++++++++++++++++- 5 files changed, 170 insertions(+), 5 deletions(-) create mode 100644 Sources/COpenSwiftUI/Overlay/Accessibility/AXRequest.c create mode 100644 Sources/COpenSwiftUI/Shims/HIServicesSPI.h diff --git a/Package.resolved b/Package.resolved index feec2584f..56ac9bcdf 100644 --- a/Package.resolved +++ b/Package.resolved @@ -1,5 +1,5 @@ { - "originHash" : "ecd2770b6cd64d41ca6e5cd237e627490c39fa0bafc5d24f34ae63dd958e2063", + "originHash" : "caf188f2a395d2f7d1b4460b42823cf2843cacca2fee1d664e55e75cd582da46", "pins" : [ { "identity" : "darwinprivateframeworks", diff --git a/Package.swift b/Package.swift index 25148aa35..12612a939 100644 --- a/Package.swift +++ b/Package.swift @@ -641,7 +641,10 @@ let cOpenSwiftUITarget = Target.target( .headerSearchPath("../OpenSwiftUI_SPI"), ], cxxSettings: sharedCxxSettings, - swiftSettings: sharedSwiftSettings + swiftSettings: sharedSwiftSettings, + linkerSettings: [ + .linkedFramework("ApplicationServices", .when(platforms: [.macOS])), + ] ) let cOpenSwiftUITestTarget = Target.testTarget( diff --git a/Sources/COpenSwiftUI/Overlay/Accessibility/AXRequest.c b/Sources/COpenSwiftUI/Overlay/Accessibility/AXRequest.c new file mode 100644 index 000000000..904508e48 --- /dev/null +++ b/Sources/COpenSwiftUI/Overlay/Accessibility/AXRequest.c @@ -0,0 +1,20 @@ +// +// AXRequest.c +// COpenSwiftUI +// +// Audited for 6.5.4 +// Status: Complete + +#include "Shims/HIServicesSPI.h" + +#if OPENSWIFTUI_TARGET_OS_OSX + +bool AXIsClientMakingRequest(void) { + return _AXGetClientForCurrentRequestUntrusted() != kAXClientTypeNoActiveRequestFound; +} + +void AXOverrideIsClientMakingRequest(bool value) { + _AXSetClientIdentificationOverride(value ? kAXClientTypeUnknown : kAXClientTypeNoActiveRequestFound); +} + +#endif /* OPENSWIFTUI_TARGET_OS_OSX */ diff --git a/Sources/COpenSwiftUI/Shims/HIServicesSPI.h b/Sources/COpenSwiftUI/Shims/HIServicesSPI.h new file mode 100644 index 000000000..1a8406ea3 --- /dev/null +++ b/Sources/COpenSwiftUI/Shims/HIServicesSPI.h @@ -0,0 +1,44 @@ +// +// HIServicesSPI.h +// COpenSwiftUI +// +// Audited for 6.5.4 +// Status: Complete + +#ifndef HIServicesSPI_h +#define HIServicesSPI_h + +#include "OpenSwiftUIBase.h" + +#if OPENSWIFTUI_TARGET_OS_OSX + +typedef CF_ENUM(int32_t, AXClientType) { + kAXClientTypeNoActiveRequestFound = 0, + kAXClientTypeUnknown, + kAXClientTypeRaft, + kAXClientTypeXCUITest, + kAXClientTypeXCTest, + kAXClientTypeScripter2, + kAXClientTypeSystemEvents, + kAXClientTypeVoiceOver, + kAXClientTypeAssistiveControl, + kAXClientTypeFullKeyboardAccess, + kAXClientTypeDictation, +}; + +OPENSWIFTUI_EXTERN_C_BEGIN + +AXClientType _AXGetClientForCurrentRequestUntrusted(void); +void _AXSetClientIdentificationOverride(AXClientType clientType); + +OPENSWIFTUI_EXPORT +bool AXIsClientMakingRequest(void); + +OPENSWIFTUI_EXPORT +void AXOverrideIsClientMakingRequest(bool value); + +OPENSWIFTUI_EXTERN_C_END + +#endif /* OPENSWIFTUI_TARGET_OS_OSX */ + +#endif /* HIServicesSPI_h */ diff --git a/Sources/OpenSwiftUI/Event/HitTest/HitTestingDebug.swift b/Sources/OpenSwiftUI/Event/HitTest/HitTestingDebug.swift index 04997394e..74a1f5aec 100644 --- a/Sources/OpenSwiftUI/Event/HitTest/HitTestingDebug.swift +++ b/Sources/OpenSwiftUI/Event/HitTest/HitTestingDebug.swift @@ -58,7 +58,7 @@ import UIKit // MARK: - UIView + HitTestTracing extension UIView: HitTestTracing { - func printHitTest(_ point: CGPoint, radius: CGFloat) { + func printHitTest(_ point: CGPoint, radius: CGFloat = 1.0) { guard let hitView = hitTest(point, with: nil) else { return } let context = _UIHitTestContext(point: convert(point, to: nil), radius: radius) let hit = hitView._hitTest(with: context) @@ -117,7 +117,90 @@ extension UIView: HitTestTracing { } } #elseif os(macOS) -// TODO: NSView +import AppKit + +// MARK: - NSView + HitTestTracing + +extension NSView: HitTestTracing { + func printHitTest(_ point: CGPoint, radius: CGFloat = 1.0) { + guard let hitView = hitTest(convert(point, to: superview)) else { return } + let hitResponder: ViewResponder? = { + guard let leaf = hitView as? any HitTestingLeafPlatformView, + leaf.usesResponderForHitTesting else { + return nil + } + return Update.perform { + guard let responder = leaf.responderForHitTesting else { return nil } + var globalPoint = convert(point, to: nil) + if _SemanticFeature_v3.isEnabled { + globalPoint.y = (window?.frame.height ?? 0) - globalPoint.y + } + return responder.hitTest(globalPoint: globalPoint, radius: radius) + } + }() + let description = { + if ResponderBasedHitTesting.isEnabled { + let result = hitResponder.map { ResponderBasedHitTestTracing.responder($0) } ?? .view(hitView) + return ResponderBasedHitTestTracing.view(self) + .traceHitTest(point: point, radius: radius, options: .platformDefault, result: result) + .recursiveDescription(annotating: [result, .view(hitView)]) + } else { + return traceHitTest(point: point, radius: radius, result: hitView) + .recursiveDescription(annotating: [hitView]) + } + }() + Log.eventDebug("HIT TEST\n\(description)\n") + } + + fileprivate var propertiesAffectingHitTest: [(key: String?, value: String)] { + var properties: [(key: String?, value: String)] = [("frame", "\(frame)")] + if isHidden { + properties.append(("isHidden", "true")) + } + if alphaValue < ViewResponder.minOpacityForHitTest { + properties.append(("alpha", "\(alphaValue)")) + } + if let customizing = self as? any RecursiveIgnoreHitTestCustomizing, + customizing.recursiveIgnoreHitTest { + properties.append(("isUserInteractionEnabled", "false")) + } + if let customizing = self as? any HitTestsAsOpaqueCustomizing { + properties.append(("hitTestsAsOpaque", "\(customizing.hitTestsAsOpaque)")) + } + if let customizing = self as? any AcceptsFirstMouseCustomizing, + let value = customizing.customAcceptsFirstMouse { + properties.append(("acceptsFirstMouse", "\(value)")) + } + if self is any HostingViewProtocol, AXIsClientMakingRequest() { + properties.append(("isAccessibilityRequest", "true")) + } + return properties + } + + fileprivate func isEqual(to other: NSView) -> Bool { + self === other + } + + fileprivate func traceHitTest( + point: CGPoint, + radius: CGFloat, + result: NSView? + ) -> HitTestTrace { + let name = String(describing: type(of: self)) + let identifier = String(format: "%p", self) + let hit = hitTest(convert(point, to: superview)) + let children = subviews.compactMap { child -> HitTestTrace? in + let childPoint = child.convert(point, from: self) + guard child.bounds.contains(childPoint) || result?.isDescendant(of: child) == true else { + return nil + } + return child.traceHitTest(point: childPoint, radius: radius, result: result) + } + return HitTestTrace( + value: self, name: name, identifier: identifier, point: point, result: hit, children: children + ) + } +} #endif // MARK: - ViewResponder + HitTestTracing @@ -237,8 +320,16 @@ private enum ResponderBasedHitTestTracing: HitTestTracing { { return nil } + #if os(macOS) + var globalPoint = view.convert(point, to: nil) + if _SemanticFeature_v3.isEnabled { + globalPoint.y = (view.window?.frame.height ?? 0) - globalPoint.y + } + #else + let globalPoint = view.convert(point, to: nil) + #endif return [Self.responder(responder).traceHitTest( - point: view.convert(point, to: nil), radius: radius, options: options, result: result + point: globalPoint, radius: radius, options: options, result: result )] } } @@ -247,6 +338,12 @@ private enum ResponderBasedHitTestTracing: HitTestTracing { let hostView = viewResponder.hostView, hostView.window != nil { + #if os(macOS) + var point = point + if _SemanticFeature_v3.isEnabled { + point.y = (hostView.window?.frame.height ?? 0) - point.y + } + #else if !trace.children.isEmpty { guard case let .view(resultView) = result else { break @@ -261,6 +358,7 @@ private enum ResponderBasedHitTestTracing: HitTestTracing { break } } + #endif return [Self.view(hostView).traceHitTest( point: hostView.convert(point, from: nil), radius: radius, options: options, result: result )] From 5b1013c30cb397e773581d39382cbca0c6a8cb13 Mon Sep 17 00:00:00 2001 From: Kyle Date: Mon, 14 Sep 2026 00:33:43 +0800 Subject: [PATCH 6/6] fix(event): guard platform hit-test tracing on Linux --- Sources/OpenSwiftUI/Event/HitTest/HitTestingDebug.swift | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/Sources/OpenSwiftUI/Event/HitTest/HitTestingDebug.swift b/Sources/OpenSwiftUI/Event/HitTest/HitTestingDebug.swift index 74a1f5aec..7e07d5847 100644 --- a/Sources/OpenSwiftUI/Event/HitTest/HitTestingDebug.swift +++ b/Sources/OpenSwiftUI/Event/HitTest/HitTestingDebug.swift @@ -3,9 +3,10 @@ // OpenSwiftUI // // Audited for 6.5.4 -// Status: WIP +// Status: Complete // ID: DB5E6F06E13FF0259F656B4E03BE4F79 (SwiftUI) +import Foundation import COpenSwiftUI @_spi(ForOpenSwiftUIOnly) import OpenSwiftUICore @@ -261,6 +262,7 @@ extension ViewResponder: HitTestTracing { // MARK: - ResponderBasedHitTestTracing +#if canImport(Darwin) private enum ResponderBasedHitTestTracing: HitTestTracing { case view(PlatformView) case responder(ViewResponder) @@ -375,3 +377,4 @@ private enum ResponderBasedHitTestTracing: HitTestTracing { ) } } +#endif