create-cmp-cli 0.2.0

package/template/composeApp/src/commonMain/kotlin/com/example/app/presentation/home/HomeViewModel.kt

@@ -0,0 +1,35 @@
+package __PACKAGE__.presentation.home
+
+import androidx.lifecycle.ViewModel
+import androidx.lifecycle.viewModelScope
+import __PACKAGE__.domain.model.Item
+import __PACKAGE__.domain.usecase.GetItemsUseCase
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.launch
+
+data class HomeUiState(
+    val isLoading: Boolean = true,
+    val items: List<Item> = emptyList(),
+)
+
+class HomeViewModel(
+    private val getItems: GetItemsUseCase,
+) : ViewModel() {
+
+    private val _state = MutableStateFlow(HomeUiState())
+    val state: StateFlow<HomeUiState> = _state.asStateFlow()
+
+    init {
+        load()
+    }
+
+    fun load() {
+        viewModelScope.launch {
+            _state.value = HomeUiState(isLoading = true)
+            val items = getItems()
+            _state.value = HomeUiState(isLoading = false, items = items)
+        }
+    }
+}

package/template/composeApp/src/commonMain/kotlin/com/example/app/presentation/navigation/AppNavHost.kt

@@ -0,0 +1,43 @@
+package __PACKAGE__.presentation.navigation
+
+import androidx.compose.runtime.Composable
+import androidx.navigation.NavType
+import androidx.navigation.compose.NavHost
+import androidx.navigation.compose.composable
+import androidx.navigation.compose.rememberNavController
+import androidx.navigation.navArgument
+// Nav 2.9 (multiplatform): backStackEntry.arguments is a SavedState, not an Android Bundle.
+// Read it via the androidx.savedstate.read extension, NOT Bundle.getString().
+import androidx.savedstate.read
+import __PACKAGE__.presentation.home.HomeScreen
+import __PACKAGE__.presentation.profile.ProfileScreen
+
+@Composable
+fun AppNavHost() {
+    val navController = rememberNavController()
+
+    NavHost(navController = navController, startDestination = Screen.Shell.route) {
+        composable(Screen.Shell.route) {
+            val tabs = appTabs(
+                home = {
+                    HomeScreen(
+                        onItemClick = { itemId -> navController.navigate(Routes.detail(itemId)) },
+                    )
+                },
+                profile = { ProfileScreen() },
+            )
+            AppShell(tabs = tabs)
+        }
+
+        composable(
+            route = Screen.Detail.route,
+            arguments = listOf(navArgument("itemId") { type = NavType.StringType }),
+        ) { backStackEntry ->
+            val itemId = backStackEntry.arguments?.read { getStringOrNull("itemId") }.orEmpty()
+            __PACKAGE__.presentation.home.DetailScreen(
+                itemId = itemId,
+                onBack = { navController.popBackStack() },
+            )
+        }
+    }
+}

package/template/composeApp/src/commonMain/kotlin/com/example/app/presentation/navigation/AppShell.kt

