diff --git a/Sources/OpenSwiftUI/EventHandling/Focus/FocusStore.swift b/Sources/OpenSwiftUI/EventHandling/Focus/FocusStore.swift
index c12434923..b5769e4aa 100644
--- a/Sources/OpenSwiftUI/EventHandling/Focus/FocusStore.swift
+++ b/Sources/OpenSwiftUI/EventHandling/Focus/FocusStore.swift
@@ -1,6 +1,3 @@
-// FIXME
-protocol ResponderNode {}
-
 struct FocusStore {
     var seed: VersionSeed
     var focusedResponders: ContiguousArray<ResponderNode>
diff --git a/Sources/OpenSwiftUICore/Event/Event.swift b/Sources/OpenSwiftUICore/Event/Event.swift
deleted file mode 100644
index c625848ec..000000000
--- a/Sources/OpenSwiftUICore/Event/Event.swift
+++ /dev/null
@@ -1,4 +0,0 @@
-// FIXME
-
-package struct EventID: Hashable {}
-package protocol EventType {}
diff --git a/Sources/OpenSwiftUICore/Event/Event/Event.swift b/Sources/OpenSwiftUICore/Event/Event/Event.swift
new file mode 100644
index 000000000..feee8738b
--- /dev/null
+++ b/Sources/OpenSwiftUICore/Event/Event/Event.swift
@@ -0,0 +1,217 @@
+//
+//  Event.swift
+//  OpenSwiftUICore
+//
+//  Status: Complete
+
+package import Foundation
+
+// MARK: - MouseEvent [6.5.4]
+
+package struct MouseEvent: SpatialEventType, TappableEventType, ModifiersEventType, Equatable {
+    package struct Button: RawRepresentable, Equatable {
+        package let rawValue: Int
+
+        package init(rawValue: Int) {
+            self.rawValue = rawValue
+        }
+
+        package static let primary: MouseEvent.Button = .init(rawValue: 1 << 0)
+
+        package static let secondary: MouseEvent.Button = .init(rawValue: 1 << 1)
+
+        package static func other(_ index: Int) -> MouseEvent.Button {
+            .init(rawValue: index)
+        }
+    }
+
+    package var timestamp: Time
+    package var binding: EventBinding?
+    package var button: MouseEvent.Button
+    package var phase: EventPhase
+    package var location: CGPoint
+    package var globalLocation: CGPoint
+    package var modifiers: EventModifiers
+
+    package init(
+        timestamp: Time,
+        binding: EventBinding? = nil,
+        button: MouseEvent.Button,
+        phase: EventPhase,
+        location: CGPoint,
+        globalLocation: CGPoint,
+        modifiers: EventModifiers
+    ) {
+        self.timestamp = timestamp
+        self.binding = binding
+        self.button = button
+        self.phase = phase
+        self.location = location
+        self.globalLocation = globalLocation
+        self.modifiers = modifiers
+    }
+
+    package var radius: CGFloat { .zero }
+
+    package var kind: SpatialEvent.Kind? { .mouse }
+}
+
+extension MouseEvent: HitTestableEventType {}
+
+// MARK: - EventModifiers [6.5.4]
+
+/// A set of key modifiers that you can add to a gesture.
+@available(OpenSwiftUI_v1_0, *)
+@frozen
+public struct EventModifiers: OptionSet {
+    public let rawValue: Int
+
+    public init(rawValue: Int) {
+        self.rawValue = rawValue
+    }
+
+    /// The Caps Lock key.
+    public static let capsLock: EventModifiers = .init(rawValue: 1 << 0)
+
+    /// The Shift key.
+    public static let shift: EventModifiers = .init(rawValue: 1 << 1)
+
+    /// The Control key.
+    public static let control: EventModifiers = .init(rawValue: 1 << 2)
+
+    /// The Option key.
+    public static let option: EventModifiers = .init(rawValue: 1 << 3)
+
+    /// The Command key.
+    public static let command: EventModifiers = .init(rawValue: 1 << 4)
+
+    /// Any key on the numeric keypad.
+    public static let numericPad: EventModifiers = .init(rawValue: 1 << 5)
+
+    /// The Function key.
+    @available(*, deprecated, message: "Function modifier is reserved for system applications")
+    public static let function: EventModifiers = .init(rawValue: 1 << 6)
+
+    package static let _function: EventModifiers = .init(rawValue: 1 << 6)
+
+    /// All possible modifier keys.
+    public static let all: EventModifiers = [.capsLock, .shift, .control, .option, .command, .numericPad]
+
+    package static let _all: EventModifiers = [.capsLock, .shift, .control, .option, .command, .numericPad, ._function]
+}
+
+// MARK: - ModifiersEventType [6.5.4]
+
+package protocol ModifiersEventType: EventType {
+    var modifiers: EventModifiers { get set }
+}
+
+// MARK: - EventPhase [6.5.4]
+
+@_spi(ForOpenSwiftUIOnly)
+@available(OpenSwiftUI_v6_0, *)
+public enum EventPhase: Hashable {
+    case began
+    case active
+    case ended
+    case failed
+}
+
+@available(*, unavailable)
+extension EventPhase: Sendable {}
+
+extension EventPhase {
+    package var isTerminal: Bool {
+        switch self {
+        case .began, .active: false
+        case .ended, .failed: true
+        }
+    }
+}
+
+// MARK: - EventType [6.5.4]
+
+@_spi(ForOpenSwiftUIOnly)
+@available(OpenSwiftUI_v6_0, *)
+public protocol EventType {
+    var phase: EventPhase { get }
+
+    var timestamp: Time { get }
+
+    var binding: EventBinding? { get set }
+
+    init?(_ event: any EventType)
+}
+
+extension EventType {
+    package init?(_ event: any EventType) {
+        guard let event = event as? Self else {
+            return nil
+        }
+        self = event
+    }
+
+    package var isFocusEvent: Bool {
+        HitTestableEvent(self) == nil
+    }
+}
+
+// MARK: - Event [6.5.4]
+
+package struct Event: EventType {
+    package var phase: EventPhase
+    package var timestamp: Time
+    package var binding: EventBinding?
+
+    package init<T>(_ event: T) where T: EventType {
+        phase = event.phase
+        timestamp = event.timestamp
+        binding = event.binding
+    }
+
+    package init?(_ event: any EventType) {
+        phase = event.phase
+        timestamp = event.timestamp
+        binding = event.binding
+    }
+}
+
+// MARK: - EventID [6.5.4]
+
+@_spi(ForOpenSwiftUIOnly)
+@available(OpenSwiftUI_v6_0, *)
+public struct EventID: Hashable {
+    package var type: any Any.Type
+
+    package var serial: Int
+
+    package init(type: any Any.Type, serial: Int) {
+        self.type = type
+        self.serial = serial
+    }
+
+    public static func == (lhs: EventID, rhs: EventID) -> Bool {
+        lhs.type == rhs.type && lhs.serial == rhs.serial
+    }
+
+    public func hash(into hasher: inout Hasher) {
+        hasher.combine(ObjectIdentifier(type))
+        hasher.combine(serial)
+    }
+}
+
+@available(*, unavailable)
+extension EventID: Sendable {}
+
+extension EventID {
+    package init<T, S>(_ obj: T, subtype: S.Type) where T: NSObject {
+        type = (T, S).self
+        serial = unsafeBitCast(obj, to: Int.self)
+    }
+}
+
+extension EventID: CustomStringConvertible {
+    public var description: String {
+        "\(type)#\(serial)"
+    }
+}
diff --git a/Sources/OpenSwiftUICore/Event/Event/EventBinding.swift b/Sources/OpenSwiftUICore/Event/Event/EventBinding.swift
new file mode 100644
index 000000000..6010eddbd
--- /dev/null
+++ b/Sources/OpenSwiftUICore/Event/Event/EventBinding.swift
@@ -0,0 +1,25 @@
+//
+//  EventBinding.swift
+//  OpenSwiftUICore
+//
+//  Status: Complete
+
+// MARK: - EventBinding [6.5.4]
+
+@_spi(ForOpenSwiftUIOnly)
+@available(OpenSwiftUI_v6_0, *)
+public struct EventBinding: Equatable {
+    package var responder: ResponderNode
+
+    package init(responder: ResponderNode) {
+        self.responder = responder
+    }
+
+    public static func == (lhs: EventBinding, rhs: EventBinding) -> Bool {
+        lhs.responder === rhs.responder
+    }
+}
+
+@_spi(ForOpenSwiftUIOnly)
+@available(*, unavailable)
+extension EventBinding: Sendable {}
diff --git a/Sources/OpenSwiftUICore/Event/Event/EventBindingBridge.swift b/Sources/OpenSwiftUICore/Event/Event/EventBindingBridge.swift
new file mode 100644
index 000000000..167b51f9b
--- /dev/null
+++ b/Sources/OpenSwiftUICore/Event/Event/EventBindingBridge.swift
@@ -0,0 +1,100 @@
+//
+//  EventBindingBridge.swift
+//  OpenSwiftUICore
+//
+//  Status: WIP
+//  ID: E11AC34B5BFF53E1001A61D61F5B9E0F (SwiftUICore)
+
+// MARK: - EventBindingBridge [6.5.4] [WIP]
+
+@_spi(ForOpenSwiftUIOnly)
+@available(OpenSwiftUI_v6_0, *)
+open class EventBindingBridge {
+    package private(set) weak var eventBindingManager: EventBindingManager?
+
+    package var responderWasBoundHandler: ((ResponderNode) -> Void)?
+
+    private struct TrackedEventState {
+        var sourceID: ObjectIdentifier
+        var reset: Bool
+    }
+
+    private var trackedEvents: [EventID: TrackedEventState] = [:]
+
+    public init(eventBindingManager: EventBindingManager) {
+        self.eventBindingManager = eventBindingManager
+    }
+
+    public init() {}
+
+    open var eventSources: [any EventBindingSource] { [] }
+
+    @discardableResult
+    open func send(
+        _ events: [EventID: any EventType],
+        source: any EventBindingSource
+    ) -> Set<EventID> {
+        preconditionFailure("TODO")
+    }
+
+    open func reset(
+        eventSource: any EventBindingSource,
+        resetForwardedEventDispatchers: Bool = false
+    ) {
+        preconditionFailure("TODO")
+    }
+
+    private func resetEvent() {
+        preconditionFailure("TODO")
+    }
+
+    open func setInheritedPhase(_ phase: _GestureInputs.InheritedPhase) {
+        eventBindingManager?.setInheritedPhase(phase)
+    }
+
+    open func source(for sourceType: EventSourceType) -> (any EventBindingSource)? {
+        nil
+    }
+}
+
+@_spi(ForOpenSwiftUIOnly)
+@available(*, unavailable)
+extension EventBindingBridge: Sendable {}
+
+// MARK: - EventBindingBridge + EventBindingManagerDelegate [6.5.4]
+
+@_spi(ForOpenSwiftUIOnly)
+extension EventBindingBridge: EventBindingManagerDelegate {
+    package func didBind(
+        to newBinding: EventBinding,
+        id: EventID
+    ) {
+        if let responderWasBoundHandler {
+            // TODO: Update.enqueueAction(reason:_:)
+            Update.enqueueAction {
+                responderWasBoundHandler(newBinding.responder)
+            }
+        }
+        for eventSource in eventSources {
+            eventSource.didBind(to: newBinding, id: id, in: self)
+        }
+    }
+
+    package func didUpdate(
+        phase: GesturePhase<Void>,
+        in eventBindingManager: EventBindingManager
+    ) {
+        for eventSource in eventSources {
+            eventSource.didUpdate(phase: phase, in: self)
+        }
+    }
+
+    package func didUpdate(
+        gestureCategory: GestureCategory,
+        in eventBindingManager: EventBindingManager
+    ) {
+        for eventSource in eventSources {
+            eventSource.didUpdate(gestureCategory: gestureCategory, in: self)
+        }
+    }
+}
diff --git a/Sources/OpenSwiftUICore/Event/Event/EventBindingManager.swift b/Sources/OpenSwiftUICore/Event/Event/EventBindingManager.swift
new file mode 100644
index 000000000..c50305fc4
--- /dev/null
+++ b/Sources/OpenSwiftUICore/Event/Event/EventBindingManager.swift
@@ -0,0 +1,153 @@
+//
+//  EventBindingManager.swift
+//  OpenSwiftUICore
+//
+//  Status: WIP
+
+import Foundation
+
+// MARK: - EventBindingManager [6.5.4] [WIP]
+
+@_spi(ForOpenSwiftUIOnly)
+@available(OpenSwiftUI_v6_0, *)
+final public class EventBindingManager {
+    package weak var host: (any EventGraphHost)?
+
+    package weak var delegate: (any EventBindingManagerDelegate)?
+
+    private var forwardedEventDispatchers: [ObjectIdentifier: any ForwardedEventDispatcher] = [:]
+
+    private var eventBindings: [EventID: EventBinding] = [:]
+
+    private(set) package var isActive: Bool = false
+
+    package static var current: EventBindingManager? {
+        guard let delegate = ViewGraph.current.delegate,
+              let host = delegate as? ViewRendererHost,
+              let eventGraphHost = host.as(EventGraphHost.self)
+        else {
+            return nil
+        }
+        return eventGraphHost.eventBindingManager
+    }
+
+    private var eventTimer: Timer?
+
+    package init() {}
+
+    deinit {
+        eventTimer?.invalidate()
+    }
+
+    package func addForwardedEventDispatcher(_ dispatcher: any ForwardedEventDispatcher) {
+        forwardedEventDispatchers[ObjectIdentifier(type(of: dispatcher).eventType)] = dispatcher
+    }
+
+    package func rebindEvent(
+        _ identifier: EventID,
+        to: ResponderNode?
+    ) -> (from: EventBinding?, to: EventBinding?)? {
+        preconditionFailure("TODO")
+    }
+
+    package func willRemoveResponder(_ from: ResponderNode) {
+        preconditionFailure("TODO")
+    }
+
+    package func setInheritedPhase(_ phase: _GestureInputs.InheritedPhase) {
+        preconditionFailure("TODO")
+    }
+
+    @discardableResult
+    package func send(_ events: [EventID: any EventType]) -> Set<EventID> {
+        preconditionFailure("TODO")
+    }
+
+    package func send<E>(_ event: E, id: Int) where E: EventType {
+        preconditionFailure("TODO")
+    }
+
+    package var rootResponder: ResponderNode? { preconditionFailure("TODO") }
+
+    package var focusedResponder: ResponderNode? { preconditionFailure("TODO") }
+
+    package func reset(resetForwardedEventDispatchers: Bool = false) {
+        preconditionFailure("TODO")
+    }
+
+    package func isActive<E>(for eventType: E.Type) -> Bool where E: EventType {
+        preconditionFailure("TODO")
+    }
+
+    package func binds<E>(_ event: E) -> Bool where E: EventType {
+        preconditionFailure("TODO")
+    }
+}
+
+@_spi(ForOpenSwiftUIOnly)
+@available(*, unavailable)
+extension EventBindingManager: Sendable {}
+
+// MARK: - ForwardedEventDispatcher [6.5.4]
+
+package protocol ForwardedEventDispatcher {
+    static var eventType: any EventType.Type { get }
+
+    var isActive: Bool { get }
+
+    func wantsEvent(
+        _ event: any EventType,
+        manager: EventBindingManager
+    ) -> Bool
+
+    mutating func receiveEvents(
+        _ events: [EventID: any EventType],
+        manager: EventBindingManager
+    ) -> Set<EventID>
+
+    mutating func reset()
+}
+
+extension ForwardedEventDispatcher {
+    package var isActive: Bool { false }
+
+    package func wantsEvent(
+        _ event: any EventType,
+        manager: EventBindingManager
+    ) -> Bool {
+        true
+    }
+
+    package mutating func reset() {}
+}
+
+// MARK: - EventBindingManagerDelegate [6.5.4]
+
+package protocol EventBindingManagerDelegate: AnyObject {
+    func didBind(
+        to newBinding: EventBinding,
+        id: EventID
+    )
+
+    func didUpdate(
+        phase: GesturePhase<Void>,
+        in eventBindingManager: EventBindingManager
+    )
+
+    func didUpdate(
+        gestureCategory: GestureCategory,
+        in eventBindingManager: EventBindingManager
+    )
+}
+
+extension EventBindingManagerDelegate {
+    package func didBind(
+        to newBinding: EventBinding,
+        id: EventID
+    ) {}
+
+    package func didUpdate(
+        gestureCategory: GestureCategory,
+        in eventBindingManager: EventBindingManager
+    ) {}
+}
diff --git a/Sources/OpenSwiftUICore/Event/Event/EventBindingSource.swift b/Sources/OpenSwiftUICore/Event/Event/EventBindingSource.swift
new file mode 100644
index 000000000..68f633186
--- /dev/null
+++ b/Sources/OpenSwiftUICore/Event/Event/EventBindingSource.swift
@@ -0,0 +1,80 @@
+//
+//  EventBindingSource.swift
+//  OpenSwiftUICore
+//
+//  Status: Complete
+
+// MARK: - EventBindingSource [6.5.4]
+
+@_spi(ForOpenSwiftUIOnly)
+@available(OpenSwiftUI_v6_0, *)
+public protocol EventBindingSource: AnyObject {
+    func attach(to eventBridge: EventBindingBridge)
+
+    func `as`<T>(_ type: T.Type) -> T?
+
+    func didUpdate(
+        phase: GesturePhase<Void>,
+        in eventBridge: EventBindingBridge
+    )
+
+    func didUpdate(
+        gestureCategory: GestureCategory,
+        in eventBridge: EventBindingBridge
+    )
+
+    func didBind(
+        to newBinding: EventBinding,
+        id: EventID,
+        in eventBridge: EventBindingBridge
+    )
+}
+
+@_spi(ForOpenSwiftUIOnly)
+extension EventBindingSource {
+    public func `as`<T>(_ type: T.Type) -> T? { nil }
+
+    public func didUpdate(
+        phase: GesturePhase<Void>,
+        in eventBridge: EventBindingBridge
+    ) {}
+
+    public func didUpdate(
+        gestureCategory: GestureCategory,
+        in eventBridge: EventBindingBridge
+    ) {}
+
+    public func didBind(
+        to newBinding: EventBinding,
+        id: EventID,
+        in eventBridge: EventBindingBridge
+    ) {}
+}
+
+// MARK: - EventBindingBridgeFactory [6.5.4]
+
+package protocol EventBindingBridgeFactory {
+    static func makeEventBindingBridge(
+        bindingManager: EventBindingManager,
+        responder: any AnyGestureResponder
+    ) -> any EventBindingBridge & GestureGraphDelegate
+}
+
+package struct EventBindingBridgeFactoryInput: ViewInput {
+    package static let defaultValue: (any EventBindingBridgeFactory.Type)? = nil
+}
+
+extension _ViewInputs {
+    package func makeEventBindingBridge(
+        bindingManager: EventBindingManager,
+        responder: any AnyGestureResponder
+    ) -> any EventBindingBridge & GestureGraphDelegate {
+        guard let factory = self[EventBindingBridgeFactoryInput.self] else {
+            preconditionFailure("Event binding factory must be configured")
+        }
+        return factory.makeEventBindingBridge(
+            bindingManager: bindingManager,
+            responder: responder
+        )
+    }
+}
diff --git a/Sources/OpenSwiftUICore/Event/Event/EventGraphHost.swift b/Sources/OpenSwiftUICore/Event/Event/EventGraphHost.swift
new file mode 100644
index 000000000..60605f92b
--- /dev/null
+++ b/Sources/OpenSwiftUICore/Event/Event/EventGraphHost.swift
@@ -0,0 +1,29 @@
+//
+//  EventGraphHost.swift
+//  OpenSwiftUICore
+//
+//  Status: Complete
+
+// MARK: - EventGraphHost [6.5.4]
+
+package protocol EventGraphHost: AnyObject {
+    var eventBindingManager: EventBindingManager { get }
+
+    var responderNode: ResponderNode? { get }
+
+    var focusedResponder: ResponderNode? { get }
+
+    var nextGestureUpdateTime: Time { get }
+
+    func setInheritedPhase(_ phase: _GestureInputs.InheritedPhase)
+
+    func sendEvents(
+        _ events: [EventID: any EventType],
+        rootNode: ResponderNode,
+        at time: Time
+    ) -> GesturePhase<Void>
+
+    func resetEvents()
+
+    func gestureCategory() -> GestureCategory?
+}
diff --git a/Sources/OpenSwiftUICore/Event/Event/EventSourceType.swift b/Sources/OpenSwiftUICore/Event/Event/EventSourceType.swift
new file mode 100644
index 000000000..2fd8506ef
--- /dev/null
+++ b/Sources/OpenSwiftUICore/Event/Event/EventSourceType.swift
@@ -0,0 +1,49 @@
+//
+//  EventSourceType.swift
+//  OpenSwiftUICore
+//
+//  Status: Complete
+
+// MARK: - EventSourceType [6.5.4]
+
+@_spi(ForOpenSwiftUIOnly)
+@available(OpenSwiftUI_v6_0, *)
+public enum EventSourceType: CaseIterable {
+    case platformGestureRecognizer
+
+    @available(iOS, unavailable)
+    @available(tvOS, unavailable)
+    @available(watchOS, unavailable)
+    @available(visionOS, unavailable)
+    case platformHostingView
+    
+    @available(macOS, unavailable)
+    @available(tvOS, unavailable)
+    @available(watchOS, unavailable)
+    case hoverGestureRecognizer
+    
+    @available(iOS, unavailable)
+    @available(macOS, unavailable)
+    @available(watchOS, unavailable)
+    @available(visionOS, unavailable)
+    case selectGestureRecognizer
+
+    public static var allCases: [EventSourceType] {
+        var cases: [EventSourceType] = []
+        cases.append(.platformGestureRecognizer)
+        #if !os(iOS) && !os(tvOS) && !os(watchOS) && !os(visionOS)
+        cases.append(.platformHostingView)
+        #endif
+        #if !os(macOS) && !os(tvOS) && !os(watchOS)
+        cases.append(.hoverGestureRecognizer)
+        #endif
+        #if !os(iOS) && !os(macOS) && !os(watchOS) && !os(visionOS)
+        cases.append(.selectGestureRecognizer)
+        #endif
+        return cases
+    }
+}
+
+@_spi(ForOpenSwiftUIOnly)
+@available(*, unavailable)
+extension EventSourceType: Sendable {}
diff --git a/Sources/OpenSwiftUICore/Event/Event/HitTestableEvent.swift b/Sources/OpenSwiftUICore/Event/Event/HitTestableEvent.swift
new file mode 100644
index 000000000..55684b9e4
--- /dev/null
+++ b/Sources/OpenSwiftUICore/Event/Event/HitTestableEvent.swift
@@ -0,0 +1,53 @@
+//
+//  HitTestableEvent.swift
+//  OpenSwiftUICore
+//
+//  Status: Complete
+
+package import Foundation
+
+// MARK: - HitTestableEventType [6.5.4]
+
+package protocol HitTestableEventType: EventType {
+    var hitTestLocation: CGPoint { get }
+    var hitTestRadius: CGFloat { get }
+}
+
+// MARK: - HitTestableEvent [6.5.4]
+
+package struct HitTestableEvent: HitTestableEventType, Equatable {
+    package var phase: EventPhase
+    package var timestamp: Time
+    package var binding: EventBinding?
+    package var hitTestLocation: CGPoint
+    package var hitTestRadius: CGFloat
+
+    package init<T>(_ event: T) where T: HitTestableEventType {
+        phase = event.phase
+        timestamp = event.timestamp
+        binding = event.binding
+        hitTestLocation = event.hitTestLocation
+        hitTestRadius = event.hitTestRadius
+    }
+
+    package init(_ event: any HitTestableEventType) {
+        phase = event.phase
+        timestamp = event.timestamp
+        binding = event.binding
+        hitTestLocation = event.hitTestLocation
+        hitTestRadius = event.hitTestRadius
+    }
+
+    package init?(_ event: any EventType) {
+        guard let event = event as? any HitTestableEventType else {
+            return nil
+        }
+        self.init(event)
+    }
+}
+
+extension HitTestableEventType where Self: SpatialEventType {
+    package var hitTestLocation: CGPoint { globalLocation }
+
+    package var hitTestRadius: CGFloat { radius }
+}
diff --git a/Sources/OpenSwiftUICore/Event/Event/SpatialEvent.swift b/Sources/OpenSwiftUICore/Event/Event/SpatialEvent.swift
new file mode 100644
index 000000000..a23a3f11c
--- /dev/null
+++ b/Sources/OpenSwiftUICore/Event/Event/SpatialEvent.swift
@@ -0,0 +1,91 @@
+//
+//  SpatialEvent.swift
+//  OpenSwiftUICore
+//
+//  Status: Complete
+
+package import Foundation
+
+// MARK: - SpatialEventType [6.5.4]
+
+package protocol SpatialEventType: EventType {
+    var globalLocation: CGPoint { get set }
+    var location: CGPoint { get set }
+    var radius: CGFloat { get }
+    var kind: SpatialEvent.Kind? { get }
+}
+
+extension SpatialEventType {
+    package var kind: SpatialEvent.Kind? { nil }
+}
+
+// MARK: - SpatialEvent [6.5.4]
+
+package struct SpatialEvent: SpatialEventType, Equatable {
+    package enum Kind: Equatable {
+        case touch
+        case mouse
+        case pan
+    }
+
+    package var phase: EventPhase
+    package var timestamp: Time
+    package var binding: EventBinding?
+    package var kind: SpatialEvent.Kind?
+    package var globalLocation: CGPoint
+    package var location: CGPoint
+    package var radius: CGFloat
+
+    package init<T>(_ event: T) where T: SpatialEventType {
+        phase = event.phase
+        timestamp = event.timestamp
+        binding = event.binding
+        kind = event.kind
+        globalLocation = event.globalLocation
+        location = event.location
+        radius = event.radius
+    }
+
+    package init(_ event: any SpatialEventType) {
+        phase = event.phase
+        timestamp = event.timestamp
+        binding = event.binding
+        kind = event.kind
+        globalLocation = event.globalLocation
+        location = event.location
+        radius = event.radius
+    }
+
+    package init?(_ event: any EventType) {
+        guard let event = event as? any SpatialEventType else {
+            return nil
+        }
+        self.init(event)
+    }
+}
+
+package func defaultConvertEventLocations<E>(
+    _ events: inout [EventID: E],
+    converter: (inout [CGPoint]) -> Void
+) {
+    var eventIDs: [EventID] = []
+    var points: [CGPoint] = []
+    for (eventID, event) in events {
+        guard var spatialEvent = event as? SpatialEventType else {
+            continue
+        }
+        eventIDs.append(eventID)
+        points.append(spatialEvent.globalLocation)
+    }
+    guard !points.isEmpty else {
+        return
+    }
+    converter(&points)
+    for (index, eventID) in eventIDs.enumerated() {
+        guard var spatialEvent = events[eventID] as? SpatialEventType else {
+            continue
+        }
+        spatialEvent.location = points[index]
+        events[eventID] = spatialEvent as? E
+    }
+}
diff --git a/Sources/OpenSwiftUICore/Event/Event/TappableEvent.swift b/Sources/OpenSwiftUICore/Event/Event/TappableEvent.swift
new file mode 100644
index 000000000..399af22a9
--- /dev/null
+++ b/Sources/OpenSwiftUICore/Event/Event/TappableEvent.swift
@@ -0,0 +1,82 @@
+//
+//  TappableEvent.swift
+//  OpenSwiftUICore
+//
+//  Status: Complete
+
+package import Foundation
+
+// MARK: - TappableEventType [6.5.4]
+
+package protocol TappableEventType: EventType {}
+
+package typealias PlatformTappableSpatialEvent = TappableSpatialEvent
+
+// MARK: - TappableEvent [6.5.4]
+
+package struct TappableEvent: TappableEventType, Equatable {
+    package var phase: EventPhase
+    package var timestamp: Time
+    package var binding: EventBinding?
+
+    package init<T>(_ event: T) where T: TappableEventType {
+        self.phase = event.phase
+        self.timestamp = event.timestamp
+        self.binding = event.binding
+    }
+
+    package init(_ event: any TappableEventType) {
+        self.phase = event.phase
+        self.timestamp = event.timestamp
+        self.binding = event.binding
+    }
+
+    package init?(_ event: any EventType) {
+        guard let event = event as? any TappableEventType else {
+            return nil
+        }
+        self.init(event)
+    }
+}
+
+// MARK: - TappableSpatialEvent [6.5.4]
+
+package struct TappableSpatialEvent: TappableEventType, SpatialEventType, Equatable {
+    package var phase: EventPhase
+    package var timestamp: Time
+    package var binding: EventBinding?
+    package var globalLocation: CGPoint
+    package var location: CGPoint
+    package var radius: CGFloat
+
+    package init<T>(_ event: T) where T: SpatialEventType, T: TappableEventType {
+        self.phase = event.phase
+        self.timestamp = event.timestamp
+        self.binding = event.binding
+        self.globalLocation = event.globalLocation
+        self.location = event.location
+        self.radius = event.radius
+    }
+
+    package init(_ event: any SpatialEventType & TappableEventType) {
+        self.phase = event.phase
+        self.timestamp = event.timestamp
+        self.binding = event.binding
+        self.globalLocation = event.globalLocation
+        self.location = event.location
+        self.radius = event.radius
+    }
+
+    package init?(_ event: any EventType) {
+        guard let event = event as? any SpatialEventType & TappableEventType else {
+            return nil
+        }
+        self.init(event)
+    }
+}
+
+// MARK: - TouchTypeProviding [6.5.4]
+
+package protocol TouchTypeProviding {
+    var touchType: TouchType { get }
+}
diff --git a/Sources/OpenSwiftUICore/Event/Event/TouchType.swift b/Sources/OpenSwiftUICore/Event/Event/TouchType.swift
new file mode 100644
index 000000000..9387dcac5
--- /dev/null
+++ b/Sources/OpenSwiftUICore/Event/Event/TouchType.swift
@@ -0,0 +1,39 @@
+//
+//  TouchType.swift
+//  OpenSwiftUICore
+//
+//  Status: Complete
+
+// MARK: - TouchType [6.5.4]
+
+@_spi(_)
+@available(OpenSwiftUI_v5_0, *)
+public enum TouchType: Hashable {
+    case direct
+
+    case indirect
+
+    @available(macOS, obsoleted: 14.0)
+    case pencil
+
+    @available(macOS, obsoleted: 14.0)
+    case indirectPointer
+}
+
+@_spi(_)
+@available(*, unavailable)
+extension TouchType: Sendable {}
+
+@_spi(_)
+extension TouchType {
+    #if os(macOS)
+    package static let allTypes: Set<TouchType> = [
+        .direct, .indirect,
+    ]
+    #else
+    package static let allTypes: Set<TouchType> = [
+        .direct, .indirect,
+        .pencil, .indirectPointer,
+    ]
+    #endif
+}
diff --git a/Sources/OpenSwiftUICore/Event/Event_TODO.swift b/Sources/OpenSwiftUICore/Event/Event_TODO.swift
new file mode 100644
index 000000000..41518eabb
--- /dev/null
+++ b/Sources/OpenSwiftUICore/Event/Event_TODO.swift
@@ -0,0 +1,13 @@
+// FIXME
+
+package class ResponderNode {}
+
+package struct ExclusiveGesture<A, B>: PrimitiveGesture {}
+
+package struct _MapGesture<Content, Value>: PrimitiveGesture where Content: Gesture {
+    nonisolated package static func _makeGesture(gesture: _GraphValue<_MapGesture<Content, Value>>, inputs: _GestureInputs) -> _GestureOutputs<Never> {
+        preconditionFailure("TODO")
+    }
+}
+
+package struct AnyGesture<A>: PrimitiveGesture {}
diff --git a/Sources/OpenSwiftUICore/Event/Gesture/EmptyGesture.swift b/Sources/OpenSwiftUICore/Event/Gesture/EmptyGesture.swift
new file mode 100644
index 000000000..2f4f8d1ae
--- /dev/null
+++ b/Sources/OpenSwiftUICore/Event/Gesture/EmptyGesture.swift
@@ -0,0 +1,19 @@
+//
+//  EmptyGesture.swift
+//  OpenSwiftUICore
+//
+//  Status: Complete
+
+// MARK: - EmptyGesture [6.5.4]
+
+package struct EmptyGesture<Value>: PrimitiveGesture {
+    package init() {}
+
+    nonisolated package static func _makeGesture(
+        gesture: _GraphValue<Self>,
+        inputs: _GestureInputs
+    ) -> _GestureOutputs<Value> {
+        let phase = inputs.intern(GesturePhase<Value>.failed, id: .failedValue)
+        return _GestureOutputs(phase: phase)
+    }
+}
diff --git a/Sources/OpenSwiftUICore/Event/Gesture/Gesture.swift b/Sources/OpenSwiftUICore/Event/Gesture/Gesture.swift
new file mode 100644
index 000000000..049f68e50
--- /dev/null
+++ b/Sources/OpenSwiftUICore/Event/Gesture/Gesture.swift
@@ -0,0 +1,351 @@
+//
+//  Gesture.swift
+//  OpenSwiftUICore
+//
+//  Status: WIP
+//  ID: 5DF390A778F4D193C5F92C06542566B0 (SwiftUICore)
+
+package import OpenGraphShims
+import OpenSwiftUI_SPI
+
+// MARK: - Gesture [6.5.4]
+
+/// An instance that matches a sequence of events to a gesture, and returns a
+/// stream of values for each of its states.
+///
+/// Create custom gestures by declaring types that conform to the `Gesture`
+/// protocol.
+@available(OpenSwiftUI_v1_0, *)
+@MainActor
+@preconcurrency
+public protocol Gesture<Value> {
+    /// The type representing the gesture's value.
+    associatedtype Value
+
+    nonisolated static func _makeGesture(
+        gesture: _GraphValue<Self>,
+        inputs: _GestureInputs
+    ) -> _GestureOutputs<Value>
+
+    /// The type of gesture representing the body of `Self`.
+    associatedtype Body: Gesture
+
+    /// The content and behavior of the gesture.
+    var body: Body { get }
+}
+
+// MARK: - PrimitiveGesture [6.5.4]
+
+package protocol PrimitiveGesture: Gesture where Body == Never {}
+
+// MARK: - PubliclyPrimitiveGesture [6.5.4]
+
+package protocol PubliclyPrimitiveGesture: PrimitiveGesture {
+    associatedtype InternalBody: Gesture where Value == InternalBody.Value
+
+    var internalBody: InternalBody { get }
+}
+
+@available(OpenSwiftUI_v1_0, *)
+extension PubliclyPrimitiveGesture {
+    nonisolated public static func _makeGesture(
+        gesture: _GraphValue<Self>,
+        inputs: _GestureInputs
+    ) -> _GestureOutputs<Self.Value> {
+        makeGesture(gesture: gesture, inputs: inputs)
+    }
+
+    nonisolated package static func makeGesture(
+        gesture: _GraphValue<Self>,
+        inputs: _GestureInputs
+    ) -> _GestureOutputs<Self.Value> {
+        InternalBody.makeDebuggableGesture(
+            gesture: gesture[\.internalBody],
+            inputs: inputs
+        )
+    }
+}
+
+// MARK: - Never + Gesture [6.5.4]
+
+@available(OpenSwiftUI_v1_0, *)
+extension Never: Gesture {
+    public typealias Value = Never
+}
+
+@available(OpenSwiftUI_v1_0, *)
+extension PrimitiveGesture {
+    public var body: Never {
+        preconditionFailure("body() should not be called on \(Self.self).")
+    }
+}
+
+// MARK: - GestureBodyAccessor [6.5.4]
+
+private struct GestureBodyAccessor<Container>: BodyAccessor where Container: Gesture {
+    typealias Body = Container.Body
+
+    func updateBody(of container: Container, changed: Bool) {
+        guard changed else { return }
+        setBody { container.body }
+    }
+}
+
+@available(OpenSwiftUI_v1_0, *)
+extension Gesture where Value == Body.Value {
+    public static func _makeGesture(
+        gesture: _GraphValue<Self>,
+        inputs: _GestureInputs
+    ) -> _GestureOutputs<Self.Body.Value> {
+        let fields = DynamicPropertyCache.fields(of: Self.self)
+        var inputs = inputs
+        let (body, _) = GestureBodyAccessor().makeBody(container: gesture, inputs: &inputs.viewInputs.base, fields: fields)
+        return Body.makeDebuggableGesture(gesture: body, inputs: inputs)
+    }
+}
+
+// MARK: - GestureInputs [6.5.4] [WIP]
+
+/// Input (aka inherited) attributes for gesture objects.
+@available(OpenSwiftUI_v1_0, *)
+public struct _GestureInputs {
+    package var viewInputs: _ViewInputs
+
+    package var viewSubgraph: Subgraph
+
+    package var preferences: PreferencesInputs
+
+    package var events: Attribute<[EventID : any EventType]>
+
+    package var resetSeed: Attribute<UInt32>
+
+    @_spi(ForOpenSwiftUIOnly)
+    public struct InheritedPhase: OptionSet, Defaultable {
+        public let rawValue: Int
+
+        public init(rawValue: Int) {
+            self.rawValue = rawValue
+        }
+
+        package static let failed: _GestureInputs.InheritedPhase = .init(rawValue: 1 << 0)
+
+        package static let active: _GestureInputs.InheritedPhase = .init(rawValue: 1 << 1)
+
+        package static let defaultValue: _GestureInputs.InheritedPhase = .failed
+    }
+
+    package var inheritedPhase: Attribute<_GestureInputs.InheritedPhase>
+
+    package var failedPhase: Attribute<GesturePhase<Void>> {
+        get { preconditionFailure("TODO") }
+    }
+
+    package var options: _GestureInputs.Options
+
+    package var platformInputs: PlatformGestureInputs
+
+    package init(
+        _ inputs: _ViewInputs,
+        viewSubgraph: Subgraph,
+        events: Attribute<[EventID : any EventType]>,
+        time: Attribute<Time>,
+        resetSeed: Attribute<UInt32>,
+        inheritedPhase: Attribute<_GestureInputs.InheritedPhase>,
+        gesturePreferenceKeys: Attribute<PreferenceKeys>
+    ) {
+
+        preconditionFailure("TODO")
+    }
+
+    package mutating func mergeViewInputs(
+        _ other: _ViewInputs,
+        viewSubgraph: Subgraph
+    ) {
+        preconditionFailure("TODO")
+    }
+
+    package func animatedPosition() -> Attribute<ViewOrigin> {
+        viewSubgraph.apply {
+            viewInputs.animatedPosition()
+        }
+    }
+
+    package func intern<T>(
+        _ value: T,
+        id: GraphHost.ConstantID
+    ) -> Attribute<T> {
+        GraphHost.currentHost.intern(value, id: id)
+    }
+
+    package func makeIndirectOutputs<Value>() -> _GestureOutputs<Value> {
+        preconditionFailure("TODO")
+    }
+
+    package func makeDefaultOutputs<Value>() -> _GestureOutputs<Value> {
+        preconditionFailure("TODO")
+    }
+}
+
+extension _GestureInputs {
+    package struct Options: OptionSet {
+        package let rawValue: UInt32
+
+        @inlinable
+        package init(rawValue: UInt32) {
+            self.rawValue = rawValue
+        }
+
+        @inlinable
+        package static var preconvertedEventLocations: _GestureInputs.Options {
+            .init(rawValue: 1 << 0)
+        }
+
+        @inlinable
+        package static var allowsIncompleteEventSequences: _GestureInputs.Options {
+            .init(rawValue: 1 << 1)
+        }
+
+        @inlinable
+        package static var skipCombiners: _GestureInputs.Options {
+            .init(rawValue: 1 << 2)
+        }
+
+        @inlinable
+        package static var includeDebugOutput: _GestureInputs.Options {
+            .init(rawValue: 1 << 3)
+        }
+
+        @inlinable
+        package static var gestureGraph: _GestureInputs.Options {
+            .init(rawValue: 1 << 4)
+        }
+    }
+}
+
+@available(*, unavailable)
+extension _GestureInputs: Sendable {}
+
+@available(*, unavailable)
+extension _GestureInputs.InheritedPhase: Sendable {}
+
+// MARK: - GestureOutputs [6.5.4] [WIP]
+
+/// Output (aka synthesized) attributes for gesture objects.
+@available(OpenSwiftUI_v1_0, *)
+public struct _GestureOutputs<Value> {
+    package var phase: Attribute<GesturePhase<Value>>
+
+    package var preferences: PreferencesOutputs
+
+    package var debugData: Attribute<GestureDebug.Data>? {
+        get { preconditionFailure("TODO") }
+        set { preconditionFailure("TODO") }
+    }
+
+    package init(phase: Attribute<GesturePhase<Value>>) {
+        preconditionFailure("TODO")
+    }
+
+    package func withPhase<T>(_ phase: Attribute<GesturePhase<T>>) -> _GestureOutputs<T> {
+        preconditionFailure("TODO")
+    }
+
+    package func overrideDefaultValues(_ childOutputs: _GestureOutputs<Value>) {
+        preconditionFailure("TODO")
+    }
+
+    package func setIndirectDependency(_ dependency: AnyAttribute?) {
+        preconditionFailure("TODO")
+    }
+
+    package func attachIndirectOutputs(_ childOutputs: _GestureOutputs<Value>) {
+        preconditionFailure("TODO")
+    }
+
+    package func detachIndirectOutputs() {
+        preconditionFailure("TODO")
+    }
+
+    package subscript(anyKey key: any AnyPreferenceKey.Type) -> AnyAttribute? {
+        get { preconditionFailure("TODO") }
+        set { preconditionFailure("TODO") }
+    }
+
+    package subscript<K>(key: K.Type) -> Attribute<K.Value>? where K: PreferenceKey {
+        get { preconditionFailure("TODO") }
+        set { preconditionFailure("TODO") }
+    }
+
+    package mutating func appendPreference<K>(
+        key: K.Type,
+        value: Attribute<K.Value>
+    ) where K: PreferenceKey {
+        preconditionFailure("TODO")
+    }
+
+    package func forEachPreference(_ body: (any AnyPreferenceKey.Type, AnyAttribute) -> Void) {
+        preconditionFailure("TODO")
+    }
+}
+
+// MARK: - GestureCategory [6.5.4]
+
+@_spi(ForOpenSwiftUIOnly)
+@available(OpenSwiftUI_v6_0, *)
+public struct GestureCategory: OptionSet {
+    public let rawValue: Int
+
+    public init(rawValue: Int) {
+        self.rawValue = rawValue
+    }
+
+    package static let magnify: GestureCategory = .init(rawValue: 1 << 0)
+
+    package static let rotate: GestureCategory = .init(rawValue: 1 << 1)
+
+    package static let drag: GestureCategory = .init(rawValue: 1 << 2)
+
+    package static let select: GestureCategory = .init(rawValue: 1 << 3)
+
+    package static let longPress: GestureCategory = .init(rawValue: 1 << 4)
+
+    package struct Key: PreferenceKey {
+        package static let _includesRemovedValues: Bool = true
+
+        package static let defaultValue: GestureCategory = .defaultValue
+
+        package static func reduce(
+            value: inout GestureCategory.Key.Value,
+            nextValue: () -> GestureCategory.Key.Value
+        ) {
+            value = GestureCategory(rawValue: value.rawValue | nextValue().rawValue)
+        }
+    }
+}
+
+@available(*, unavailable)
+extension GestureCategory: Sendable {}
+
+// MARK: - GestureDescriptor [6.5.4]
+
+package struct GestureDescriptor: TupleDescriptor {
+    package static var typeCache: [ObjectIdentifier: TupleTypeDescription<GestureDescriptor>] = [:]
+
+    package static var descriptor: UnsafeRawPointer {
+        _OpenSwiftUI_gestureProtocolDescriptor()
+    }
+}
+
+// MARK: - GestureModifierDescriptor [6.5.4]
+
+package struct GestureModifierDescriptor: TupleDescriptor {
+    package static var typeCache: [ObjectIdentifier: TupleTypeDescription<GestureModifierDescriptor>] = [:]
+
+    package static var descriptor: UnsafeRawPointer {
+        _OpenSwiftUI_gestureModifierProtocolDescriptor()
+    }
+}
+
+// MARK: - PlatformGestureInputs [6.5.4]
+
+package struct PlatformGestureInputs {}
diff --git a/Sources/OpenSwiftUICore/Event/Gesture/GestureDebug.swift b/Sources/OpenSwiftUICore/Event/Gesture/GestureDebug.swift
new file mode 100644
index 000000000..10c12ccf1
--- /dev/null
+++ b/Sources/OpenSwiftUICore/Event/Gesture/GestureDebug.swift
@@ -0,0 +1,186 @@
+//
+//  GestureDebug.swift
+//  OpenSwiftUICore
+//
+//  Status: WIP
+//  ID: 40D5679141F478561068F8E300838A67 (SwiftUICore)
+
+package import Foundation
+package import OpenGraphShims
+import OpenSwiftUI_SPI
+
+package enum GestureDebug {
+    package typealias Properties = ArrayWith2Inline<(String, String)>
+
+    package enum Kind {
+        case empty
+        case primitive
+        case modifier
+        case gesture
+        case combiner
+    }
+
+    package struct Data {
+        package var kind: GestureDebug.Kind
+        package var type: any Any.Type
+        package var phase: GesturePhase<()>
+        package var attribute: AnyOptionalAttribute
+        package var resetSeed: UInt32
+        package var frame: CGRect
+        package var properties: GestureDebug.Properties
+        // private var childrenBox: GestureDebug.ChildrenBox
+
+        package typealias Children = ArrayWith2Inline<GestureDebug.Data>
+
+        package var children: GestureDebug.Data.Children {
+            get { preconditionFailure("TODO") }
+            set { preconditionFailure("TODO") }
+        }
+
+        package init() {
+            kind = .empty
+            type = EmptyGesture<()>.self
+            phase = .failed
+            attribute = .init()
+            resetSeed = 0
+            frame = .zero
+            properties = .init()
+        }
+
+        package init(
+            kind: GestureDebug.Kind,
+            type: any Any.Type,
+            children: GestureDebug.Data.Children,
+            phase: GesturePhase<()>,
+            attribute: AnyAttribute?,
+            resetSeed: UInt32,
+            frame: CGRect,
+            properties: GestureDebug.Properties
+        ) {
+            preconditionFailure("TODO")
+        }
+    }
+}
+
+extension GestureDebug.Data: Defaultable {
+    package static let defaultValue: GestureDebug.Data = .init()
+}
+
+// MARK: - PrimitiveDebuggableGesture [6.5.4]
+
+package protocol PrimitiveDebuggableGesture {
+}
+
+// MARK: - DebuggableGesturePhase [6.5.4]
+
+package protocol DebuggableGesturePhase {
+    associatedtype PhaseValue
+    var phase: GesturePhase<PhaseValue> { get set }
+    var properties: GestureDebug.Properties { get }
+}
+
+extension Attribute where Value: DebuggableGesturePhase {
+    package func phase() -> Attribute<GesturePhase<Value.PhaseValue>> {
+        self[offset: { .of(&$0.phase) }]
+    }
+}
+
+extension Gesture {
+    @inline(__always)
+    nonisolated package static func makeDebuggableGesture(
+        gesture: _GraphValue<Self>,
+        inputs: _GestureInputs
+    ) -> _GestureOutputs<Self.Value> {
+        var outputs = _makeGesture(gesture: gesture, inputs: inputs)
+        guard inputs.options.contains(.includeDebugOutput),
+              // FIXME
+              !(self is PrimitiveDebuggableGesture) else {
+            return outputs
+        }
+        outputs.wrapDebugOutputs(Self.self, inputs: inputs)
+        return outputs
+    }
+}
+
+extension GestureModifier {
+    @inline(__always)
+    nonisolated package static func makeDebuggableGesture(
+        modifier: _GraphValue<Self>,
+        inputs: _GestureInputs,
+        body: (_GestureInputs) -> _GestureOutputs<Self.BodyValue>
+    ) -> _GestureOutputs<Self.Value> {
+        var outputs = _makeGesture(modifier: modifier, inputs: inputs, body: body)
+        guard inputs.options.contains(.includeDebugOutput),
+              // FIXME
+              !(self is PrimitiveDebuggableGesture) else {
+            return outputs
+        }
+        outputs.wrapDebugOutputs(Self.self, inputs: inputs)
+        return outputs
+    }
+}
+
+extension _GestureOutputs {
+    @inline(__always)
+    package mutating func wrapDebugOutputs<T>(
+        _ type: T.Type,
+        properties: Attribute<GestureDebug.Properties>? = nil,
+        inputs: _GestureInputs
+    ) {
+        guard inputs.options.contains(.includeDebugOutput) else {
+            return
+        }
+        reallyWrap(
+            type,
+            kind: conformsToProtocol(type, _OpenSwiftUI_gestureModifierProtocolDescriptor()) ? .modifier : .primitive,
+            properties: properties,
+            inputs: inputs,
+            data: (debugData, nil)
+        )
+    }
+
+    @inline(__always)
+    package mutating func wrapDebugOutputs<T, V1, V2>(
+        _ type: T.Type,
+        kind: GestureDebug.Kind,
+        properties: Attribute<GestureDebug.Properties>? = nil,
+        inputs: _GestureInputs,
+        combiningOutputs outputs: (_GestureOutputs<V1>, _GestureOutputs<V2>)
+    ) {
+        guard inputs.options.contains(.includeDebugOutput) else {
+            return
+        }
+        reallyWrap(
+            type,
+            kind: kind,
+            properties: properties,
+            inputs: inputs,
+            data: (outputs.0.debugData, outputs.1.debugData)
+        )
+    }
+
+    private func reallyWrap<T>(
+        _ type: T.Type,
+        kind: GestureDebug.Kind,
+        properties: Attribute<GestureDebug.Properties>?,
+        inputs: _GestureInputs,
+        data: (Attribute<GestureDebug.Data>?, Attribute<GestureDebug.Data>?)
+    ) {
+        preconditionFailure("TODO")
+    }
+}
+
+@_spi(ForSwiftUIOnly)
+extension GesturePhase {
+    @_spi(ForSwiftUIOnly)
+    package var descriptionWithoutValue: String {
+        @_spi(ForSwiftUIOnly)
+        get { preconditionFailure("TODO") }
+    }
+}
+
+extension GestureDebug.Data {
+    package func printTree() {
+        preconditionFailure("TODO")
+    }
+}
diff --git a/Sources/OpenSwiftUICore/Event/Gesture/GestureDependency.swift b/Sources/OpenSwiftUICore/Event/Gesture/GestureDependency.swift
new file mode 100644
index 000000000..1387b64b4
--- /dev/null
+++ b/Sources/OpenSwiftUICore/Event/Gesture/GestureDependency.swift
@@ -0,0 +1,112 @@
+//
+//  GestureDependency.swift
+//  OpenSwiftUICore
+//
+//  Status: Complete
+//  ID: 8687835E41FEE17B108D67665C1D2D0B (SwiftUICore)
+
+import OpenGraphShims
+
+// MARK: - GestureDependency [6.5.4]
+
+package enum GestureDependency {
+    case none
+    case pausedWhileActive
+    case pausedUntilFailed
+    case failIfActive
+}
+
+extension Gesture {
+    package func dependency(_ dependency: GestureDependency) -> some Gesture<Value> {
+        modifier(DependentGesture(dependency: dependency))
+    }
+}
+
+private struct DependentGesture<V>: GestureModifier {
+    typealias Value = V
+
+    typealias BodyValue = V
+
+    var dependency: GestureDependency
+
+    static func _makeGesture(
+        modifier: _GraphValue<Self>,
+        inputs: _GestureInputs,
+        body: (_GestureInputs) -> _GestureOutputs<Value>
+    ) -> _GestureOutputs<Value> {
+        var outputs = body(inputs)
+        outputs.phase = Attribute(DependentPhase(
+            modifier: modifier.value,
+            phase: outputs.phase,
+            inheritedPhase: inputs.inheritedPhase
+        ))
+        if inputs.preferences.contains(GestureDependency.Key.self) {
+            outputs.preferences[GestureDependency.Key.self] = modifier.value.dependency
+        }
+        return outputs
+    }
+}
+
+extension GestureDependency {
+    struct Key: PreferenceKey {
+        static var defaultValue: GestureDependency { .none }
+
+        static func reduce(value: inout GestureDependency, nextValue: () -> GestureDependency) {
+            let nextValue = nextValue()
+            let dict: [GestureDependency: Int] = [
+                .none: 0,
+                .pausedWhileActive: 1,
+                .pausedUntilFailed: 2,
+                .failIfActive: 3
+            ]
+            value = dict[value]! < dict[nextValue]! ? value : nextValue
+        }
+    }
+}
+
+private struct DependentPhase<V>: Rule {
+    @Attribute var modifier: DependentGesture<V>
+    @Attribute var phase: GesturePhase<V>
+    @Attribute var inheritedPhase: _GestureInputs.InheritedPhase
+
+    var value: GesturePhase<V> {
+        phase.applyingDependency(modifier.dependency, inheritedPhase: inheritedPhase)
+    }
+}
+
+extension GesturePhase {
+    func paused() -> GesturePhase {
+        switch self {
+        case .possible, .failed: self
+        case let .active(wrapped): .possible(wrapped)
+        case let .ended(wrapped): .possible(wrapped)
+        }
+    }
+
+    fileprivate func applyingDependency(_ dependency: GestureDependency, inheritedPhase: _GestureInputs.InheritedPhase) -> GesturePhase {
+        switch dependency {
+        case .none:
+            self
+        case .pausedWhileActive:
+            if inheritedPhase.contains(.active) {
+                paused()
+            } else {
+                self
+            }
+        case .pausedUntilFailed:
+            if inheritedPhase.contains(.failed) {
+                self
+            } else {
+                paused()
+            }
+        case .failIfActive:
+            if inheritedPhase.contains(.active) {
+                GesturePhase.failed
+            } else if inheritedPhase.contains(.failed) {
+                self
+            } else {
+                paused()
+            }
+        }
+    }
+}
diff --git a/Sources/OpenSwiftUICore/Event/Gesture/GestureGraph.swift b/Sources/OpenSwiftUICore/Event/Gesture/GestureGraph.swift
new file mode 100644
index 000000000..b587ac937
--- /dev/null
+++ b/Sources/OpenSwiftUICore/Event/Gesture/GestureGraph.swift
@@ -0,0 +1,83 @@
+//
+//  GestureGraph.swift
+//  OpenSwiftUICore
+//
+//  Status: WIP
+
+// MARK: - GestureGraphDelegate [6.5.4]
+
+package protocol GestureGraphDelegate: AnyObject {
+    func enqueueAction(_ action: @escaping () -> Void)
+}
+
+// MARK: - GestureGraph [6.5.4] [WIP]
+
+final package class GestureGraph: GraphHost, EventGraphHost, CustomStringConvertible {
+    package init(eventBindingManager: EventBindingManager) {
+        preconditionFailure("TODO")
+    }
+
+    final package let eventBindingManager: EventBindingManager
+
+    final package var description: String {
+        get { preconditionFailure("TODO") }
+    }
+
+    override final package func instantiateOutputs() {
+        preconditionFailure("TODO")
+    }
+
+    override final package func uninstantiateOutputs() {
+        preconditionFailure("TODO")
+    }
+
+    override final package func timeDidChange() {
+        preconditionFailure("TODO")
+    }
+
+    final package var responderNode: ResponderNode? {
+        get { preconditionFailure("TODO") }
+    }
+
+    final package var focusedResponder: ResponderNode? {
+        get { preconditionFailure("TODO") }
+    }
+
+    final package var nextGestureUpdateTime: Time {
+        get { preconditionFailure("TODO") }
+    }
+
+    final package func setInheritedPhase(_ phase: _GestureInputs.InheritedPhase) {
+        preconditionFailure("TODO")
+    }
+
+    final package func sendEvents(
+        _ events: [EventID: any EventType],
+        rootNode: ResponderNode,
+        at time: Time
+    ) -> GesturePhase<Void> {
+        preconditionFailure("TODO")
+    }
+
+    final package func resetEvents() {
+        preconditionFailure("TODO")
+    }
+
+    final package func enqueueAction(_ action: @escaping () -> Void) {
+        preconditionFailure("TODO")
+    }
+
+    final package func gestureCategory() -> GestureCategory? {
+        preconditionFailure("TODO")
+    }
+
+//    @objc deinit {
+//        preconditionFailure("TODO")
+//    }
+}
+
+extension GestureGraph {
+    package static var current: GestureGraph {
+        GraphHost.currentHost as! GestureGraph
+    }
+}
diff --git a/Sources/OpenSwiftUICore/Event/Gesture/GestureMask.swift b/Sources/OpenSwiftUICore/Event/Gesture/GestureMask.swift
new file mode 100644
index 000000000..087f3bfbb
--- /dev/null
+++ b/Sources/OpenSwiftUICore/Event/Gesture/GestureMask.swift
@@ -0,0 +1,35 @@
+//
+//  GestureMask.swift
+//  OpenSwiftUICore
+//
+//  Status: Complete
+
+// MARK: - GestureMask [6.5.4]
+
+/// Options that control how adding a gesture to a view affects other gestures
+/// recognized by the view and its subviews.
+@frozen
+@available(OpenSwiftUI_v1_0, *)
+public struct GestureMask: OptionSet {
+    public let rawValue: UInt32
+    
+    public init(rawValue: UInt32) {
+        self.rawValue = rawValue
+    }
+
+    /// Disable all gestures in the subview hierarchy, including the added
+    /// gesture.
+    public static let none: GestureMask = .init(rawValue: 0)
+
+    /// Enable the added gesture but disable all gestures in the subview
+    /// hierarchy.
+    public static let gesture: GestureMask = .init(rawValue: 1 << 0)
+
+    /// Enable all gestures in the subview hierarchy but disable the added
+    /// gesture.
+    public static let subviews: GestureMask = .init(rawValue: 1 << 1)
+
+    /// Enable both the added gesture as well as all other gestures on the view
+    /// and its subviews.
+    public static let all: GestureMask = [.gesture, .subviews]
+}
diff --git a/Sources/OpenSwiftUICore/Event/Gesture/GestureModifier.swift b/Sources/OpenSwiftUICore/Event/Gesture/GestureModifier.swift
new file mode 100644
index 000000000..b7bdc6b5c
--- /dev/null
+++ b/Sources/OpenSwiftUICore/Event/Gesture/GestureModifier.swift
@@ -0,0 +1,43 @@
+//
+//  GestureModifier.swift
+//  OpenSwiftUICore
+//
+//  Status: Blocked by makeDebuggableGesture
+
+package protocol GestureModifier {
+    associatedtype Value
+
+    associatedtype BodyValue
+
+    static func _makeGesture(
+        modifier: _GraphValue<Self>,
+        inputs: _GestureInputs,
+        body: (_GestureInputs) -> _GestureOutputs<BodyValue>
+    ) -> _GestureOutputs<Value>
+}
+
+extension Gesture {
+    package func modifier<T>(_ modifier: T) -> ModifierGesture<T, Self> where T: GestureModifier, Value == T.BodyValue {
+        ModifierGesture(content: self, modifier: modifier)
+    }
+}
+
+package struct ModifierGesture<ContentModifier, Content>: PrimitiveGesture
+    where ContentModifier: GestureModifier,
+          Content: Gesture,
+          ContentModifier.BodyValue == Content.Value {
+    var content: Content
+
+    var modifier: ContentModifier
+
+    package typealias Value = ContentModifier.Value
+
+    package static func _makeGesture(
+        gesture: _GraphValue<ModifierGesture<ContentModifier, Content>>,
+        inputs: _GestureInputs
+    ) -> _GestureOutputs<ContentModifier.Value> {
+        preconditionFailure("TODO")
+    }
+}
+
+extension ModifierGesture: PrimitiveDebuggableGesture {}
diff --git a/Sources/OpenSwiftUICore/Event/Gesture/GesturePhase.swift b/Sources/OpenSwiftUICore/Event/Gesture/GesturePhase.swift
new file mode 100644
index 000000000..d0ee3ada5
--- /dev/null
+++ b/Sources/OpenSwiftUICore/Event/Gesture/GesturePhase.swift
@@ -0,0 +1,97 @@
+//
+//  GesturePhase.swift
+//  OpenSwiftUICore
+//
+//  Status: Complete
+
+// MARK: - GesturePhase [6.5.4]
+
+@_spi(ForOnlySwiftUIOnly)
+@available(OpenSwiftUI_v6_0, *)
+public enum GesturePhase<Wrapped> {
+    case possible(Wrapped?)
+    case active(Wrapped)
+    case ended(Wrapped)
+    case failed
+}
+
+@_spi(ForOnlySwiftUIOnly)
+@available(*, unavailable)
+extension GesturePhase: Sendable {}
+
+@_spi(ForOnlySwiftUIOnly)
+extension GesturePhase: Equatable where Wrapped: Equatable {}
+
+@_spi(ForOnlySwiftUIOnly)
+extension GesturePhase {
+    package var unwrapped: Wrapped? {
+        switch self {
+        case let .possible(value): value
+        case let .active(value): value
+        case let .ended(value): value
+        case .failed: nil
+        }
+    }
+
+    package func map<T>(_ body: (Wrapped) -> T) -> GesturePhase<T> {
+        switch self {
+        case let .possible(value): .possible(value.map(body))
+        case let .active(value): .active(body(value))
+        case let .ended(value): .ended(body(value))
+        case .failed: .failed
+        }
+    }
+
+    package func withValue<T>(_ value: @autoclosure () -> T) -> GesturePhase<T> {
+        map { _ in value() }
+    }
+
+    package var isPossible: Bool {
+        guard case .possible = self else {
+            return false
+        }
+        return true
+    }
+
+    package var isActive: Bool {
+        guard case .active = self else {
+            return false
+        }
+        return true
+    }
+
+    package var isTerminal: Bool {
+        switch self {
+        case .possible, .active: false
+        case .ended, .failed: true
+        }
+    }
+
+    package var isEnded: Bool {
+        guard case .ended = self else {
+            return false
+        }
+        return true
+    }
+
+    package var isFailed: Bool {
+        guard case .failed = self else {
+            return false
+        }
+        return true
+    }
+}
+
+// MARK: - GesturePhase + Defaultable [6.5.4]
+
+@_spi(ForOnlySwiftUIOnly)
+extension GesturePhase: Defaultable {
+    package static var defaultValue: GesturePhase<Wrapped> { .failed }
+}
+
+// MARK: - GestureCategory + Defaultable [6.5.4]
+
+@_spi(ForOnlySwiftUIOnly)
+extension GestureCategory: Defaultable {
+    package static var defaultValue: GestureCategory { .magnify }
+}
diff --git a/Sources/OpenSwiftUICore/Event/Gesture/GestureViewModifier.swift b/Sources/OpenSwiftUICore/Event/Gesture/GestureViewModifier.swift
new file mode 100644
index 000000000..2a96ead12
--- /dev/null
+++ b/Sources/OpenSwiftUICore/Event/Gesture/GestureViewModifier.swift
@@ -0,0 +1,275 @@
+//
+//  GestureViewModifier.swift
+//  OpenSwiftUICore
+//
+//  Status: WIP
+//  ID: 9DF46B4E935FF03A55FF3DDFB0B1FF2B (SwiftUICore)
+
+package import OpenGraphShims
+
+// MARK: - GestureViewModifier [6.5.4]
+
+package protocol GestureViewModifier: MultiViewModifier, PrimitiveViewModifier {
+    associatedtype ContentGesture: Gesture
+    
+    associatedtype Combiner: GestureCombiner = DefaultGestureCombiner
+    
+    var gesture: Self.ContentGesture { get }
+    
+    var name: String? { get }
+    
+    var gestureMask: GestureMask { get }
+}
+
+// MARK: - GestureResponderExclusionPolicy [6.5.4]
+
+@_spi(ForOpenSwiftUIOnly)
+@available(OpenSwiftUI_v6_0, *)
+public enum GestureResponderExclusionPolicy {
+    case `default`
+    
+    case highPriority
+    
+    case simultaneous
+}
+
+@_spi(ForOpenSwiftUIOnly)
+@available(*, unavailable)
+extension GestureResponderExclusionPolicy: Sendable {}
+
+// MARK: - GestureCombiner [6.5.4]
+
+package protocol GestureCombiner {
+    associatedtype Result: Gesture /*where Result.Value == ()*/
+
+    static func combine(
+        _ gesture1: AnyGesture<Void>,
+        _ gesture2: AnyGesture<Void>
+    ) -> Self.Result
+    
+    static var exclusionPolicy: GestureResponderExclusionPolicy { get }
+}
+
+// MARK: - GestureViewModifier + Default Implementation [6.5.4]
+
+extension GestureViewModifier {
+    package var name: String? { nil }
+    
+    package var gestureMask: GestureMask { .all }
+    
+    package static func makeView(
+        modifier: _GraphValue<Self>,
+        inputs: _ViewInputs,
+        body: @escaping (_Graph, _ViewInputs) -> _ViewOutputs
+    ) -> _ViewOutputs {
+        var outputs = body(_Graph(), inputs)
+        if inputs.preferences.contains(ViewRespondersKey.self) {
+            let filter = GestureFilter(
+                children: outputs.viewResponders(),
+                modifier: modifier.value,
+                inputs: inputs,
+                viewSubgraph: .current!
+            )
+            outputs.preferences[ViewRespondersKey.self] = Attribute(filter)
+        }
+        let provider = inputs.gestureAccessibilityProvider
+        provider.makeGesture(
+            mask: modifier.value[keyPath: \.gestureMask],
+            inputs: inputs,
+            outputs: &outputs
+        )
+        return outputs
+    }
+    
+    package static func _makeView(
+        modifier: _GraphValue<Self>,
+        inputs: _ViewInputs,
+        body: @escaping (_Graph, _ViewInputs) -> _ViewOutputs
+    ) -> _ViewOutputs {
+        makeView(modifier: modifier, inputs: inputs, body: body)
+    }
+}
+
+// MARK: - GestureFilter [6.5.4] [Blocked by ViewResponder]
+
+private struct GestureFilter<Modifier>: StatefulRule where Modifier: GestureViewModifier {
+    typealias Value = [ViewResponder]
+    
+    @Attribute var children: [ViewResponder]
+    
+    @Attribute var modifier: Modifier
+    
+    var inputs: _ViewInputs
+    
+    var viewSubgraph: Subgraph
+    
+    lazy var responder: GestureResponder<Modifier> = {
+        viewSubgraph.apply {
+            GestureResponder(
+                modifier: $modifier,
+                inputs: inputs
+            )
+        }
+    }()
+    
+    mutating func updateValue() {
+        let responder = responder
+        let (children, childrenChanged) = $children.changedValue()
+        if childrenChanged {
+            // responder.children = children
+        }
+        if !hasValue {
+            // value = [self.responder]
+        }
+    }
+}
+
+// MARK: - AddGestureModifier [6.5.4]
+
+package struct AddGestureModifier<T>: GestureViewModifier where T: Gesture {
+    package var gesture: T
+    package var name: String?
+    package var gestureMask: GestureMask
+    
+    package init(
+        _ gesture: T,
+        name: String? = nil,
+        gestureMask: GestureMask = .all
+    ) {
+        self.gesture = gesture
+        self.name = name
+        self.gestureMask = gestureMask
+    }
+    
+    package typealias Combiner = DefaultGestureCombiner
+
+    package typealias ContentGesture = T
+}
+
+package struct DefaultGestureCombiner: GestureCombiner {
+    package typealias Base = ExclusiveGesture<AnyGesture<Void>, AnyGesture<Void>>
+
+    package typealias Result = _MapGesture<DefaultGestureCombiner.Base, Int>
+
+    package static var exclusionPolicy: GestureResponderExclusionPolicy { .default }
+
+    package static func combine(
+        _ first: AnyGesture<Void>,
+        _ second: AnyGesture<Void>
+    ) -> DefaultGestureCombiner.Result {
+        preconditionFailure("TODO")
+    }
+}
+
+package protocol AnyGestureContainingResponder: ViewResponder {
+    var viewSubgraph: Subgraph { get }
+    var eventSources: [any EventBindingSource] { get }
+    var gestureType: any Any.Type { get }
+    var isValid: Bool { get }
+    
+    func detachContainer()
+}
+
+package protocol AnyGestureResponder: AnyGestureContainingResponder {
+    var inputs: _ViewInputs { get }
+    var childSubgraph: Subgraph? { get set }
+    var childViewSubgraph: Subgraph? { get set }
+    var exclusionPolicy: GestureResponderExclusionPolicy { get }
+    var gestureGraph: GestureGraph { get }
+    
+    func makeSubviewsGesture(inputs: _GestureInputs) -> _GestureOutputs<Void>
+}
+
+extension AnyGestureResponder {
+    package var exclusionPolicy: GestureResponderExclusionPolicy {
+        get { preconditionFailure("TODO") }
+    }
+    
+    package func makeSubviewsGesture(inputs: _GestureInputs) -> _GestureOutputs<Void> {
+        preconditionFailure("TODO")
+    }
+    
+    package func makeWrappedGesture(
+        inputs: _GestureInputs,
+        makeChild: (_GestureInputs) -> _GestureOutputs<Void>
+    ) -> _GestureOutputs<Void> { preconditionFailure("TODO") }
+    
+    package var label: String? {
+        get { preconditionFailure("TODO") }
+    }
+    
+    package var isCancellable: Bool {
+        get { preconditionFailure("TODO") }
+    }
+    
+    package var requiredTapCount: Int? {
+        get { preconditionFailure("TODO") }
+    }
+    
+    package func canPrevent(
+        _ other: ViewResponder,
+        otherExclusionPolicy: GestureResponderExclusionPolicy
+    ) -> Bool { preconditionFailure("TODO") }
+    
+    package func shouldRequireFailure(of other: any AnyGestureResponder) -> Bool {
+        preconditionFailure("TODO")
+    }
+}
+
+private class GestureResponder<Modifier>/*: AnyGestureResponder where Modifier: GestureViewModifier*/ {
+    init(modifier: Attribute<Modifier>, inputs: _ViewInputs) {
+        preconditionFailure("TODO")
+    }
+}
+
+// MARK: - GestureAccessibilityProvider [6.5.4]
+
+package protocol GestureAccessibilityProvider {
+    static func makeGesture(
+        mask: @autoclosure () -> Attribute<GestureMask>,
+        inputs: _ViewInputs,
+        outputs: inout _ViewOutputs
+    )
+}
+
+private struct GestureAccessibilityProviderKey: GraphInput {
+    static let defaultValue: (any GestureAccessibilityProvider.Type) = EmptyGestureAccessibilityProvider.self
+}
+
+struct EmptyGestureAccessibilityProvider: GestureAccessibilityProvider {
+    static func makeGesture(
+        mask: @autoclosure () -> Attribute<GestureMask>,
+        inputs: _ViewInputs,
+        outputs: inout _ViewOutputs
+    ) {
+    }
+}
+
+extension _GraphInputs {
+    package var gestureAccessibilityProvider: (any GestureAccessibilityProvider.Type) {
+        get { self[GestureAccessibilityProviderKey.self] }
+        set { self[GestureAccessibilityProviderKey.self] = newValue }
+    }
+}
+
+extension _ViewInputs {
+    package var gestureAccessibilityProvider: (any GestureAccessibilityProvider.Type) {
+        get { base.gestureAccessibilityProvider }
+        set { base.gestureAccessibilityProvider = newValue }
+    }
+}
+
+// MARK: - Optional: Gesture
+
+//extension Optional: Gesture where Wrapped: Gesture {
+//    public typealias Value = Wrapped.Value
+//    
+//    public static func _makeGesture(
+//        gesture: _GraphValue<Optional<Wrapped>>,
+//        inputs: _GestureInputs
+//    ) -> _GestureOutputs<Wrapped.Value> { preconditionFailure("TODO") }
+//    
+//    public typealias Body = Never
+//}
+//
+//extension Optional: PrimitiveGesture where Wrapped: Gesture {}
diff --git a/Sources/OpenSwiftUICore/Test/TestApp.swift b/Sources/OpenSwiftUICore/Test/TestApp.swift
index 01981aff3..74cd2e470 100644
--- a/Sources/OpenSwiftUICore/Test/TestApp.swift
+++ b/Sources/OpenSwiftUICore/Test/TestApp.swift
@@ -6,6 +6,8 @@
 //  ID: A519B5B95CA8FF4E3445832668F0B2D2 (SwiftUI)
 //  ID: E1A97A5CD5A5467396F8BB461CB26984 (SwiftUICore)
 
+package import Foundation
+
 // MARK: _TestApp [6.4.41] [WIP for defaultEnvironment]
 
 @available(OpenSwiftUI_v1_0, *)
@@ -105,3 +107,16 @@ public struct _TestApp {
         }
     }
 }
