chore(frontend): refactor navigation and DI setup, remove unused shared module

- Replaced `initKoin` with `startKoin` for DI initialization consistency across platforms.
- Introduced `StateNavigationPort` with `StateFlow` to streamline navigation state management.
- Migrated `AppScreen` to sealed class with route mapping for better navigation handling.
- Deleted unused `frontend/shared` module and removed related dependencies from build files.
- Cleaned up legacy navigation and Redux-related code, aligning with MVVM architecture.

_backup/shared/build.gradle.kts

@@ -0,0 +1,109 @@
+plugins {
+  alias(libs.plugins.kotlinMultiplatform)
+  alias(libs.plugins.kotlinSerialization)
+  alias(libs.plugins.composeMultiplatform)
+  alias(libs.plugins.composeCompiler)
+}
+
+kotlin {
+  jvm("desktop")
+
+  js(IR) {
+    // WICHTIG: Als Library kompilieren für Webpack Federation
+    binaries.library()
+    generateTypeScriptDefinitions()
+    browser {
+      commonWebpackConfig {
+        cssSupport {
+          enabled.set(true)
+        }
+      }
+    }
+  }
+
+  // Wasm vorerst deaktiviert
+  /*
+  @OptIn(org.jetbrains.kotlin.gradle.ExperimentalWasmDsl::class)
+  wasmJs {
+      browser()
+      binaries.executable()
+  }
+  */
+
+  sourceSets {
+    commonMain {
+      dependencies {
+        implementation(projects.frontend.core.domain)
+        // implementation(projects.frontend.core.designSystem) // REMOVED: Circular dependency
+        implementation(projects.frontend.core.navigation)
+        implementation(projects.frontend.core.network)
+        implementation(projects.frontend.core.localDb)
+
+        // Features - REMOVED: Circular dependency. Shared should NOT depend on features.
+        // implementation(projects.frontend.features.authFeature)
+        // implementation(projects.frontend.features.pingFeature)
+
+        // KMP Bundles
+        implementation(libs.bundles.kmp.common)
+        implementation(libs.bundles.compose.common)
+
+        // Ktor (used directly in shared/di and shared/network)
+        implementation(libs.ktor.client.core)
+        implementation(libs.ktor.client.contentNegotiation)
+        implementation(libs.ktor.client.logging)
+        implementation(libs.ktor.client.serialization.kotlinx.json)
+
+        // Serialization
+        implementation(libs.kotlinx.serialization.json)
+
+        implementation(libs.kotlinx.coroutines.core)
+        // implementation(libs.sqldelight.coroutines) // Wird transitiv über core:localDb geladen
+
+        // Compose
+        implementation(compose.runtime)
+        implementation(compose.foundation)
+        implementation(compose.material3)
+        implementation(compose.ui)
+        implementation(compose.components.resources)
+        implementation(compose.components.uiToolingPreview)
+
+        // Koin
+        implementation(libs.koin.core)
+        implementation(libs.koin.compose)
+        implementation(libs.koin.compose.viewmodel)
+      }
+    }
+
+    commonTest {
+      dependencies {
+        implementation(libs.kotlin.test)
+      }
+    }
+
+    val desktopMain by getting {
+      dependencies {
+        implementation(compose.desktop.currentOs)
+        implementation(libs.kotlinx.coroutines.swing)
+        // implementation(libs.sqldelight.driver.sqlite) // Wird transitiv über core:localDb geladen
+      }
+    }
+
+    val jsMain by getting {
+      dependencies {
+        implementation(libs.ktor.client.js)
+        // implementation(libs.sqldelight.driver.web) // Wird transitiv über core:localDb geladen
+
+        // Webpack Plugin für Federation Support (falls benötigt)
+        implementation(devNpm("copy-webpack-plugin", "12.0.0"))
+      }
+    }
+
+    /*
+    val wasmJsMain by getting {
+        dependencies {
+            implementation(libs.ktor.client.js)
+        }
+    }
+    */
+  }
+}

_backup/shared/src/commonMain/kotlin/at/mocode/shared/core/AppConfig.kt

@@ -0,0 +1,12 @@
+package at.mocode.shared.core
+
+data class AppConfig(
+  val gatewayUrl: String,
+  val isDebug: Boolean
+)
+
+// Standard-Config für Local Development
+val devConfig = AppConfig(
+  gatewayUrl = "http://localhost:8081",
+  isDebug = true
+)

_backup/shared/src/commonMain/kotlin/at/mocode/shared/core/AppConstants.kt