@@ -0,0 +1,144 @@
+package __PACKAGE__.presentation.navigation
+
+import androidx.compose.foundation.background
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.defaultMinSize
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.navigationBarsPadding
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.material3.Icon
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableIntStateOf
+import androidx.compose.runtime.saveable.rememberSaveable
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clip
+import androidx.compose.ui.semantics.semantics
+import androidx.compose.ui.semantics.testTag
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.sp
+import __PACKAGE__.presentation.components.BaseScreen
+import __PACKAGE__.presentation.components.exposeTestTagsForAutomation
+import __PACKAGE__.presentation.theme.__THEME_PREFIX__Colors
+import __PACKAGE__.presentation.theme.__THEME_PREFIX__Tokens
+import __PACKAGE__.presentation.theme.designToken
+
+/**
+ * Generic bottom-nav shell. Parameterized by a [tabs] list — NOT role-hardcoded.
+ * Hosts the selected tab's content inside a [BaseScreen] so each tab gets correct insets;
+ * the bottom bar reserves the navigation-bar inset exactly once.
+ */
+@Composable
+fun AppShell(tabs: List<AppTab>) {
+    var selected by rememberSaveable { mutableIntStateOf(0) }
+
+    BaseScreen(
+        // Expose Compose testTags to the platform automation layer (Android resource-ids /
+        // iOS accessibilityIdentifiers) so Appium/uiautomator id-selectors and the
+        // cmp-test-generated suites find them; covers the whole subtree. Desktop: no-op.
+        modifier = Modifier.exposeTestTagsForAutomation(),
+        // The bottom bar owns the navigation-bar inset; the body must not also pad it.
+        applyNavBarPadding = false,
+        bottomBar = {
+            AppBottomNav(
+                tabs = tabs,
+                selectedIndex = selected,
+                onSelect = { selected = it },
+            )
+        },
+    ) {
+        Box(Modifier.fillMaxSize()) {
+            tabs.getOrNull(selected)?.content?.invoke()
+        }
+    }
+}
+
+@Composable
+private fun AppBottomNav(
+    tabs: List<AppTab>,
+    selectedIndex: Int,
+    onSelect: (Int) -> Unit,
+) {
+    Column(Modifier.fillMaxWidth()) {
+        Box(
+            Modifier
+                .fillMaxWidth()
+                .height(1.dp)
+                .background(__THEME_PREFIX__Colors.OutlineVariant)
+        )
+        Row(
+            modifier = Modifier
+                .fillMaxWidth()
+                .background(__THEME_PREFIX__Colors.Surface)
+                // Lift tabs above the gesture pill / 3-button nav (maps to iOS safe area).
+                .navigationBarsPadding()
+                .height(__THEME_PREFIX__Tokens.BottomNavHeight)
+                // Inspector: the bottom-nav container self-reports its height token.
+                .designToken(
+                    tokens = listOf("BottomNavHeight"),
+                    resolved = mapOf("height" to "72dp"),
+                )
+                .semantics { testTag = "app_bottom_nav" }
+                .padding(bottom = 8.dp),
+            verticalAlignment = Alignment.CenterVertically,
+            horizontalArrangement = Arrangement.SpaceEvenly,
+        ) {
+            tabs.forEachIndexed { index, tab ->
+                NavItem(
+                    label = tab.label,
+                    selected = selectedIndex == index,
+                    onClick = { onSelect(index) },
+                ) {
+                    Icon(
+                        imageVector = tab.icon,
+                        contentDescription = tab.label,
+                        tint = if (selectedIndex == index) __THEME_PREFIX__Colors.Primary
+                               else __THEME_PREFIX__Colors.OnSurfaceVariant.copy(alpha = 0.55f),
+                        modifier = Modifier.size(24.dp),
+                    )
+                }
+            }
+        }
+    }
+}
+
+@Composable
+private fun NavItem(
+    label: String,
+    selected: Boolean,
+    onClick: () -> Unit,
+    icon: @Composable () -> Unit,
+) {
+    Column(
+        modifier = Modifier
+            .clip(RoundedCornerShape(8.dp))
+            .clickable(onClick = onClick)
+            // a11y: guarantee the 48dp minimum touch target regardless of label width
+            // (the inspector's audit_a11y flags anything smaller).
+            .defaultMinSize(minWidth = 48.dp, minHeight = 48.dp)
+            .padding(horizontal = 8.dp, vertical = 4.dp),
+        horizontalAlignment = Alignment.CenterHorizontally,
+        verticalArrangement = Arrangement.Center,
+    ) {
+        icon()
+        Text(
+            text = label,
+            fontSize = 10.sp,
+            fontWeight = if (selected) FontWeight.Bold else FontWeight.SemiBold,
+            color = if (selected) __THEME_PREFIX__Colors.Primary else __THEME_PREFIX__Colors.OnSurfaceVariant,
+            modifier = Modifier.padding(top = 4.dp),
+        )
+    }
+}

package/template/composeApp/src/commonMain/kotlin/com/example/app/presentation/navigation/AppTab.kt