+
+@available(*, unavailable)
+extension _TestApp: Sendable {}
+
+extension _TestApp {
+    package static func date(for time: Time) -> Date {
+        Date.now
+    }
+
+    package static var dateIsSynchronizedWithTime: Bool {
+        false
+    }
+}
diff --git a/Sources/OpenSwiftUICore/Util/Defaultable.swift b/Sources/OpenSwiftUICore/Util/Defaultable.swift
index 93eb99a46..1df77ec37 100644
--- a/Sources/OpenSwiftUICore/Util/Defaultable.swift
+++ b/Sources/OpenSwiftUICore/Util/Defaultable.swift
@@ -1,11 +1,13 @@
 //
 //  Defaultable.swift
-//  OpenSwiftUI
+//  OpenSwiftUICore
 //
-//  Audited for iOS 15.5
 //  Status: Complete
 
-protocol Defaultable {
+// MARK: - Defaultable [6.5.4]
+
+package protocol Defaultable {
     associatedtype Value
+
     static var defaultValue: Value { get }
 }
diff --git a/Sources/OpenSwiftUICore/View/Input/ViewInputs.swift b/Sources/OpenSwiftUICore/View/Input/ViewInputs.swift
index f1d5a42ac..0b5a0b348 100644
--- a/Sources/OpenSwiftUICore/View/Input/ViewInputs.swift
+++ b/Sources/OpenSwiftUICore/View/Input/ViewInputs.swift
@@ -2,8 +2,8 @@
 //  ViewInputs.swift
 //  OpenSwiftUICore
 //
-//  ID: C38EF38637B6130AEFD462CBD5EAC727 (SwiftUICore)
 //  Status: Complete
+//  ID: C38EF38637B6130AEFD462CBD5EAC727 (SwiftUICore)
 
 #if !canImport(Darwin)
 package import Foundation
diff --git a/Sources/OpenSwiftUICore/View/Debug/ViewDebug.swift b/Sources/OpenSwiftUICore/View/ViewDebug.swift
similarity index 100%
rename from Sources/OpenSwiftUICore/View/Debug/ViewDebug.swift
rename to Sources/OpenSwiftUICore/View/ViewDebug.swift
diff --git a/Sources/OpenSwiftUI_SPI/Util/ProtocolDescriptor.c b/Sources/OpenSwiftUI_SPI/Util/ProtocolDescriptor.c
index 50ad9d9a6..253291226 100644
--- a/Sources/OpenSwiftUI_SPI/Util/ProtocolDescriptor.c
+++ b/Sources/OpenSwiftUI_SPI/Util/ProtocolDescriptor.c
@@ -22,3 +22,17 @@ const void *$s15OpenSwiftUICore12ViewModifierMp;
 const void *_OpenSwiftUI_viewModifierProtocolDescriptor(void) {
     return &$s15OpenSwiftUICore12ViewModifierMp;
 }
+
+OPENSWIFTUI_EXPORT
+const void *$s15OpenSwiftUICore7GestureMp;
+
+const void *_OpenSwiftUI_gestureProtocolDescriptor(void) {
+    return &$s15OpenSwiftUICore7GestureMp;
+}
+
+OPENSWIFTUI_EXPORT
+const void *$s15OpenSwiftUICore15GestureModifierMp;
+
+const void *_OpenSwiftUI_gestureModifierProtocolDescriptor(void) {
+    return &$s15OpenSwiftUICore15GestureModifierMp;
+}
diff --git a/Sources/OpenSwiftUI_SPI/Util/ProtocolDescriptor.h b/Sources/OpenSwiftUI_SPI/Util/ProtocolDescriptor.h
index 32c4c5d33..14effe173 100644
--- a/Sources/OpenSwiftUI_SPI/Util/ProtocolDescriptor.h
+++ b/Sources/OpenSwiftUI_SPI/Util/ProtocolDescriptor.h
@@ -1,9 +1,6 @@
 //
 //  ProtocolDescriptor_h
-//  OpenSwiftUI
-//
-//  Audited for iOS 15.5
-//  Status: WIP
+//  OpenSwiftUI_SPI
 
 #ifndef ProtocolDescriptor_h
 #define ProtocolDescriptor_h
@@ -18,6 +15,12 @@ const void *_OpenSwiftUI_viewProtocolDescriptor(void);
 OPENSWIFTUI_EXPORT
 const void *_OpenSwiftUI_viewModifierProtocolDescriptor(void);
 
+OPENSWIFTUI_EXPORT
+const void *_OpenSwiftUI_gestureProtocolDescriptor(void);
+
+OPENSWIFTUI_EXPORT
+const void *_OpenSwiftUI_gestureModifierProtocolDescriptor(void);
+
 OPENSWIFTUI_ASSUME_NONNULL_END
 
 #endif /* ProtocolDescriptor_h */