@@ -0,0 +1,29 @@
+package at.mocode.shared.core
+
+/**
+ * Shared application configuration constants for clients.
+ * These defaults target local development environments.
+ */
+object AppConstants {
+  // Gateway base URL (reverse proxy / API gateway)
+  // Used by NetworkConfig via PlatformConfig
+  const val GATEWAY_URL: String = "http://localhost:8081"
+
+  // Keycloak configuration
+  const val KEYCLOAK_URL: String = "http://localhost:8180"
+  const val KEYCLOAK_REALM: String = "meldestelle"
+
+  // Use 'postman-client' for Desktop App Password Flow (Direct Access Grants enabled)
+  // 'web-app' is for Browser Flow (PKCE)
+  // TODO: Make this platform-dependent (Desktop vs Web)
+  const val KEYCLOAK_CLIENT_ID: String = "web-app"
+
+  // DEV ONLY: Client Secret for 'postman-client' (Confidential Client)
+  // In Production, this should NEVER be in the frontend code.
+  // For the Desktop App Pilot, we use this to simulate a secure client.
+  // For 'web-app' (Public Client), this is not needed/used if configured correctly,
+  // but our AuthApiClient might be sending it.
+  const val KEYCLOAK_CLIENT_SECRET: String = "postman-secret-123"
+
+  // Removed unused browser flow URLs (registerUrl, loginUrl, etc.) as we focus on Desktop App.
+}

_backup/shared/src/commonMain/kotlin/at/mocode/shared/data/repository/PingRepositoryImpl.kt

@@ -0,0 +1,27 @@
+package at.mocode.shared.data.repository
+
+import at.mocode.shared.domain.model.PingData
+import at.mocode.shared.domain.model.Resource
+import at.mocode.shared.domain.repository.PingRepository
+import io.ktor.client.*
+import io.ktor.client.call.*
+import io.ktor.client.request.*
+
+class PingRepositoryImpl(
+  private val httpClient: HttpClient
+) : PingRepository {
+
+  override suspend fun checkSystemStatus(): Resource<PingData> {
+    return try {
+      // Der HttpClient hat die BaseURL schon konfiguriert (siehe NetworkModule)
+      val response = httpClient.get("/api/ping/simple").body<PingData>()
+      Resource.Success(response)
+    } catch (e: Exception) {
+      // Hier fangen wir Netzwerkfehler ab und machen sie "hübsch" für die UI
+      Resource.Error(
+        message = "Verbindung fehlgeschlagen: ${e.message ?: "Unbekannter Fehler"}",
+        code = "NETWORK_ERROR"
+      )
+    }
+  }
+}

_backup/shared/src/commonMain/kotlin/at/mocode/shared/di/NetworkModule.kt

@@ -0,0 +1,50 @@
+package at.mocode.shared.di
+
+import at.mocode.shared.core.AppConfig
+import io.ktor.client.*
+import io.ktor.client.plugins.*
+import io.ktor.client.plugins.contentnegotiation.*
+import io.ktor.client.plugins.logging.*
+import io.ktor.http.*
+import io.ktor.serialization.kotlinx.json.*
+import kotlinx.serialization.json.Json
+import org.koin.dsl.module
+
+val networkModule = module {
+  // 1. JSON Konfiguration (Global verfügbar)
+  single {
+    Json {
+      ignoreUnknownKeys = true
+      prettyPrint = true
+      isLenient = true
+    }
+  }
+
+  // 2. HttpClient (Singleton)
+  single {
+    val config = get<AppConfig>()
+    val jsonConfig = get<Json>()
+
+    HttpClient {
+      // Standard-URL setzen
+      defaultRequest {
+        url(config.gatewayUrl)
+        contentType(ContentType.Application.Json)
+      }
+
+      install(ContentNegotiation) {
+        json(jsonConfig)
+      }
+
+      install(Logging) {
+        level = if (config.isDebug) LogLevel.INFO else LogLevel.NONE
+        logger = Logger.DEFAULT
+      }
+
+      install(HttpTimeout) {
+        requestTimeoutMillis = 10000
+        connectTimeoutMillis = 10000
+      }
+    }
+  }
+}

_backup/shared/src/commonMain/kotlin/at/mocode/shared/di/SharedModule.kt

@@ -0,0 +1,26 @@
+package at.mocode.shared.di
+
+import at.mocode.shared.core.devConfig
+import at.mocode.frontend.core.network.networkModule
+import org.koin.core.context.startKoin
+import org.koin.dsl.KoinAppDeclaration
+import org.koin.dsl.module
+
+// Das Modul für die Config
+val configModule = module {
+  single { devConfig } // Später können wir hier PROD/DEV umschalten
+}
+
+// Basismodule, die immer geladen werden sollen (ohne Feature/Core-Cross-Imports)
+val baseSharedModules = listOf(
+  configModule,
+  // Network module provides DI-only HttpClient (safe to be shared across features)
+  networkModule
+)
+
+// Helper zum Starten von Koin (wird von der App aufgerufen)
+// Weitere Module (z. B. networkModule) können über appDeclaration hinzugefügt werden.
+fun initKoin(appDeclaration: KoinAppDeclaration = {}) = startKoin {
+  modules(baseSharedModules)
+  appDeclaration()
+}

_backup/shared/src/commonMain/kotlin/at/mocode/shared/domain/model/ApiModels.kt

