Kmp Starter Native App

FeatureX/
    HomeScreen.swift        # pure, previewable view
    HomeRootScreen.swift    # wires ViewModel + lifecycle + sheets/alerts
    HomeViewModel.swift     # @MainActor ObservableObject, MVI

import SwiftUI

struct HomeScreen: View {
    let greeting: String
    let items: [HomeItem]
    let isLoading: Bool
    let onStart: () -> Void
    let onOpen: (Int) -> Void

    var body: some View {
        List {
            Section {
                Button(action: onStart) { Label("New", systemImage: "plus") }
            }
            Section {
                if isLoading {
                    ProgressView()
                } else if items.isEmpty {
                    ContentUnavailableView("Nothing here", systemImage: "tray")
                } else {
                    ForEach(items) { item in
                        Button { onOpen(item.id) } label: { Text(item.title) }
                    }
                }
            }
        }
        .listStyle(.insetGrouped)
        .navigationTitle(greeting)
    }
}

#Preview("Home") {
    NavigationStack {
        HomeScreen(
            greeting: "Hello, Jamie",
            items: [HomeItem(id: 1, title: "First")],
            isLoading: false,
            onStart: {},
            onOpen: { _ in }
        )
    }
}

import SwiftUI
import iosRuntime

@MainActor
final class HomeViewModel: ObservableObject {
    @Published private(set) var greeting: String = "Hello"
    @Published private(set) var items: [HomeItem] = []
    @Published private(set) var isLoading = true
    @Published var errorMessage: String?

    private var observeTask: Task<Void, Never>?

    func start() {
        refresh()
        observeTask?.cancel()
        observeTask = Task { await observe() }
    }

    func stop() {
        observeTask?.cancel()
        observeTask = nil
    }

    func open(_ id: Int) { /* action */ }

    private func refresh() {
        let runtime = SharedRuntime.shared
        greeting = runtime.greeting()
    }

    private func observe() async {
        let repo = SharedRuntime.shared.yourRepository()
        for await data in repo.observeItems() {   // SKIE turns Flow into AsyncSequence
            if Task.isCancelled { return }
            items = data.map { HomeItem(id: Int($0.id), title: $0.title) }
            isLoading = false
        }
    }
}

struct HomeRootScreen: View {
    @StateObject private var viewModel = HomeViewModel()

    var body: some View {
        HomeScreen(
            greeting: viewModel.greeting,
            items: viewModel.items,
            isLoading: viewModel.isLoading,
            onStart: { viewModel.open(0) },
            onOpen: { viewModel.open($0) }
        )
        .task { viewModel.start() }
        .onDisappear { viewModel.stop() }
        .alert("Error", isPresented: Binding(
            get: { viewModel.errorMessage != nil },
            set: { if !$0 { viewModel.errorMessage = nil } }
        )) {
            Button("OK", role: .cancel) { viewModel.errorMessage = nil }
        } message: {
            Text(viewModel.errorMessage ?? "")
        }
    }
}