MyApp/
├── MyApp/
│   ├── App/
│   │   ├── MyAppApp.swift
│   │   └── ContentView.swift
│   ├── Features/
│   │   └── FeatureName/
│   │       ├── Views/
│   │       ├── ViewModels/
│   │       └── Models/
│   ├── Core/
│   │   ├── Extensions/
│   │   ├── Utilities/
│   │   └── Services/
│   ├── Resources/
│   │   └── Assets.xcassets
│   └── Info.plist
├── MyAppTests/
├── MyAppUITests/
└── MyApp.xcodeproj

// MyAppApp.swift
import SwiftUI

@main
struct MyAppApp: App {
    @StateObject private var appState = AppState()

    var body: some Scene {
        WindowGroup {
            ContentView()
                .environmentObject(appState)
        }
    }
}

// Features/Home/Views/HomeView.swift
import SwiftUI

struct HomeView: View {
    @StateObject private var viewModel = HomeViewModel()
    @State private var searchText = ""

    var body: some View {
        NavigationStack {
            List {
                ForEach(viewModel.filteredItems) { item in
                    NavigationLink(value: item) {
                        ItemRowView(item: item)
                    }
                }
            }
            .navigationTitle("Home")
            .searchable(text: $searchText)
            .onChange(of: searchText) { _, newValue in
                viewModel.search(query: newValue)
            }
            .navigationDestination(for: Item.self) { item in
                ItemDetailView(item: item)
            }
            .refreshable {
                await viewModel.refresh()
            }
        }
    }
}

#Preview {
    HomeView()
}

// Features/Home/ViewModels/HomeViewModel.swift
import Foundation
import Combine

@MainActor
final class HomeViewModel: ObservableObject {
    @Published private(set) var items: [Item] = []
    @Published private(set) var filteredItems: [Item] = []
    @Published private(set) var isLoading = false
    @Published private(set) var error: Error?

    private let itemService: ItemServiceProtocol
    private var cancellables = Set<AnyCancellable>()

    init(itemService: ItemServiceProtocol = ItemService()) {
        self.itemService = itemService
        setupBindings()
        Task { await loadItems() }
    }

    private func setupBindings() {
        $items
            .assign(to: &$filteredItems)
    }

    func loadItems() async {
        isLoading = true
        error = nil

        do {
            items = try await itemService.fetchItems()
        } catch {
            self.error = error
        }

        isLoading = false
    }

    func search(query: String) {
        if query.isEmpty {
            filteredItems = items
        } else {
            filteredItems = items.filter { $0.title.localizedCaseInsensitiveContains(query) }
        }
    }

    func refresh() async {
        await loadItems()
    }
}

// Core/ViewModifiers/CardStyle.swift
import SwiftUI

struct CardStyle: ViewModifier {
    var cornerRadius: CGFloat = 12
    var shadowRadius: CGFloat = 4

    func body(content: Content) -> some View {
        content
            .background(Color(.systemBackground))
            .cornerRadius(cornerRadius)
            .shadow(color: .black.opacity(0.1), radius: shadowRadius, x: 0, y: 2)
    }
}

extension View {
    func cardStyle(cornerRadius: CGFloat = 12, shadowRadius: CGFloat = 4) -> some View {
        modifier(CardStyle(cornerRadius: cornerRadius, shadowRadius: shadowRadius))
    }
}

// App/Router.swift
import SwiftUI

enum Route: Hashable {
    case home
    case detail(id: String)
    case settings
    case profile(userId: String)
}

final class Router: ObservableObject {
    @Published var path = NavigationPath()

    func navigate(to route: Route) {
        path.append(route)
    }

    func navigateBack() {
        path.removeLast()
    }

    func navigateToRoot() {
        path.removeLast(path.count)
    }

    func handle(url: URL) -> Bool {
        guard let components = URLComponents(url: url, resolvingAgainstBaseURL: true),
              let host = components.host else {
            return false
        }

        switch host {
        case "detail":
            if let id = components.queryItems?.first(where: { $0.name == "id" })?.value {
                navigate(to: .detail(id: id))
                return true
            }
        case "profile":
            if let userId = components.queryItems?.first(where: { $0.name == "userId" })?.value {
                navigate(to: .profile(userId: userId))
                return true
            }
        default:
            break
        }

        return false
    }
}

# Build for simulator
xcodebuild -scheme MyApp -destination 'platform=iOS Simulator,name=iPhone 15 Pro' build

# Build for device
xcodebuild -scheme MyApp -destination 'generic/platform=iOS' build

# Archive for distribution
xcodebuild -scheme MyApp -archivePath ./build/MyApp.xcarchive archive

# Export IPA
xcodebuild -exportArchive -archivePath ./build/MyApp.xcarchive -exportPath ./build -exportOptionsPlist ExportOptions.plist

# Run tests
xcodebuild test -scheme MyApp -destination 'platform=iOS Simulator,name=iPhone 15 Pro'