@@ -0,0 +1,41 @@
+package at.mocode.shared.domain.model
+
+import kotlinx.serialization.Serializable
+
+/**
+ * Generischer Wrapper für API-Antworten.
+ */
+@Serializable
+data class ApiResponse<T>(
+  val success: Boolean,
+  val data: T? = null,
+  val error: ApiError? = null
+)
+
+@Serializable
+data class ApiError(
+  val code: String,
+  val message: String,
+  val details: Map<String, String> = emptyMap()
+)
+
+/**
+ * Das Ergebnis eines Repository-Aufrufs.
+ * Die UI kennt nur das hier, keine HTTP-Exceptions!
+ */
+sealed class Resource<out T> {
+  data class Success<T>(val data: T) : Resource<T>()
+  data class Error(val message: String, val code: String? = null) : Resource<Nothing>()
+  data object Loading : Resource<Nothing>()
+}
+
+/**
+ * Datenmodell für den Ping.
+ */
+@Serializable
+data class PingData(
+  val status: String,
+  val timestamp: String,
+  val service: String
+)
+

_backup/shared/src/commonMain/kotlin/at/mocode/shared/domain/repository/PingRepository.kt

@@ -0,0 +1,8 @@
+package at.mocode.shared.domain.repository
+
+import at.mocode.shared.domain.model.PingData
+import at.mocode.shared.domain.model.Resource
+
+interface PingRepository {
+  suspend fun checkSystemStatus(): Resource<PingData>
+}

_backup/shared/src/commonMain/kotlin/at/mocode/shared/navigation/NavigationManager.kt

@@ -0,0 +1,178 @@
+package at.mocode.shared.navigation
+
+import at.mocode.shared.presentation.actions.AppAction
+import at.mocode.shared.presentation.store.AppStore
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.map
+
+/**
+ * Navigation manager for handling routing and navigation logic
+ */
+class NavigationManager(
+  private val store: AppStore
+) {
+
+  /**
+   * Current route as a flow
+   */
+  val currentRoute: Flow<String> = store.state.map { it.navigation.currentRoute }
+
+  /**
+   * Navigation history as a flow
+   */
+  val navigationHistory: Flow<List<String>> = store.state.map { it.navigation.history }
+
+  /**
+   * Can go back flag as a flow
+   */
+  val canGoBack: Flow<Boolean> = store.state.map { it.navigation.canGoBack }
+
+  /**
+   * Navigate to a specific route
+   */
+  fun navigateTo(route: String) {
+    store.dispatch(AppAction.Navigation.NavigateTo(route))
+  }
+
+  /**
+   * Navigate back to the previous route
+   */
+  fun navigateBack() {
+    store.dispatch(AppAction.Navigation.NavigateBack)
+  }
+
+  /**
+   * Replace current route without adding to history
+   */
+  fun replaceRoute(route: String) {
+    store.dispatch(AppAction.Navigation.UpdateHistory(route))
+  }
+
+  /**
+   * Clear navigation history and navigate to the route
+   */
+  fun navigateAndClearHistory(route: String) {
+    // First clear by replacing with the new route
+    store.dispatch(AppAction.Navigation.UpdateHistory(route))
+  }
+
+  /**
+   * Get current route value (non-reactive)
+   */
+  fun getCurrentRoute(): String = store.state.value.navigation.currentRoute
+
+  /**
+   * Check if we can navigate back
+   */
+  fun canNavigateBack(): Boolean = store.state.value.navigation.canGoBack
+}
+
+/**
+ * Route definitions for the application
+ */
+object Routes {
+  const val HOME = "/"
+  const val LOGIN = "/login"
+  const val DASHBOARD = "/dashboard"
+  const val PROFILE = "/profile"
+  const val SETTINGS = "/settings"
+  const val PING = "/ping"
+
+  // Auth-related routes
+  object Auth {
+    const val LOGIN = "/auth/login"
+    const val LOGOUT = "/auth/logout"
+    const val REGISTER = "/auth/register"
+    const val FORGOT_PASSWORD = "/auth/forgot-password"
+  }
+
+  // Admin routes
+  object Admin {
+    const val DASHBOARD = "/admin/dashboard"
+    const val USERS = "/admin/users"
+    const val SETTINGS = "/admin/settings"
+  }
+
+  // Feature routes
+  object Features {
+    const val PING = "/features/ping"
+    const val REPORTS = "/features/reports"
+    const val NOTIFICATIONS = "/features/notifications"
+  }
+}
+
+/**
+ * Route validation and utilities
+ */
+object RouteUtils {
+
+  /**
+   * Check if a route requires authentication
+   */
+  fun requiresAuth(route: String): Boolean {
+    return when {
+      route.startsWith("/auth/") && route != Routes.Auth.LOGIN -> false
+      route == Routes.HOME -> false
+      route == Routes.LOGIN -> false
+      else -> true
+    }
+  }
+
+  /**
+   * Check if a route is for admin only
+   */
+  fun requiresAdmin(route: String): Boolean {
+    return route.startsWith("/admin/")
+  }
+
+  /**
+   * Get the default route for authenticated users
+   */
+  fun getDefaultAuthenticatedRoute(): String = Routes.DASHBOARD
+
+  /**
+   * Get the default route for unauthenticated users
+   */
+  fun getDefaultUnauthenticatedRoute(): String = Routes.LOGIN
+
+  /**
+   * Validate route format
+   */
+  fun isValidRoute(route: String): Boolean {
+    return route.startsWith("/") && route.isNotBlank()
+  }
+
+  /**
+   * Parse route parameters (simple implementation)
+   */
+  fun parseRouteParams(route: String): Map<String, String> {
+    val params = mutableMapOf<String, String>()
+
+    // Simple query parameter parsing
+    if (route.contains("?")) {
+      val parts = route.split("?")
+      if (parts.size == 2) {
+        val queryParams = parts[1].split("&")
+        queryParams.forEach { param ->
+          val keyValue = param.split("=")
+          if (keyValue.size == 2) {
+            params[keyValue[0]] = keyValue[1]
+          }
+        }
+      }
+    }
+
+    return params
+  }
+
+  /**
+   * Get clean route without parameters
+   */
+  fun getCleanRoute(route: String): String {
+    return if (route.contains("?")) {
+      route.split("?")[0]
+    } else {
+      route
+    }
+  }
+}

