Observe the path configuration loading state

[jayohms]

This introduces a StateFlow-based loading mechanism for path configuration so apps can observe when the configuration loads and from which source.

Key Changes

PathConfigurationData — New class containing only the serializable configuration data (rules, settings). Extracted from PathConfiguration so the StateFlow emits lightweight data objects rather than the full PathConfiguration instance. Implements equals()/hashCode() so StateFlow properly deduplicates identical emissions.

PathConfigurationLoadState — New sealed class hierarchy: Idle for the initial state, and Loaded with three subclasses (BundledAssetLoaded, CachedRemoteLoaded, RemoteLoaded). Apps can check is Loaded for any successful load, or match on the specific subclass when the source matters.

PathConfigurationLoader — Refactored to return load states directly. Smarter loading order: prefers the cached remote config over the bundled asset. Falls back to bundled only when no cache exists or the cache fails to parse. Remote fetch runs on Dispatchers.IO.

PathConfiguration — Exposes loadState: StateFlow<PathConfigurationLoadState> for app observation. The bundled/cached config loads synchronously (to maintain backwards compatibility) in load() so it's available immediately. The remote fetch runs asynchronously on IO. All state mutations are synchronized for thread safety between the IO loading scope and main-thread reads. If load() is called multiple times, the previous job is cancelled before fetching the configuration again.

Example Usage

// Observe all configuration updates
lifecycleScope.launch {
    Hotwire.config.pathConfiguration.loadState.collect { state ->
        when (state) {
            is PathConfigurationLoadState.NotLoaded -> {
                // Not loaded yet
            }
            is PathConfigurationLoadState.Loaded -> {
                // Configuration available — check settings, update UI, etc.
                val settings = state.configuration.settings
                val properties = state.configuration.properties("https://example.com/home")
            }
        }
    }
}

// Distinguish the source when needed
lifecycleScope.launch {
    Hotwire.config.pathConfiguration.loadState.collect { state ->
        when (state) {
            is PathConfigurationLoadState.NotLoaded -> {}
            is PathConfigurationLoadState.Loaded.BundledAssetLoaded -> {
                // First load from bundled asset (fresh install, no cache)
            }
            is PathConfigurationLoadState.Loaded.CachedRemoteLoaded -> {
                // Loaded from previously cached remote config
            }
            is PathConfigurationLoadState.Loaded.RemoteLoaded -> {
                // Fresh config from the server
            }
        }
    }
}

// One-shot: wait for the first available config
lifecycleScope.launch {
    val loaded = Hotwire.config.pathConfiguration.loadState
        .first { it is PathConfigurationLoadState.Loaded }
    // Configuration is ready
}