@@ -0,0 +1,25 @@
+package __PACKAGE__.presentation.navigation
+
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.Home
+import androidx.compose.material.icons.filled.Person
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.graphics.vector.ImageVector
+
+// A single bottom-nav tab: its label, icon, and the screen it renders.
+data class AppTab(
+    val label: String,
+    val icon: ImageVector,
+    val content: @Composable () -> Unit,
+)
+
+// The tab list drives AppShell + AppBottomNav generically (no role-hardcoded shells).
+// The scaffolder regenerates this list from the configured `tabs`.
+@Composable
+fun appTabs(
+    home: @Composable () -> Unit,
+    profile: @Composable () -> Unit,
+): List<AppTab> = listOf(
+    AppTab("Home", Icons.Filled.Home, home),
+    AppTab("Profile", Icons.Filled.Person, profile),
+)

package/template/composeApp/src/commonMain/kotlin/com/example/app/presentation/navigation/Screen.kt

@@ -0,0 +1,15 @@
+package __PACKAGE__.presentation.navigation
+
+// Type-safe route registry. Add a Screen object + a Routes constant per destination.
+sealed class Screen(val route: String) {
+    data object Shell : Screen(Routes.SHELL)
+    // Example detail destination reachable from a tab. Add your own below.
+    data object Detail : Screen(Routes.DETAIL)
+}
+
+object Routes {
+    const val SHELL  = "shell"
+    const val DETAIL = "detail/{itemId}"
+
+    fun detail(itemId: String) = "detail/$itemId"
+}

package/template/composeApp/src/commonMain/kotlin/com/example/app/presentation/profile/ProfileScreen.kt

@@ -0,0 +1,43 @@
+package __PACKAGE__.presentation.profile
+
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.padding
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.semantics.semantics
+import androidx.compose.ui.semantics.testTag
+import androidx.compose.ui.unit.dp
+import __PACKAGE__.presentation.theme.__THEME_PREFIX__Tokens
+import __PACKAGE__.presentation.theme.designToken
+
+// Feature stub. Copy the `home` feature's data→domain→presentation→DI wiring to flesh this out.
+@Composable
+fun ProfileScreen() {
+    Column(
+        modifier = Modifier
+            .fillMaxSize()
+            .designToken(
+                tokens = listOf("PaddingPage"),
+                resolved = mapOf("padding" to "16dp"),
+            )
+            .padding(__THEME_PREFIX__Tokens.PaddingPage),
+        verticalArrangement = Arrangement.spacedBy(8.dp),
+        horizontalAlignment = Alignment.Start,
+    ) {
+        Text(
+            text = "Profile",
+            style = MaterialTheme.typography.headlineMedium,
+            modifier = Modifier.semantics { testTag = "profile_title" },
+        )
+        Text(
+            text = "This is a stub screen. Wire it up like the Home feature.",
+            style = MaterialTheme.typography.bodyMedium,
+            color = MaterialTheme.colorScheme.onSurfaceVariant,
+        )
+    }
+}

package/template/composeApp/src/commonMain/kotlin/com/example/app/presentation/theme/DesignToken.kt

@@ -0,0 +1,25 @@
+package __PACKAGE__.presentation.theme
+
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.semantics.SemanticsPropertyKey
+import androidx.compose.ui.semantics.SemanticsPropertyReceiver
+import androidx.compose.ui.semantics.semantics
+
+/**
+ * The resolved design-token payload a component self-reports into the semantics tree.
+ *
+ * [tokens] are the declared token names (e.g. "RadiusCard"); [resolved] maps a facet
+ * (e.g. "radius", "color") to its concrete resolved value (e.g. "16dp", "#FFFFFFFF").
+ * This makes the semantics tree design-system-aware, not just geometry — which is what
+ * the create-cmp inspector reads to catch token drift. Only uses semantics + Modifier,
+ * so it adds no dependencies.
+ */
+data class DesignTokenInfo(val tokens: List<String>, val resolved: Map<String, String>)
+
+val DesignTokenKey = SemanticsPropertyKey<DesignTokenInfo>("DesignToken")
+
+var SemanticsPropertyReceiver.designToken by DesignTokenKey
+
+/** Attaches the resolved design-token payload to a node's semantics. */
+fun Modifier.designToken(tokens: List<String>, resolved: Map<String, String>): Modifier =
+    this.semantics { designToken = DesignTokenInfo(tokens, resolved) }