_backup/shared/src/commonMain/kotlin/at/mocode/shared/navigation/NavigationPersistence.kt

@@ -0,0 +1,75 @@
+package at.mocode.shared.navigation
+
+import at.mocode.shared.presentation.state.NavigationState
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.flowOf
+
+/**
+ * Interface für das Persistieren von Navigation State
+ */
+interface NavigationPersistence {
+  suspend fun saveNavigationState(state: NavigationState)
+  fun getNavigationState(): Flow<NavigationState?>
+  suspend fun clearNavigationState()
+}
+
+/**
+ * Default implementation ohne echte Persistierung (In-Memory)
+ * Platform-spezifische Implementierungen können echte Persistierung bereitstellen
+ */
+class DefaultNavigationPersistence : NavigationPersistence {
+  private var currentState: NavigationState? = null
+
+  override suspend fun saveNavigationState(state: NavigationState) {
+    currentState = state
+  }
+
+  override fun getNavigationState(): Flow<NavigationState?> {
+    return flowOf(currentState)
+  }
+
+  override suspend fun clearNavigationState() {
+    currentState = null
+  }
+}
+
+/**
+ * Navigation History Manager mit Persistierung
+ */
+class NavigationHistoryManager(
+  private val persistence: NavigationPersistence
+) {
+  companion object {
+    private const val MAX_HISTORY_SIZE = 50
+  }
+
+  suspend fun saveRoute(route: String, history: List<String>) {
+    val state = NavigationState(
+      currentRoute = route,
+      history = history.takeLast(MAX_HISTORY_SIZE),
+      canGoBack = history.isNotEmpty()
+    )
+    persistence.saveNavigationState(state)
+  }
+
+  fun getPersistedState() = persistence.getNavigationState()
+
+  suspend fun clear() = persistence.clearNavigationState()
+
+  /**
+   * Optimiert die History für bessere Performance
+   */
+  private fun optimizeHistory(history: List<String>): List<String> {
+    // Entfernt Duplikate in Folge und behält nur die letzten N Einträge
+    return history
+      .fold(emptyList<String>()) { acc, route ->
+        if (acc.lastOrNull() != route) acc + route else acc
+      }
+      .takeLast(MAX_HISTORY_SIZE)
+  }
+
+  suspend fun addToHistory(newRoute: String, currentHistory: List<String>) {
+    val optimizedHistory = optimizeHistory(currentHistory + newRoute)
+    saveRoute(newRoute, optimizedHistory.dropLast(1))
+  }
+}

_backup/shared/src/commonMain/kotlin/at/mocode/shared/network/HttpClientConfig.kt

@@ -0,0 +1,27 @@
+package at.mocode.shared.network
+
+import io.ktor.client.*
+import io.ktor.client.plugins.contentnegotiation.*
+import io.ktor.serialization.kotlinx.json.*
+import kotlinx.serialization.json.Json
+
+object HttpClientConfig {
+
+  fun createClient(
+    baseUrl: String = "http://localhost:8080"
+  ): HttpClient = HttpClient {
+
+    // Content negotiation with JSON (based on PingApiClient pattern)
+    install(ContentNegotiation) {
+      json(Json {
+        prettyPrint = true
+        isLenient = true
+        ignoreUnknownKeys = true
+      })
+    }
+  }
+
+  fun createClientWithBaseUrl(baseUrl: String): HttpClient {
+    return createClient(baseUrl)
+  }
+}

_backup/shared/src/commonMain/kotlin/at/mocode/shared/network/NetworkException.kt

