I have this code below, how do I remove the scroll bounce in only one horizontal subview located in the body of SphereGroupSectionView without affecting the top hierarchy of the View

import SwiftUI
import EvoUIKit

@MainActor
protocol SphereGroupsViewModeling: ObservableObject {
    associatedtype ViewState

    var viewState: ViewState { get }
    func onAppear()
}

struct SphereGroupsView<ViewModel: SphereGroupsViewModeling>: View where ViewModel.ViewState == SphereGroupsVM.ViewState {

    struct HeaderDisplayValues {
        var opacity: Double = 1.0
        var segmentYOffset: CGFloat = 0.0
        var height: CGFloat = 90.0
    }

    @ObservedObject
    var viewModel: ViewModel

    @State
    private var isScrolling: Bool = false

    @State
    private var selectedSegment: SegmentHeaderView.Segment = .conscious

    @State
    private var segments: [SegmentHeaderView.Segment] = .segments

    @State
    private var isInfoExpanded: Bool = false

    @State
    private var scrollYoffset: CGFloat = .zero

    @State
    private var headerValues: HeaderDisplayValues = .init()

    init(viewModel: ViewModel) {
        self.viewModel = viewModel
    }

    var body: some View {
        VStack {
            content()
        }
        .navigationBarConfig { NavigationBarConfig.Item.hideLeading }
        .frame(maxWidth: .infinity, maxHeight: .infinity)
        .background(VideoBackgroundView())
        .overlay(alignment: .top, content: headerView)
        .compositingGroup()
        .onAppear(perform: viewModel.onAppear)
    }

    @ViewBuilder
    private func content() -> some View {
        switch viewModel.viewState {
        case .loading:
            EmptyView()
        case .content(let profile): EmptyView()
            ScrollViewReader { scroll in
                ScrollView(showsIndicators: false) {
                    VStack {
                        SegmentInfoView(
                            isInfoExpanded: $isInfoExpanded,
                            subtitle: selectedSegment.subtitle
                        )
                        .padding(.top, 112)
                        .padding(.horizontal, 24)

                        ForEach(profile.sphereGroups, id: \.title) { group in
                            SphereGroupSectionView(
                                title: group.title,
                                segments: segments,
                                selectedSegmentTitle: selectedSegment.title,
                                spheres: group.spheres,
                                onTalent: {
                                    $0.broadcast()
                                }
                            )
                        }
                    }
                    .frame(maxWidth: .infinity, maxHeight: .infinity)
                    .background(scrollCoordinatorView())
                    .padding(.bottom, 80)
                }
                .coordinateSpace(name: "scroll")
            }
        }
    }

    @ViewBuilder
    private func scrollCoordinatorView() -> some View {
        GeometryReader { proxy in
            Color.clear
                .frame(maxWidth: .infinity, maxHeight: .infinity)
                .onChange(of: proxy.frame(in: .named("scroll")).minY) { newValue in
                    scrollYoffset = newValue

                    adjustedYOffset(scrollYOffset: newValue)

                    withAnimation {
                        isScrolling = newValue < 0
                    }
                }
        }
    }

    private func adjustedYOffset(scrollYOffset: CGFloat) {
        let minYOffset: CGFloat = 35
        let maxYOffset: CGFloat = 90

        let minScrollOffset: CGFloat = -80
        let maxScrollOffset: CGFloat = 0

        let clampedOffset = min(max(scrollYOffset, minScrollOffset), maxScrollOffset)


        let headerHeightValue = minYOffset + ((clampedOffset + 80) / 80) * (maxYOffset - minYOffset)
        let opacity = (headerHeightValue - minYOffset) / (maxYOffset - minYOffset)

        let segmentYOffSet = -25 + ((headerHeightValue - minYOffset) / (maxYOffset - minYOffset)) * 25

        headerValues.height = headerHeightValue
        headerValues.opacity = opacity
        headerValues.segmentYOffset = segmentYOffSet
    }

    @ViewBuilder
    private func headerView() -> some View {
        Color.white
            .opacity(isScrolling ? 0.08 : 0)
            .background(BackdropBlurView(radius: 8))
            .roundedCorners([.bottomLeft, .bottomRight])
            .edgesIgnoringSafeArea(.top)
            .frame(height: 0)
            .safeAreaInset(edge: .top) {
                VStack {
                    Text(S.myTalent.localized)
                        .typography(.H1.bold)
                        .foregroundColor(.palette.primary800)
                        .frame(maxWidth: .infinity, alignment: .leading)
                        .opacity(headerValues.opacity)
                        .padding(.top, 16)
                        .padding(.bottom, 8)

                    HStack(spacing: 6) {
                        ForEach(segments, id: \.title) {
                            SegmentHeaderView(
                                selectedSegment: $selectedSegment,
                                segment: $0
                            )
                        }
                    }
                    .padding(.bottom, 8)
                    .offset(y: headerValues.segmentYOffset)
                }
                .frame(height: headerValues.height)
                .padding(.horizontal, 24)
            }
    }

    private func onExpandInfo() {
        withAnimation(.spring) {
            isInfoExpanded.toggle()
        }
    }
}

private extension SegmentHeaderView.Segment {
    static let unconscious: SegmentHeaderView.Segment = .init(
        title: S.Unconscious.title.localized,
        subtitle: S.Unconscious.subtitle.localized
    )

    static let conscious: SegmentHeaderView.Segment = .init(
        title: S.Conscious.title.localized,
        subtitle: S.Conscious.subtitle.localized
    )
}

extension Array where Element == SegmentHeaderView.Segment {
    static let segments: [SegmentHeaderView.Segment] = [.conscious, .unconscious]
}