package/template/composeApp/src/commonMain/kotlin/com/example/app/presentation/theme/Shape.kt

@@ -0,0 +1,12 @@
+package __PACKAGE__.presentation.theme
+
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.material3.Shapes
+import androidx.compose.ui.unit.dp
+
+val __THEME_PREFIX__Shapes = Shapes(
+    small      = RoundedCornerShape(14.dp),
+    medium     = RoundedCornerShape(16.dp),
+    large      = RoundedCornerShape(999.dp),
+    extraLarge = RoundedCornerShape(24.dp),
+)

package/template/composeApp/src/commonMain/kotlin/com/example/app/presentation/theme/Theme.kt

@@ -0,0 +1,64 @@
+package __PACKAGE__.presentation.theme
+
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.lightColorScheme
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.graphics.Color
+
+// Seed design tokens. Replace these with your own brand palette — every screen reads
+// colours from here (or from MaterialTheme.colorScheme), never as raw hex.
+object __THEME_PREFIX__Colors {
+    val Primary          = Color(0xFF0A2540)
+    val OnPrimary        = Color(0xFFFFFFFF)
+    val Accent           = Color(0xFF00E676)
+    val OnAccent         = Color(0xFF0A2540)
+    val Secondary        = Color(0xFF00B96B)
+    val Error            = Color(0xFFDC2626)
+    val Success          = Color(0xFF16A34A)
+    val Warning          = Color(0xFFF59E0B)
+    val Info             = Color(0xFF2563EB)
+    val Background       = Color(0xFFF7F9FC)
+    val Surface          = Color(0xFFFFFFFF)
+    val SurfaceVariant   = Color(0xFFE8EDF3)
+    val OnSurface        = Color(0xFF1A1A1A)
+    val OnSurfaceVariant = Color(0xFF6B7280)
+    val Outline          = Color(0xFF9CA3AF)
+    val OutlineVariant   = Color(0xFFE5E7EB)
+    val Divider          = Color(0xFFE5E7EB)
+}
+
+private val __THEME_PREFIX__ColorScheme = lightColorScheme(
+    primary              = __THEME_PREFIX__Colors.Primary,
+    onPrimary            = __THEME_PREFIX__Colors.OnPrimary,
+    secondary            = __THEME_PREFIX__Colors.Secondary,
+    onSecondary          = __THEME_PREFIX__Colors.OnPrimary,
+    tertiary             = __THEME_PREFIX__Colors.Accent,
+    onTertiary           = __THEME_PREFIX__Colors.OnAccent,
+    error                = __THEME_PREFIX__Colors.Error,
+    background           = __THEME_PREFIX__Colors.Background,
+    surface              = __THEME_PREFIX__Colors.Surface,
+    surfaceVariant       = __THEME_PREFIX__Colors.SurfaceVariant,
+    onBackground         = __THEME_PREFIX__Colors.OnSurface,
+    onSurface            = __THEME_PREFIX__Colors.OnSurface,
+    onSurfaceVariant     = __THEME_PREFIX__Colors.OnSurfaceVariant,
+    outline              = __THEME_PREFIX__Colors.Outline,
+    outlineVariant       = __THEME_PREFIX__Colors.OutlineVariant,
+    inverseSurface       = __THEME_PREFIX__Colors.Primary,
+    // Kill M3's tonal overlay so dialogs/menus/sheets stay on the design-system surface.
+    surfaceTint              = Color.Transparent,
+    surfaceContainerLowest   = __THEME_PREFIX__Colors.Surface,
+    surfaceContainerLow      = __THEME_PREFIX__Colors.Surface,
+    surfaceContainer         = __THEME_PREFIX__Colors.Surface,
+    surfaceContainerHigh     = __THEME_PREFIX__Colors.Surface,
+    surfaceContainerHighest  = __THEME_PREFIX__Colors.SurfaceVariant,
+)
+
+@Composable
+fun __THEME_PREFIX__Theme(content: @Composable () -> Unit) {
+    MaterialTheme(
+        colorScheme = __THEME_PREFIX__ColorScheme,
+        typography  = remember__THEME_PREFIX__Typography(),
+        shapes      = __THEME_PREFIX__Shapes,
+        content     = content,
+    )
+}