@@ -0,0 +1,172 @@
+package at.mocode.shared.network
+
+import at.mocode.shared.domain.model.ApiError
+import io.ktor.client.network.sockets.*
+import io.ktor.client.plugins.*
+import kotlinx.io.IOException
+
+/**
+ * Custom exceptions for network operations
+ */
+sealed class NetworkException(
+  message: String,
+  cause: Throwable? = null,
+  val apiError: ApiError
+) : Exception(message, cause) {
+
+  class ConnectionException(
+    message: String = "Connection failed",
+    cause: Throwable? = null
+  ) : NetworkException(
+    message = message,
+    cause = cause,
+    apiError = ApiError(
+      code = "CONNECTION_ERROR",
+      message = message,
+      details = mapOf("type" to "network_connectivity")
+    )
+  )
+
+  class TimeoutException(
+    message: String = "Request timed out",
+    cause: Throwable? = null
+  ) : NetworkException(
+    message = message,
+    cause = cause,
+    apiError = ApiError(
+      code = "TIMEOUT_ERROR",
+      message = message,
+      details = mapOf("type" to "request_timeout")
+    )
+  )
+
+  class ServerException(
+    statusCode: Int,
+    message: String = "Server error",
+    cause: Throwable? = null
+  ) : NetworkException(
+    message = message,
+    cause = cause,
+    apiError = ApiError(
+      code = "SERVER_ERROR",
+      message = message,
+      details = mapOf(
+        "type" to "server_error",
+        "status_code" to statusCode.toString()
+      )
+    )
+  )
+
+  class ClientException(
+    statusCode: Int,
+    message: String = "Client error",
+    cause: Throwable? = null
+  ) : NetworkException(
+    message = message,
+    cause = cause,
+    apiError = ApiError(
+      code = "CLIENT_ERROR",
+      message = message,
+      details = mapOf(
+        "type" to "client_error",
+        "status_code" to statusCode.toString()
+      )
+    )
+  )
+
+  class AuthenticationException(
+    message: String = "Authentication failed",
+    cause: Throwable? = null
+  ) : NetworkException(
+    message = message,
+    cause = cause,
+    apiError = ApiError(
+      code = "AUTHENTICATION_ERROR",
+      message = message,
+      details = mapOf("type" to "authentication_failure")
+    )
+  )
+
+  class AuthorizationException(
+    message: String = "Authorization failed",
+    cause: Throwable? = null
+  ) : NetworkException(
+    message = message,
+    cause = cause,
+    apiError = ApiError(
+      code = "AUTHORIZATION_ERROR",
+      message = message,
+      details = mapOf("type" to "authorization_failure")
+    )
+  )
+
+  class UnknownException(
+    message: String = "Unknown error occurred",
+    cause: Throwable? = null
+  ) : NetworkException(
+    message = message,
+    cause = cause,
+    apiError = ApiError(
+      code = "UNKNOWN_ERROR",
+      message = message,
+      details = mapOf("type" to "unknown_error")
+    )
+  )
+}
+
+/**
+ * Extension function to convert various exceptions to NetworkException
+ */
+fun Throwable.toNetworkException(): NetworkException {
+  return when (this) {
+    is ConnectTimeoutException -> NetworkException.TimeoutException(
+      message = "Connection timeout: ${this.message}",
+      cause = this
+    )
+
+    is SocketTimeoutException -> NetworkException.TimeoutException(
+      message = "Socket timeout: ${this.message}",
+      cause = this
+    )
+
+    is ResponseException -> when (this.response.status.value) {
+      401 -> NetworkException.AuthenticationException(
+        message = "Authentication required",
+        cause = this
+      )
+
+      403 -> NetworkException.AuthorizationException(
+        message = "Access forbidden",
+        cause = this
+      )
+
+      in 400..499 -> NetworkException.ClientException(
+        statusCode = this.response.status.value,
+        message = "Client error: ${this.message}",
+        cause = this
+      )
+
+      in 500..599 -> NetworkException.ServerException(
+        statusCode = this.response.status.value,
+        message = "Server error: ${this.message}",
+        cause = this
+      )
+
+      else -> NetworkException.UnknownException(
+        message = "HTTP error: ${this.message}",
+        cause = this
+      )
+    }
+
+    is IOException -> NetworkException.ConnectionException(
+      message = "Network connection failed: ${this.message}",
+      cause = this
+    )
+
+    is NetworkException -> this
+    else -> NetworkException.UnknownException(
+      message = "Unexpected error: ${this.message}",
+      cause = this
+    )
+  }
+}

_backup/shared/src/commonMain/kotlin/at/mocode/shared/network/NetworkUtils.kt