import SwiftUI

struct SphereGroupSectionView: View {

    typealias Segment = SegmentHeaderView.Segment

    let title: String
    let segments: [Segment]
    let selectedSegmentTitle: String
    let spheres: [Sphere]
    let onTalent: (Talent) -> Void

    var groupedSpheres: [[Sphere]] {
        stride(from: 0, to: spheres.count, by: 2).map {
            Array(spheres[$0..<min($0 + 2, spheres.count)])
        }
    }

    @State
    private var currentSegmentIndex: Int = 0

    @State
    private var isTrailingBrickShown: Bool = false

    var body: some View {
        VStack(spacing: 0) {
            Text(title)
                .typography(.H2.regular)
                .foregroundColor(.palette.primary800)
                .frame(maxWidth: .infinity, alignment: .leading)
                .padding(.top, 24)
                .padding(.bottom, 16)
                .padding(.horizontal, 24)

            ScrollViewReader { scroll in
                VStack(spacing: 15) {
                    ForEach(Array(groupedSpheres.enumerated()), id: \.offset) { sectionIndex, spheres in
                        ScrollView(.horizontal, showsIndicators: false) {
                            HStack(spacing: 15) {
                                ForEach(Array(spheres.enumerated()), id: \.offset) { itemIndex, sphere in
                                    Button(action: { onTalent(sphere.talent) }) {
                                        SphereView(sphere: sphere)
                                            .frame(width: 255, height: 88)
                                            .background(
                                                background(
                                                    color: sphere.talent.color,
                                                    indexPath: IndexPath(item: itemIndex, section: sectionIndex)
                                                )
                                            )
                                            .overlay {
                                                RoundedRectangle(cornerRadius: 16)
                                                    .stroke(
                                                        stroke(for: sphere.talent.color, index: itemIndex),
                                                        lineWidth: 1.5
                                                    )
                                            }
                                            .clipShape(
                                                .rect(
                                                    topLeadingRadius: itemIndex == 1 ? 16 : 0,
                                                    bottomLeadingRadius: itemIndex == 0 ? 16 : 0,
                                                    bottomTrailingRadius: itemIndex == 1 ? 16 : 0,
                                                    topTrailingRadius: itemIndex == 0 ? 16 : 0
                                                )
                                            )
                                            .id(IndexPath(item: itemIndex, section: sectionIndex))
                                    }
                                    .buttonStyle(.plain)
                                    .onChange(of: currentSegmentIndex) { index in
                                        withAnimation {
                                            scroll.scrollTo(IndexPath(item: index, section: sectionIndex))
                                        }
                                    }
                                }
                            }
                            .background(scrollCoordinatorView())
                        }
                        .coordinateSpace(name: "scroll")
                        .onChange(
                            of: segments.firstIndex(where: { $0.title == selectedSegmentTitle })!
                        ) { index in
                            withAnimation {
                                currentSegmentIndex = index
                            }
                        }
                    }
                }
            }
        }
    }

    @ViewBuilder
    private func stroke(for color: Color, index: Int) -> some ShapeStyle {
        withAnimation(.spring) {
            if isTrailingBrickShown && index == 1 {
                color.opacity(0.0)
            } else if isTrailingBrickShown && index == 0 {
                color.opacity(1.0)
            } else if !isTrailingBrickShown && index == 0 {
                color.opacity(0.0)
            } else {
                color.opacity(1.0)
            }
        }
    }

    @ViewBuilder
    private func scrollCoordinatorView() -> some View {
        GeometryReader { proxy in
            Color.clear
                .frame(maxWidth: .infinity, maxHeight: .infinity)
                .onChange(of: proxy.frame(in: .named("scroll")).midX) { newValue in
                    guard newValue <= (UIScreen.main.bounds.width / 2), !isTrailingBrickShown else { return }

                    withAnimation(.spring) {
                        isTrailingBrickShown.toggle()
                    }
                }
                .onChange(of: proxy.frame(in: .named("scroll")).midX) { newValue in
                    guard newValue > (UIScreen.main.bounds.width / 2), isTrailingBrickShown else { return }

                    withAnimation(.spring) {
                        isTrailingBrickShown.toggle()
                    }
                }
        }
    }

    @ViewBuilder
    private func background(color: Color, indexPath: IndexPath) -> some View {
        ZStack {
            withAnimation(.spring) {
                if isTrailingBrickShown && indexPath.item == 1 {
                    color.opacity(1.0)
                } else if isTrailingBrickShown && indexPath.item == 0 {
                    color.opacity(0.1)
                } else if !isTrailingBrickShown && indexPath.item == 0 {
                    color.opacity(1.0)
                } else {
                    color.opacity(0.1)
                }
            }
        }
    }
}

extension View {
    func disableBounce() -> some View {
        modifier(DisableBouncesModifier())
    }

    func enableBounce() -> some View {
        modifier(EnableBouncesModifier())
    }
}

private struct EnableBouncesModifier: ViewModifier {
    func body(content: Content) -> some View {
        content
            .onAppear {
                UIScrollView.appearance().bounces = true
            }
            .onDisappear {
                UIScrollView.appearance().bounces = false
            }
    }
}

private struct DisableBouncesModifier: ViewModifier {
    func body(content: Content) -> some View {
        content
            .onAppear {
                UIScrollView.appearance().bounces = false
            }
            .onDisappear {
                UIScrollView.appearance().bounces = true
            }
    }
}

#Preview {
    SphereGroupSectionView(
        title: "",
        segments: [],
        selectedSegmentTitle: "", 
        spheres: [], 
        onTalent: { _ in }
    )
}