package/template/composeApp/src/commonMain/kotlin/com/example/app/presentation/theme/Tokens.kt

@@ -0,0 +1,19 @@
+package __PACKAGE__.presentation.theme
+
+import androidx.compose.ui.unit.dp
+
+object __THEME_PREFIX__Tokens {
+    val ElevationCard  = 2.dp
+    val ElevationModal = 8.dp
+
+    val PaddingPage = 16.dp
+    val PaddingCard = 16.dp
+    val GapCard     = 12.dp
+
+    val BottomNavHeight = 72.dp
+
+    val RadiusCard  = 16.dp
+    val RadiusPill  = 999.dp
+    val RadiusModal = 24.dp
+    val RadiusInput = 14.dp
+}

package/template/composeApp/src/commonMain/kotlin/com/example/app/presentation/theme/Typography.kt

@@ -0,0 +1,36 @@
+package __PACKAGE__.presentation.theme
+
+import androidx.compose.material3.Typography
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.text.TextStyle
+import androidx.compose.ui.text.font.FontFamily
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.unit.sp
+import org.jetbrains.compose.resources.Font
+import __PACKAGE__.generated.resources.DMSans_Bold
+import __PACKAGE__.generated.resources.DMSans_Medium
+import __PACKAGE__.generated.resources.DMSans_Regular
+import __PACKAGE__.generated.resources.DMSans_SemiBold
+import __PACKAGE__.generated.resources.Res
+
+// DM Sans font family — weights 400/500/600/700 bundled in composeResources/font/.
+val DmSansFontFamily: FontFamily
+    @Composable get() = FontFamily(
+        Font(Res.font.DMSans_Regular,  weight = FontWeight.Normal),
+        Font(Res.font.DMSans_Medium,   weight = FontWeight.Medium),
+        Font(Res.font.DMSans_SemiBold, weight = FontWeight.SemiBold),
+        Font(Res.font.DMSans_Bold,     weight = FontWeight.Bold),
+    )
+
+@Composable
+fun remember__THEME_PREFIX__Typography(): Typography {
+    val dmSans = DmSansFontFamily
+    return Typography(
+        displayLarge   = TextStyle(fontFamily = dmSans, fontWeight = FontWeight.Bold,     fontSize = 32.sp),
+        headlineMedium = TextStyle(fontFamily = dmSans, fontWeight = FontWeight.SemiBold, fontSize = 24.sp),
+        titleMedium    = TextStyle(fontFamily = dmSans, fontWeight = FontWeight.SemiBold, fontSize = 18.sp),
+        bodyLarge      = TextStyle(fontFamily = dmSans, fontWeight = FontWeight.Normal,   fontSize = 16.sp),
+        bodyMedium     = TextStyle(fontFamily = dmSans, fontWeight = FontWeight.Normal,   fontSize = 14.sp),
+        labelSmall     = TextStyle(fontFamily = dmSans, fontWeight = FontWeight.Medium,   fontSize = 12.sp),
+    )
+}

package/template/composeApp/src/desktopMain/kotlin/com/example/app/core/connectivity/NetworkMonitor.desktop.kt

@@ -0,0 +1,9 @@
+package __PACKAGE__.core.connectivity
+
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+
+// Desktop dev-client: treat the workstation as always online.
+actual class NetworkMonitor actual constructor(context: Any?) {
+    actual val isOnline: StateFlow<Boolean> = MutableStateFlow(true)
+}