@@ -0,0 +1,220 @@
+package at.mocode.shared.network
+
+import at.mocode.shared.domain.model.ApiError
+import kotlinx.coroutines.delay
+
+// Using platform-agnostic timestamp handling
+
+/**
+ * Simple timestamp provider for multiplatform compatibility
+ */
+expect fun currentTimeMillis(): Long
+
+/**
+ * Network utilities for handling retry logic and resilience
+ */
+object NetworkUtils {
+
+  /**
+   * Retry configuration for network operations
+   */
+  data class RetryConfig(
+    val maxAttempts: Int = 3,
+    val initialDelayMs: Long = 1000L,
+    val maxDelayMs: Long = 10000L,
+    val backoffMultiplier: Double = 2.0,
+    val retryableExceptions: Set<String> = setOf(
+      "CONNECTION_ERROR",
+      "TIMEOUT_ERROR",
+      "SERVER_ERROR"
+    )
+  )
+
+  /**
+   * Execute operation with retry logic
+   */
+  suspend fun <T> withRetry(
+    config: RetryConfig = RetryConfig(),
+    operation: suspend () -> RepositoryResult<T>
+  ): RepositoryResult<T> {
+    var lastError: ApiError? = null
+    var currentDelay = config.initialDelayMs
+
+    repeat(config.maxAttempts) { attempt ->
+      try {
+        val result = operation()
+
+        // Return success immediately
+        if (result.isSuccess()) {
+          return result
+        }
+
+        // Check if the error is retryable
+        val error = result.getErrorOrNull()
+        if (error != null && shouldRetry(error, config)) {
+          lastError = error
+
+          // Don't delay on the last attempt
+          if (attempt < config.maxAttempts - 1) {
+            delay(currentDelay)
+            currentDelay = minOf(
+              (currentDelay * config.backoffMultiplier).toLong(),
+              config.maxDelayMs
+            )
+          }
+        } else {
+          // Non-retryable error, return immediately
+          return result
+        }
+      } catch (e: Exception) {
+        val networkException = e.toNetworkException()
+        lastError = networkException.apiError
+
+        if (shouldRetry(networkException.apiError, config)) {
+          if (attempt < config.maxAttempts - 1) {
+            delay(currentDelay)
+            currentDelay = minOf(
+              (currentDelay * config.backoffMultiplier).toLong(),
+              config.maxDelayMs
+            )
+          }
+        } else {
+          return RepositoryResult.Error(networkException.apiError)
+        }
+      }
+    }
+
+    // All attempts exhausted, return last error
+    return RepositoryResult.Error(
+      lastError ?: ApiError(
+        code = "MAX_RETRIES_EXCEEDED",
+        message = "Maximum retry attempts exceeded"
+      )
+    )
+  }
+
+  /**
+   * Check if an error should trigger a retry
+   */
+  private fun shouldRetry(error: ApiError, config: RetryConfig): Boolean {
+    return config.retryableExceptions.contains(error.code)
+  }
+
+  /**
+   * Network connectivity checker (simplified for shared module)
+   */
+  object ConnectivityChecker {
+    private var isOnline: Boolean = true
+    private var lastCheckMillis: Long = 0L
+
+    fun setOnlineStatus(online: Boolean) {
+      isOnline = online
+      lastCheckMillis = currentTimeMillis()
+    }
+
+    fun isOnline(): Boolean = isOnline
+
+    fun getLastCheckMillis(): Long = lastCheckMillis
+
+    /**
+     * Simple connectivity test by attempting a lightweight operation
+     */
+    suspend fun checkConnectivity(testOperation: suspend () -> Boolean): Boolean {
+      return try {
+        val result = testOperation()
+        setOnlineStatus(result)
+        result
+      } catch (_: Exception) {
+        setOnlineStatus(false)
+        false
+      }
+    }
+  }
+
+  /**
+   * Circuit breaker pattern for network operations
+   */
+  class CircuitBreaker(
+    private val failureThreshold: Int = 5,
+    private val recoveryTimeoutMs: Long = 60000L,
+    private val successThreshold: Int = 3
+  ) {
+    private enum class State { CLOSED, OPEN, HALF_OPEN }
+
+    private var state = State.CLOSED
+    private var failureCount = 0
+    private var successCount = 0
+    private var lastFailureTime = 0L
+
+    suspend fun <T> execute(operation: suspend () -> RepositoryResult<T>): RepositoryResult<T> {
+      when (state) {
+        State.OPEN -> {
+          if (currentTimeMillis() - lastFailureTime >= recoveryTimeoutMs) {
+            state = State.HALF_OPEN
+            successCount = 0
+          } else {
+            return RepositoryResult.Error(
+              ApiError(
+                code = "CIRCUIT_BREAKER_OPEN",
+                message = "Circuit breaker is open, requests blocked"
+              )
+            )
+          }
+        }
+
+        State.HALF_OPEN -> {
+          // Allow limited requests to test recovery
+        }
+
+        State.CLOSED -> {
+          // Normal operation
+        }
+      }
+
+      return try {
+        val result = operation()
+
+        if (result.isSuccess()) {
+          onSuccess()
+        } else {
+          onFailure()
+        }
+
+        result
+      } catch (e: Exception) {
+        onFailure()
+        val networkException = e.toNetworkException()
+        RepositoryResult.Error(networkException.apiError)
+      }
+    }
+
+    private fun onSuccess() {
+      failureCount = 0
+
+      when (state) {
+        State.HALF_OPEN -> {
+          successCount++
+          if (successCount >= successThreshold) {
+            state = State.CLOSED
+          }
+        }
+
+        else -> {
+          state = State.CLOSED
+        }
+      }
+    }
+
+    private fun onFailure() {
+      failureCount++
+      lastFailureTime = currentTimeMillis()
+
+      if (failureCount >= failureThreshold) {
+        state = State.OPEN
+      }
+    }
+
+    fun getState(): String = state.name
+    fun getFailureCount(): Int = failureCount
+  }
+}

