struct PoseClient {
    var fetch: @Sendable (Data) async throws -> [Pose]
}

let keyWindow = UIApplication.shared.windows.filter { $0.isKeyWindow }.first

let windowScene = UIApplication.shared.connectedScenes.first as? UIWindowScene
let window = windowScene?.windows.first

func downSample(size: CGSize, scale: CGFloat = UIScreen.main.scale) -> UIImage {
        let imageSouceOption = [kCGImageSourceShouldCache: false] as CFDictionary
        let data = self.jpegData(compressionQuality: 1)! as CFData
        let imageSource = CGImageSourceCreateWithData(data, imageSouceOption)!

        let maxPixel = max(size.width, size.height) * scale
        let downSampleOptions = [
            kCGImageSourceCreateThumbnailFromImageAlways: true,
            kCGImageSourceShouldCacheImmediately: true,
            kCGImageSourceCreateThumbnailWithTransform: true,
            kCGImageSourceThumbnailMaxPixelSize: maxPixel
        ] as CFDictionary

        let downSampledImage = CGImageSourceCreateThumbnailAtIndex(imageSource, 0, downSampleOptions)!
        let newImage = UIImage(cgImage: downSampledImage)

        return newImage
    }

struct PoseState {
    var imagePickerPresented = false
    // ...
}

enum PoseAction {
    case showImagePicker
    // ...
}

let poseReducer = Reducer<PoseState, PoseAction, PoseEnvironment> { state, action, _ in
    switch action {
    case .showImagePicker:
        state.imagePickerPresented.toggle()
        return .none
    }
}

struct PoseCore: ReducerProtocol {
    struct PoseState: Equatable {
        var imagePickerPresented = false
        // ...
    }

    enum PoseAction {
        case showImagePicker
        // ...
    }
    
    func reduce(into state: inout State, action: Action) -> EffectTask<Action> {
        switch action {
        case .showImagePicker:
            state.imagePickerPresented.toggle()
            return .none
        }
    }
}

poseReducer
    .optional()
    .pullback(
        state: \.optionalPose,
        action: /RootAction.optionalPose,
        environment: { _ in PoseEnvironment() }
    )

var body: some ReducerProtocol<State, Action> {
    Reduce { state, action in
      // Parent logic
    }
    .ifLet(\.feature, action: /Action.feature) {
      Feature(date: self.date)
    }
}

let poseReducer = Reducer<PoseState, PoseAction, PoseEnvironment> { state, action, _ in
    switch action {
    case .binding(_):
        return .none
        
    case .showImagePicker:
        state.imagePickerPresented.toggle()
        return .none
    }
}
.binding()

var body: some ReducerProtocol<State, Action> {
    Reduce { state, action in
         switch action {
         case .showImagePicker:
            state.imagePickerPresented.toggle()
            return .none
        }       
    }
    BindingReducer()
}

struct UploadCore: ReducerProtocol {
  let poseClient: PoseClient
  // ...
}

struct UploadCore: ReducerProtocol {
    @Dependency (\.poseClient) var poseClient   
    // ...
}

 return Path {
    $0.move(to: CGPoint(x: 0, y: 0))
    $0.addLine(to: CGPoint(x: width * 0.3, y: 0))

    $0.addCurve(to: CGPoint(x: rect.midX, y: height),
                control1: CGPoint(x: rect.midX * 0.85, y: rect.minY),
                control2: CGPoint(x: rect.midX * 0.75, y: height))

    $0.addCurve(to: CGPoint(x: width * 0.7, y: 0),
                control1: CGPoint(x: rect.midX * 1.25, y: height),
                control2: CGPoint(x: rect.midX * 1.15, y: rect.minY))
}

TabView()
    .onAppear {
        UITabBar.appearance().backgroundImage = UIImage()
        UITabBar.appearance().isTranslucent = true
    }

extension UIImage {
     func addDat() -> UIImage {
        UIGraphicsBeginImageContextWithOptions(self.size, true, 0)
         self.draw(at: CGPointMake(0, 0))
         
         let context = UIGraphicsGetCurrentContext()!
         context.addLine(to: CGPoint(x: keypoints[leftEye] + 2, y: keypoints[leftEye + 1]))
         context.addEllipse(in: CGRect(x: keypoints[leftEye], y: keypoints[leftEye + 1], width: width, height: height))
         context.move(to: CGPoint(x: keypoints[leftEye], y: keypoints[leftEye + 1] + 4))
         // ...
         
         let image = UIGraphicsGetImageFromCurrentImageContext()!
         UIGraphicsEndImageContext()
         return image
     }   
}