package/template/composeApp/src/desktopMain/kotlin/com/example/app/data/local/DatabaseBuilder.desktop.kt

@@ -0,0 +1,13 @@
+package __PACKAGE__.data.local
+
+import androidx.room.Room
+import androidx.room.RoomDatabase
+import java.io.File
+
+// Room KMP on the JVM uses the same BundledSQLiteDriver as iOS (set in buildDatabase). The
+// dev-client keeps its cache in the OS temp dir — disposable by design, like the dev loop itself.
+actual fun getDatabaseBuilder(): RoomDatabase.Builder<AppDatabase> {
+    val dbDir = File(System.getProperty("java.io.tmpdir"), "__PACKAGE__-dev-client")
+    dbDir.mkdirs()
+    return Room.databaseBuilder<AppDatabase>(name = File(dbDir, "app.db").absolutePath)
+}

package/template/composeApp/src/desktopMain/kotlin/com/example/app/di/DesktopModule.kt

@@ -0,0 +1,32 @@
+package __PACKAGE__.di
+
+import __PACKAGE__.core.connectivity.NetworkMonitor
+// >>> cmp:feature room
+import __PACKAGE__.data.local.AppDatabase
+import __PACKAGE__.data.local.buildDatabase
+// <<< cmp:feature room
+import org.koin.core.context.startKoin
+import org.koin.dsl.module
+
+// Desktop (JVM) DI bindings for the dev-client window.
+//
+// No Firebase here — the dev-client runs fully offline. The example feature's data source
+// (ItemRepositoryImpl, bound in appModules) is already an in-memory implementation serving the
+// same sample data on every platform, so nothing needs swapping out of the box. When you add a
+// real remote-backed repository, bind its desktop fake in THIS module so the dev-client keeps
+// working without a backend:
+//
+//   single<MyRepository> { InMemoryMyRepository() }   // shadows the remote binding on desktop
+val desktopModule = module {
+    // >>> cmp:feature room
+    single<AppDatabase> { buildDatabase() }
+    // <<< cmp:feature room
+    single { NetworkMonitor(null) }
+}
+
+// Mirrors AppApplication (Android) / KoinHelper (iOS) — Koin start for the desktop entry point.
+fun initDesktopKoin() {
+    startKoin {
+        modules(desktopModule, *appModules.toTypedArray())
+    }
+}

package/template/composeApp/src/desktopMain/kotlin/com/example/app/main.kt

@@ -0,0 +1,29 @@
+package __PACKAGE__
+
+import androidx.compose.ui.unit.DpSize
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.window.Window
+import androidx.compose.ui.window.application
+import androidx.compose.ui.window.rememberWindowState
+import __PACKAGE__.di.initDesktopKoin
+
+// Desktop dev-client: the shared commonMain UI in a live, clickable JVM window, sized like a
+// phone. This is the daily dev loop — run it with Compose Hot Reload and watch edits land
+// without restarting:
+//
+//   ./gradlew :composeApp:hotRunDesktop --auto     # hot reload, auto-reload on save
+//   ./gradlew :composeApp:run                      # plain run (any JDK, no hot reload)
+//
+// See docs/dev-client.md for the full loop.
+fun main() {
+    initDesktopKoin()
+    application {
+        Window(
+            onCloseRequest = ::exitApplication,
+            title = "__APP_NAME__ dev-client",
+            state = rememberWindowState(size = DpSize(411.dp, 891.dp)),
+        ) {
+            App()
+        }
+    }
+}

package/template/composeApp/src/desktopMain/kotlin/com/example/app/presentation/components/TestTagAutomation.desktop.kt

@@ -0,0 +1,6 @@
+package __PACKAGE__.presentation.components
+
+import androidx.compose.ui.Modifier
+
+/** Desktop: no resource-id concept (skiko `ui` lacks testTagsAsResourceId) — no-op. */
+actual fun Modifier.exposeTestTagsForAutomation(): Modifier = this

package/template/composeApp/src/iosMain/kotlin/com/example/app/KoinHelper.kt