_backup/shared/src/commonMain/kotlin/at/mocode/shared/network/RepositoryResult.kt

@@ -0,0 +1,18 @@
+package at.mocode.shared.network
+
+import at.mocode.shared.domain.model.ApiError
+
+/**
+ * Einheitlicher Ergebnis-Typ für Repository-/Netzwerkoperationen.
+ */
+sealed class RepositoryResult<out T> {
+  data class Success<T>(val value: T) : RepositoryResult<T>()
+  data class Error(val apiError: ApiError) : RepositoryResult<Nothing>()
+}
+
+fun <T> RepositoryResult<T>.isSuccess(): Boolean = this is RepositoryResult.Success
+
+fun <T> RepositoryResult<T>.getErrorOrNull(): ApiError? = when (this) {
+  is RepositoryResult.Success -> null
+  is RepositoryResult.Error -> this.apiError
+}

_backup/shared/src/commonMain/kotlin/at/mocode/shared/presentation/actions/AppAction.kt

@@ -0,0 +1,37 @@
+package at.mocode.shared.presentation.actions
+
+import at.mocode.shared.presentation.state.Notification
+import at.mocode.frontend.core.domain.models.User
+import at.mocode.frontend.core.domain.models.AuthToken
+
+sealed class AppAction {
+  // Auth Actions
+  sealed class Auth : AppAction() {
+    data class LoginStart(val username: String, val password: String) : Auth()
+    data class LoginSuccess(val user: User, val token: AuthToken) : Auth()
+    data class LoginFailure(val error: String) : Auth()
+    object Logout : Auth()
+    data class RefreshToken(val newToken: AuthToken) : Auth()
+  }
+
+  // Navigation Actions
+  sealed class Navigation : AppAction() {
+    data class NavigateTo(val route: String) : Navigation()
+    object NavigateBack : Navigation()
+    data class UpdateHistory(val route: String) : Navigation()
+  }
+
+  // UI Actions
+  sealed class UI : AppAction() {
+    object ToggleDarkMode : UI()
+    data class SetLoading(val isLoading: Boolean) : UI()
+    data class ShowNotification(val notification: Notification) : UI()
+    data class DismissNotification(val id: String) : UI()
+  }
+
+  // Network Actions
+  sealed class Network : AppAction() {
+    data class SetOnlineStatus(val isOnline: Boolean) : Network()
+    data class UpdateLastSync(val timestamp: String) : Network()
+  }
+}

_backup/shared/src/commonMain/kotlin/at/mocode/shared/presentation/state/AppState.kt

@@ -0,0 +1,55 @@
+package at.mocode.shared.presentation.state
+
+import kotlinx.serialization.Serializable
+import at.mocode.frontend.core.domain.models.User
+import at.mocode.frontend.core.domain.models.AuthToken
+
+@Serializable
+data class AppState(
+  val auth: AuthState = AuthState(),
+  val navigation: NavigationState = NavigationState(),
+  val ui: UiState = UiState(),
+  val network: NetworkState = NetworkState()
+)
+
+@Serializable
+data class AuthState(
+  val isAuthenticated: Boolean = false,
+  val user: User? = null,
+  val token: AuthToken? = null,
+  val isLoading: Boolean = false,
+  val error: String? = null
+)
+
+@Serializable
+data class NavigationState(
+  val currentRoute: String = "/",
+  val history: List<String> = emptyList(),
+  val canGoBack: Boolean = false
+)
+
+@Serializable
+data class UiState(
+  val isDarkMode: Boolean = false,
+  val isLoading: Boolean = false,
+  val notifications: List<Notification> = emptyList()
+)
+
+@Serializable
+data class NetworkState(
+  val isOnline: Boolean = true,
+  val lastSync: String? = null
+)
+
+@Serializable
+data class Notification(
+  val id: String,
+  val title: String,
+  val message: String,
+  val type: NotificationType = NotificationType.INFO,
+  val timestamp: String
+)
+
+enum class NotificationType {
+  INFO, SUCCESS, WARNING, ERROR
+}

_backup/shared/src/commonMain/kotlin/at/mocode/shared/presentation/store/AppStore.kt

@@ -0,0 +1,156 @@
+package at.mocode.shared.presentation.store
+
+import at.mocode.shared.presentation.state.AppState
+import at.mocode.shared.presentation.actions.AppAction
+import at.mocode.shared.presentation.state.AuthState
+import at.mocode.shared.presentation.state.NavigationState
+import at.mocode.shared.presentation.state.NetworkState
+import at.mocode.shared.presentation.state.UiState
+import kotlinx.coroutines.*
+import kotlinx.coroutines.flow.*
+
+class AppStore(
+  private val dispatcher: CoroutineDispatcher = Dispatchers.Main
+) {
+  private val scope = CoroutineScope(SupervisorJob() + dispatcher)
+  private val _state = MutableStateFlow(AppState())
+
+  val state: StateFlow<AppState> = _state.asStateFlow()
+
+  fun dispatch(action: AppAction) {
+    scope.launch {
+      val currentState = _state.value
+      val newState = reduce(currentState, action)
+      _state.value = newState
+
+      // Handle side effects
+      handleSideEffect(action, newState)
+    }
+  }
+
+  private fun reduce(currentState: AppState, action: AppAction): AppState {
+    return when (action) {
+      is AppAction.Auth -> currentState.copy(
+        auth = reduceAuth(currentState.auth, action)
+      )
+
+      is AppAction.Navigation -> currentState.copy(
+        navigation = reduceNavigation(currentState.navigation, action)
+      )
+
+      is AppAction.UI -> currentState.copy(
+        ui = reduceUI(currentState.ui, action)
+      )
+
+      is AppAction.Network -> currentState.copy(
+        network = reduceNetwork(currentState.network, action)
+      )
+    }
+  }
+
+  private fun reduceAuth(currentAuth: AuthState, action: AppAction.Auth): AuthState {
+    return when (action) {
+      is AppAction.Auth.LoginStart -> currentAuth.copy(
+        isLoading = true,
+        error = null
+      )
+
+      is AppAction.Auth.LoginSuccess -> currentAuth.copy(
+        isAuthenticated = true,
+        user = action.user,
+        token = action.token,
+        isLoading = false,
+        error = null
+      )
+
+      is AppAction.Auth.LoginFailure -> currentAuth.copy(
+        isAuthenticated = false,
+        user = null,
+        token = null,
+        isLoading = false,
+        error = action.error
+      )
+
+      is AppAction.Auth.Logout -> AuthState()
+      is AppAction.Auth.RefreshToken -> currentAuth.copy(
+        token = action.newToken
+      )
+    }
+  }
+
+  private fun reduceNavigation(currentNav: NavigationState, action: AppAction.Navigation): NavigationState {
+    return when (action) {
+      is AppAction.Navigation.NavigateTo -> currentNav.copy(
+        currentRoute = action.route,
+        history = currentNav.history + currentNav.currentRoute,
+        canGoBack = true
+      )
+
+      is AppAction.Navigation.NavigateBack -> {
+        val newHistory = currentNav.history.dropLast(1)
+        currentNav.copy(
+          currentRoute = newHistory.lastOrNull() ?: "/",
+          history = newHistory,
+          canGoBack = newHistory.isNotEmpty()
+        )
+      }
+
+      is AppAction.Navigation.UpdateHistory -> currentNav.copy(
+        currentRoute = action.route
+      )
+    }
+  }
+
+  private fun reduceUI(currentUI: UiState, action: AppAction.UI): UiState {
+    return when (action) {
+      is AppAction.UI.ToggleDarkMode -> currentUI.copy(
+        isDarkMode = !currentUI.isDarkMode
+      )
+
+      is AppAction.UI.SetLoading -> currentUI.copy(
+        isLoading = action.isLoading
+      )
+
+      is AppAction.UI.ShowNotification -> currentUI.copy(
+        notifications = currentUI.notifications + action.notification
+      )
+
+      is AppAction.UI.DismissNotification -> currentUI.copy(
+        notifications = currentUI.notifications.filter { it.id != action.id }
+      )
+    }
+  }
+
+  private fun reduceNetwork(currentNetwork: NetworkState, action: AppAction.Network): NetworkState {
+    return when (action) {
+      is AppAction.Network.SetOnlineStatus -> currentNetwork.copy(
+        isOnline = action.isOnline
+      )
+
+      is AppAction.Network.UpdateLastSync -> currentNetwork.copy(
+        lastSync = action.timestamp
+      )
+    }
+  }
+
+  private suspend fun handleSideEffect(action: AppAction, newState: AppState) {
+    when (action) {
+      is AppAction.Auth.LoginSuccess -> {
+        // Auto-save token to local storage
+        // TODO: Implement storage
+      }
+
+      is AppAction.Auth.Logout -> {
+        // Clear local storage
+        // TODO: Implement storage cleanup
+      }
+
+      else -> { /* No side effects */
+      }
+    }
+  }
+
+  fun cleanup() {
+    scope.cancel()
+  }
+}

_backup/shared/src/desktopMain/kotlin/at/mocode/shared/network/TimeDesktop.kt

@@ -0,0 +1,3 @@
+package at.mocode.shared.network
+
+actual fun currentTimeMillis(): Long = System.currentTimeMillis()

_backup/shared/src/jsMain/kotlin/at/mocode/shared/network/TimeJs.kt

@@ -0,0 +1,5 @@
+package at.mocode.shared.network
+
+import kotlin.js.Date
+
+actual fun currentTimeMillis(): Long = Date().getTime().toLong()

_backup/shared/src/jvmMain/kotlin/at/mocode/shared/network/TimeJvm.kt

@@ -0,0 +1,3 @@
+package at.mocode.shared.network
+
+actual fun currentTimeMillis(): Long = System.currentTimeMillis()