@@ -0,0 +1,50 @@
+package __PACKAGE__
+
+import __PACKAGE__.core.connectivity.NetworkMonitor
+// >>> cmp:feature room
+import __PACKAGE__.data.local.AppDatabase
+import __PACKAGE__.data.local.buildDatabase
+// <<< cmp:feature room
+// >>> cmp:feature firebase
+import __PACKAGE__.data.remote.FIREBASE_FUNCTIONS_REGION
+import dev.gitlive.firebase.Firebase
+import dev.gitlive.firebase.auth.auth
+import dev.gitlive.firebase.firestore.firestore
+import dev.gitlive.firebase.functions.functions
+import dev.gitlive.firebase.storage.storage
+// <<< cmp:feature firebase
+import __PACKAGE__.di.appModules
+import org.koin.core.context.startKoin
+import org.koin.dsl.module
+
+// >>> cmp:feature firebase
+// Debug/QA: point GitLive Firebase at the local emulators. The iOS simulator shares the host
+// network, so 127.0.0.1 reaches the emulators directly. Requires FirebaseApp.configure() to
+// have run first (done in iOSApp.swift AppDelegate).
+private fun configureFirebaseEmulators() {
+    val host = "127.0.0.1"
+    runCatching {
+        Firebase.auth.useEmulator(host, 9099)
+        Firebase.firestore.useEmulator(host, 8080)
+        Firebase.functions(FIREBASE_FUNCTIONS_REGION).useEmulator(host, 5001)
+        Firebase.storage.useEmulator(host, 9199)
+    }
+}
+// <<< cmp:feature firebase
+
+fun initKoin() {
+    // >>> cmp:feature firebase
+    configureFirebaseEmulators()
+    // <<< cmp:feature firebase
+    startKoin {
+        modules(
+            module {
+                // >>> cmp:feature room
+                single<AppDatabase> { buildDatabase() }
+                // <<< cmp:feature room
+                single { NetworkMonitor(null) }
+            },
+            *appModules.toTypedArray()
+        )
+    }
+}

package/template/composeApp/src/iosMain/kotlin/com/example/app/MainViewController.kt

@@ -0,0 +1,10 @@
+package __PACKAGE__
+
+import androidx.compose.ui.window.ComposeUIViewController
+
+// Compose Multiplatform iOS entry point, bridged from ContentView.swift via ComposeView.
+// CMP 1.10: the iOS accessibility tree syncs automatically, so Compose testTag values are
+// exposed to XCUITest/Appium as accessibilityIdentifier without extra config.
+fun MainViewController() = ComposeUIViewController {
+    App()
+}

package/template/composeApp/src/iosMain/kotlin/com/example/app/core/connectivity/NetworkMonitor.kt

@@ -0,0 +1,32 @@
+package __PACKAGE__.core.connectivity
+
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import platform.Network.nw_path_get_status
+import platform.Network.nw_path_monitor_create
+import platform.Network.nw_path_monitor_set_queue
+import platform.Network.nw_path_monitor_set_update_handler
+import platform.Network.nw_path_monitor_start
+import platform.Network.nw_path_status_satisfied
+import platform.darwin.DISPATCH_QUEUE_PRIORITY_DEFAULT
+import platform.darwin.dispatch_get_global_queue
+
+actual class NetworkMonitor actual constructor(context: Any?) {
+
+    // Kotlin/Native exposes the C nw_path_monitor API (the Obj-C NWPathMonitor wrapper isn't bridged).
+    private val monitor = nw_path_monitor_create()
+    private val _isOnline = MutableStateFlow(false)
+    actual val isOnline: StateFlow<Boolean> = _isOnline.asStateFlow()
+
+    init {
+        nw_path_monitor_set_update_handler(monitor) { path ->
+            _isOnline.value = nw_path_get_status(path) == nw_path_status_satisfied
+        }
+        nw_path_monitor_set_queue(
+            monitor,
+            dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT.toLong(), 0u)
+        )
+        nw_path_monitor_start(monitor)
+    }
+}