### Configure Connectivity with Auto-Start

Source: https://github.com/jordond/connectivity/blob/main/README.MD

Initialize the Connectivity object with options to automatically start monitoring network connectivity upon creation.

```kotlin
val connectivity = Connectivity {
    autoStart = true
}
```

--------------------------------

### Manually Start and Stop Monitoring

Source: https://github.com/jordond/connectivity/blob/main/README.MD

Control network connectivity monitoring manually by calling `start()` and `stop()` methods on the Connectivity object.

```kotlin
val connectivity = Connectivity()
connectivity.start()

// At some later point
connectivity.stop()
```

--------------------------------

### Add Dependencies for Single Platform (Android)

Source: https://github.com/jordond/connectivity/blob/main/README.MD

Example of adding Connectivity dependencies for a single platform project targeting Android. Includes core, Android-specific, and Compose support.

```kotlin
dependencies {
  implementation(libs.connectivity.core)
  implementation(libs.connectivity.android)

  // For compose support
  implementation(libs.connectivity.compose.device)
}
```

--------------------------------

### Add Dependencies for Multiplatform (Android & Apple Devices)

Source: https://github.com/jordond/connectivity/blob/main/README.MD

Example of adding Connectivity dependencies for a multiplatform project targeting both Android and Apple devices. Includes core, device-level, and Compose support for common platforms.

```kotlin
kotlin {
    sourceSets {
        commonMain.dependencies {
          implementation(libs.connectivity.core)
          implementation(libs.connectivity.device)

          // For compose support
          implementation(libs.connectivity.compose.device)
        }
    }
}
```

--------------------------------

### Observe Network Status Updates with Connectivity

Source: https://context7.com/jordond/connectivity/llms.txt

Collect continuous network status updates using the `Connectivity` interface. Ensure the `Connectivity` instance is started before collecting. The `status()` function can be used for a one-shot query without starting monitoring.

```kotlin
import dev.jordond.connectivity.Connectivity
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.launch

val scope = CoroutineScope(Dispatchers.Default)

// Collect continuous status updates
val connectivity: Connectivity = Connectivity(/* platform provider */, scope = scope)
connectivity.start()

scope.launch {
    connectivity.statusUpdates.collect { status: Connectivity.Status ->
        when {
            status.isConnected  -> println("Connected (metered=${status.isMetered})")
            status.isDisconnected -> println("Disconnected")
        }
    }
}

// Observe monitoring state
scope.launch {
    connectivity.monitoring.collect { isMonitoring ->
        println("Monitoring active: $isMonitoring")
    }
}

// One-shot query (does not require start())
scope.launch {
    val current = connectivity.status()
    println("Current: $current") // Connected(metered=false) or Disconnected
}

// Stop when done
connectivity.stop()
```

--------------------------------

### Observe Network Connectivity Status

Source: https://github.com/jordond/connectivity/blob/main/README.MD

Instantiate the Connectivity object, start monitoring, and collect status updates within a coroutine scope. Handles Connected and Disconnected states.

```kotlin
val connectivity = Connectivity()
connectivity.start()
coroutineScope.launch {
  connectivity.statusUpdates.collect { status ->
    when (status) {
      is Connectivity.Status.Connected -> println("Connected to network")
      is Connectivity.Status.Disconnected -> println("Disconnected from network")
    }
  }
}
```

--------------------------------

### Compose Multiplatform Network Status

Source: https://github.com/jordond/connectivity/blob/main/README.MD

Use the `rememberConnectivityState` composable to get the network status in Compose Multiplatform applications. Allows optional configuration of ConnectivityOptions.

```kotlin
@Composable
fun MyApp() {
  val state = rememberConnectivityState {
    // Optional configurator for ConnectivityOptions
    autoStart = true
  }

  when (state.status) {
    is Connectivity.Status.Connected -> Text("Connected to network")
    is Connectivity.Status.Disconnected -> Text("Disconnected from network")
    else -> {}
  }
}
```

--------------------------------

### Get Current Network Connectivity Status

Source: https://github.com/jordond/connectivity/blob/main/README.MD

Retrieve the current network status by calling the suspended `status()` function. Useful for immediate checks without continuous observation.

```kotlin
val connectivity = Connectivity()
coroutineScope.launch {
    val status = connectivity.status()
    when (status) {
        is Connectivity.Status.Connected -> println("Connected to network")
        is Connectivity.Status.Disconnected -> println("Disconnected from network")
    }
}
```

--------------------------------

### Configure Connectivity with ConnectivityOptions

Source: https://context7.com/jordond/connectivity/llms.txt

Configure the `Connectivity` instance using `ConnectivityOptions`. The `autoStart` option, defaulting to `false`, determines if monitoring begins immediately upon creation. Options can be set via the constructor or a builder DSL.

```kotlin
import dev.jordond.connectivity.ConnectivityOptions
import dev.jordond.connectivity.Connectivity

// Constructor
val opts1 = ConnectivityOptions(autoStart = true)

// Builder DSL (used inside Connectivity { } factory)
val opts2 = ConnectivityOptions.build {
    autoStart = true
}

// Passed to the factory
val connectivity = Connectivity(provider = myProvider, options = opts1)

// Or inline in the factory lambda overload
val connectivity2 = Connectivity(provider = myProvider) {
    autoStart = true
}
```

--------------------------------

### Add Dependencies for Multiplatform Project

Source: https://github.com/jordond/connectivity/blob/main/README.MD

Add these dependencies to your multiplatform project to support all target platforms. It uses `connectivity-device` for mobile and `connectivity-http` for others.

```kotlin
kotlin {
    sourceSets {
        commonMain.dependencies {
          implementation(libs.connectivity.core)

          // For compose support
          implementation(libs.connectivity.compose)
        }

        val deviceMain by creating {
            dependsOn(commonMain.get())
            androidMain.get().dependsOn(this)
            appleMain.get().dependsOn(this)
            dependencies {
              implementation(libs.connectivity.device)

              // For compose support
              implementation(libs.connectivity.compose.device)
            }
        }

        val httpMain by creating {
            dependsOn(commonMain.get())
            jvmMain.get().dependsOn(this)
            jsMain.get().dependsOn(this)
            wasmJsMain.get().dependsOn(this)
            dependencies {
              implementation(libs.connectivity.http)

              // For compose support
              implementation(libs.connectivity.compose.http)
            }
        }
    }
}
```

--------------------------------

### Implement Device Connectivity

Source: https://github.com/jordond/connectivity/blob/main/README.MD

Provides the actual implementation of the createConnectivity function for device-specific monitoring. It configures the Connectivity object with auto-start enabled.

```kotlin
actual fun createConnectivityState(): Connectivity {
  return Connectivity {
    autoStart = true
  }
}
```

--------------------------------

### Implement ConnectivityProvider Interface

Source: https://context7.com/jordond/connectivity/llms.txt

Implement this interface to plug in a custom network source. Alternatively, use the extension function `Flow<Connectivity.Status>.asProvider()` to wrap any existing flow.

```kotlin
import dev.jordond.connectivity.Connectivity
import dev.jordond.connectivity.ConnectivityProvider
import dev.jordond.connectivity.asProvider
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.flowOf

// Manual implementation
val customProvider = object : ConnectivityProvider {
    override fun monitor(): Flow<Connectivity.Status> =
        flowOf(
            Connectivity.Status.Connected(metered = false),
            Connectivity.Status.Disconnected,
        )
}

// Factory function shorthand
val providerFromFlow = ConnectivityProvider(
    flow = flowOf(Connectivity.Status.Connected(metered = true))
)

// Extension on Flow
val flowProvider = flowOf(Connectivity.Status.Disconnected).asProvider()

// Wire into Connectivity
val connectivity = Connectivity(provider = customProvider)
```

--------------------------------

### Use Connectivity State in Compose UI

Source: https://github.com/jordond/connectivity/blob/main/README.MD

Demonstrates how to use the createConnectivityState function within a Compose Multiplatform UI. It displays different text based on the network connection status.

```kotlin
@Composable
fun MyApp() {
  val state = createConnectivityState()

  when (state.status) {
    is Connectivity.Status.Connected -> Text("Connected to network")
    is Connectivity.Status.Disconnected -> Text("Disconnected from network")
    else -> {}
  }
}
```

--------------------------------

### HttpConnectivityOptions Configuration

Source: https://context7.com/jordond/connectivity/llms.txt

Construct HttpConnectivityOptions directly or using a builder DSL. Supports direct construction, companion builder, or extension on ConnectivityOptions.

```kotlin
import dev.jordond.connectivity.HttpConnectivityOptions
import dev.jordond.connectivity.ConnectivityOptions

// Direct constructor
val opts = HttpConnectivityOptions(
    options           = ConnectivityOptions(autoStart = true),
    urls              = listOf("1.1.1.1", "8.8.8.8"),
    port              = 80,
    timeoutMs         = 1_500L,
    pollingIntervalMs = 30_000L,   // 30 seconds
    onPollResult      = { result -> println(result) },
)

// Builder via companion
val opts2 = HttpConnectivityOptions.build {
    autoStart         = true
    urls("1.1.1.1", "8.8.8.8")
    port              = 80
    timeoutMs         = 1_500L
    pollingIntervalMs = 30_000L
}

// Extension on ConnectivityOptions.Companion
val opts3 = ConnectivityOptions.http {
    urls("example.com")
    pollingIntervalMs = 1.minutes
}

val connectivity = Connectivity(options = opts2)
```

--------------------------------

### Implement HTTP Connectivity

Source: https://github.com/jordond/connectivity/blob/main/README.MD

Provides the actual implementation of the createConnectivity function for HTTP monitoring. It configures the Connectivity object with multiple URLs, port, polling interval, and timeout.

```kotlin
actual fun createConnectivityState(): Connectivity {
  return Connectivity {
    autoStart = true
    urls("cloudflare.com", "my-own-domain.com")
    port = 80
    pollingIntervalMs = 10.minutes
    timeoutMs = 5.seconds
  }
}
```

--------------------------------

### Configure and Use HTTP Connectivity

Source: https://context7.com/jordond/connectivity/llms.txt

Configure HTTP connectivity with custom URLs, polling intervals, and timeouts. Handles poll results and collects status updates. Requires CoroutineScope.

```kotlin
// implementation("dev.jordond.connectivity:connectivity-http:<version>")

import dev.jordond.connectivity.Connectivity
import dev.jordond.connectivity.HttpConnectivityOptions
import dev.jordond.connectivity.PollResult
import dev.jordond.connectivity.force
import io.ktor.client.HttpClient
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Dispatchers

val scope = CoroutineScope(Dispatchers.Default)

val connectivity = Connectivity(scope = scope) {
    autoStart         = true
    urls("cloudflare.com", "my-api.example.com")
    port              = 443          // HTTPS
    pollingIntervalMs = 2.minutes    // poll every 2 min
    timeoutMs         = 3.seconds    // per-request timeout

    onPollResult { result ->
        when (result) {
            is PollResult.Response -> println("HTTP ${result.response.status} — success=${result.isSuccess}")
            is PollResult.Error    -> println("Poll error: ${result.throwable.message}")
        }
    }
}

// Force an immediate check outside the polling interval
connectivity.force()

// Collect results
scope.kotlinx.coroutines.launch {
    connectivity.statusUpdates.collect { status ->
        println(if (status.isConnected) "Reachable" else "Unreachable")
    }
}
```

--------------------------------

### Remember Native Connectivity State (Device Compose)

Source: https://context7.com/jordond/connectivity/llms.txt

Use this composable factory for Android and Apple targets to create and remember a native `Connectivity` instance. Lifecycle management is handled internally.

```kotlin
// implementation("dev.jordond.connectivity:connectivity-compose-device:<version>")

import androidx.compose.runtime.Composable
import androidx.compose.material3.Button
import androidx.compose.material3.Text
import dev.jordond.connectivity.compose.rememberConnectivityState

@Composable
fun NetworkStatusCard() {
    // Builder-DSL variant — options are remembered
    val state = rememberConnectivityState {
        autoStart = true
    }

    Text("Monitoring: ${state.isMonitoring}")
    Text("Status: ${if (state.isConnected) "Connected" else "Disconnected"}")

    Button(onClick = {
        if (state.isMonitoring) state.stopMonitoring()
        else state.startMonitoring()
    }) {
        Text(if (state.isMonitoring) "Stop" else "Start")
    }
}
```

--------------------------------

### Dependency Versions for Connectivity Library

Source: https://github.com/jordond/connectivity/blob/main/README.MD

Defines the version for the Connectivity library and lists the modules available for inclusion in a project. This uses the TOML format for dependency management.

```toml
[versions]
connectivity = "2.2.1"

[libraries]
connectivity-core = { module = "dev.jordond.connectivity:connectivity-core", version.ref = "connectivity" }
connectivity-device = { module = "dev.jordond.connectivity:connectivity-device", version.ref = "connectivity" }
connectivity-android = { module = "dev.jordond.connectivity:connectivity-android", version.ref = "connectivity" }
connectivity-apple = { module = "dev.jordond.connectivity:connectivity-apple", version.ref = "connectivity" }
connectivity-http = { module = "dev.jordond.connectivity:connectivity-http", version.ref = "connectivity" }
connectivity-compose = { module = "dev.jordond.connectivity:connectivity-compose", version.ref = "connectivity" }
connectivity-compose-device = { module = "dev.jordond.connectivity:connectivity-compose-device", version.ref = "connectivity" }
connectivity-compose-http = { module = "dev.jordond.connectivity:connectivity-compose-http", version.ref = "connectivity" }
```

--------------------------------

### Multiplatform Device: DeviceConnectivity / Connectivity() (connectivity-device)

Source: https://context7.com/jordond/connectivity/llms.txt

A multiplatform solution that resolves to `AndroidConnectivity` or `AppleConnectivity` based on the target platform, suitable for KMP modules targeting both Android and Apple without HTTP fallback.

```APIDOC
## Multiplatform Device: DeviceConnectivity / Connectivity() (connectivity-device)

`expect fun Connectivity(...)` resolved per-platform to `AndroidConnectivity` or `AppleConnectivity`. Use this artifact for KMP modules that target both Android and Apple without HTTP fallback.

### Network Monitor Example
```kotlin
import dev.jordond.connectivity.Connectivity
import dev.jordond.connectivity.ConnectivityOptions
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.flow.launchIn
import kotlinx.coroutines.flow.onEach

class NetworkMonitor(private val scope: CoroutineScope = CoroutineScope(Dispatchers.Default)) {

    private val connectivity = Connectivity(
        options = ConnectivityOptions(autoStart = false),
        scope = scope,
    )

    fun start() {
        connectivity.start()
        connectivity.statusUpdates
            .onEach { status ->
                if (status.isDisconnected) notifyOffline()
                else notifyOnline(status.isMetered)
            }
            .launchIn(scope)
    }

    fun stop() = connectivity.stop()

    private fun notifyOffline() { /* … */ }
    private fun notifyOnline(metered: Boolean) { /* … */ }
}
```
```

--------------------------------

### Connectivity() Factory

Source: https://context7.com/jordond/connectivity/llms.txt

Initialize and configure the HTTP Connectivity service. This factory allows customization of polling hosts, intervals, timeouts, and callbacks.

```APIDOC
## Connectivity() Factory (connectivity-http)

Polls a list of hosts over HTTP/HTTPS to determine connectivity. Useful for JVM, JS/WASM, or any platform that needs internet reachability (not just link-layer connectivity). Default hosts: `google.com`, `github.com`, `bing.com` on port 443. Default polling interval: 5 minutes. Default timeout: 2 seconds.

```kotlin
// implementation("dev.jordond.connectivity:connectivity-http:<version>")

import dev.jordond.connectivity.Connectivity
import dev.jordond.connectivity.HttpConnectivityOptions
import dev.jordond.connectivity.PollResult
import dev.jordond.connectivity.force
import io.ktor.client.HttpClient
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Dispatchers

val scope = CoroutineScope(Dispatchers.Default)

val connectivity = Connectivity(scope = scope) {
    autoStart         = true
    urls("cloudflare.com", "my-api.example.com")
    port              = 443          // HTTPS
    pollingIntervalMs = 2.minutes    // poll every 2 min
    timeoutMs         = 3.seconds    // per-request timeout

    onPollResult { result ->
        when (result) {
            is PollResult.Response -> println("HTTP ${result.response.status} — success=${result.isSuccess}")
            is PollResult.Error    -> println("Poll error: ${result.throwable.message}")
        }
    }
}

// Force an immediate check outside the polling interval
connectivity.force()

// Collect results
scope.kotlinx.coroutines.launch {
    connectivity.statusUpdates.collect { status ->
        println(if (status.isConnected) "Reachable" else "Unreachable")
    }
}
```
```

--------------------------------

### HttpConnectivityOptions

Source: https://context7.com/jordond/connectivity/llms.txt

Configure HTTP-specific options for connectivity monitoring, including URLs, port, timeout, polling interval, and callbacks.

```APIDOC
## HttpConnectivityOptions

Full options class for HTTP-based monitoring. Can be constructed directly or via the builder DSL. Wraps a `ConnectivityOptions` for the `autoStart` flag.

```kotlin
import dev.jordond.connectivity.HttpConnectivityOptions
import dev.jordond.connectivity.ConnectivityOptions

// Direct constructor
val opts = HttpConnectivityOptions(
    options           = ConnectivityOptions(autoStart = true),
    urls              = listOf("1.1.1.1", "8.8.8.8"),
    port              = 80,
    timeoutMs         = 1_500L,
    pollingIntervalMs = 30_000L,   // 30 seconds
    onPollResult      = { result -> println(result) },
)

// Builder via companion
val opts2 = HttpConnectivityOptions.build {
    autoStart         = true
    urls("1.1.1.1", "8.8.8.8")
    port              = 80
    timeoutMs         = 1_500L
    pollingIntervalMs = 30_000L
}

// Extension on ConnectivityOptions.Companion
val opts3 = ConnectivityOptions.http {
    urls("example.com")
    pollingIntervalMs = 1.minutes
}

val connectivity = Connectivity(options = opts2)
```
```

--------------------------------

### Custom ConnectivityProvider with Connectivity() Core Factory

Source: https://context7.com/jordond/connectivity/llms.txt

The generic `Connectivity(provider, options, scope)` factory accepts any `ConnectivityProvider`, enabling custom implementations for tests, mock environments, or bespoke platform integrations.

```APIDOC
## Custom ConnectivityProvider with Connectivity() Core Factory

The generic `Connectivity(provider, options, scope)` factory accepts any `ConnectivityProvider`, enabling custom implementations — for tests, mock environments, or bespoke platform integrations.

```kotlin
import dev.jordond.connectivity.Connectivity
import dev.jordond.connectivity.ConnectivityOptions
import dev.jordond.connectivity.ConnectivityProvider
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.MutableSharedFlow
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.launch

// Fake provider useful in tests
class FakeConnectivityProvider : ConnectivityProvider {
    val statusFlow = MutableSharedFlow<Connectivity.Status>(replay = 1)
    override fun monitor(): Flow<Connectivity.Status> = statusFlow
}

val fake = FakeConnectivityProvider()
val scope = CoroutineScope(Dispatchers.Default)

val connectivity = Connectivity(
    provider = fake,
    options  = ConnectivityOptions(autoStart = true),
    scope    = scope,
)

scope.launch {
    connectivity.statusUpdates.collect { println(it) }
}

// Simulate network changes from tests
fake.statusFlow.emit(Connectivity.Status.Connected(metered = false))
fake.statusFlow.emit(Connectivity.Status.Disconnected)
```
```

--------------------------------

### Remember HTTP-Polling Connectivity State (HTTP Compose)

Source: https://context7.com/jordond/connectivity/llms.txt

This composable factory creates and remembers an HTTP-polling `Connectivity` instance for platforms lacking native network APIs (JVM, JS/WASM). Configure polling intervals and timeouts as needed.

```kotlin
// implementation("dev.jordond.connectivity:connectivity-compose-http:<version>")

import androidx.compose.runtime.Composable
import androidx.compose.material3.Text
import dev.jordond.connectivity.compose.rememberConnectivityState

@Composable
fun HttpNetworkIndicator() {
    val state = rememberConnectivityState {
        autoStart         = true
        urls("cloudflare.com", "github.com")
        pollingIntervalMs = 1.minutes
        timeoutMs         = 3.seconds
    }

    Text(if (state.isConnected) "🟢 Online" else "🔴 Offline")
}
```

--------------------------------

### Custom ConnectivityProvider Factory

Source: https://context7.com/jordond/connectivity/llms.txt

Create a custom `Connectivity` instance using the generic factory by providing a `ConnectivityProvider`, `ConnectivityOptions`, and a `CoroutineScope`. This is useful for testing or custom integrations.

```kotlin
import dev.jordond.connectivity.Connectivity
import dev.jordond.connectivity.ConnectivityOptions
import dev.jordond.connectivity.ConnectivityProvider
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.MutableSharedFlow
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.launch

// Fake provider useful in tests
class FakeConnectivityProvider : ConnectivityProvider {
    val statusFlow = MutableSharedFlow<Connectivity.Status>(replay = 1)
    override fun monitor(): Flow<Connectivity.Status> = statusFlow
}

val fake = FakeConnectivityProvider()
val scope = CoroutineScope(Dispatchers.Default)

val connectivity = Connectivity(
    provider = fake,
    options  = ConnectivityOptions(autoStart = true),
    scope    = scope,
)

scope.launch {
    connectivity.statusUpdates.collect { println(it) }
}

// Simulate network changes from tests
fake.statusFlow.emit(Connectivity.Status.Connected(metered = false))
fake.statusFlow.emit(Connectivity.Status.Disconnected)
```

--------------------------------

### Custom HTTP Monitoring Configuration

Source: https://github.com/jordond/connectivity/blob/main/README.MD

Customize HTTP monitoring by specifying target URLs, port, polling interval, and timeout. Includes an optional callback for poll results.

```kotlin
val connectivity = Connectivity {
  urls("cloudflare.com", "my-own-domain.com") // Defaults to ["google.com", "github.com", "bing.com"]
  port = 80 // Defaults to 443
  pollingIntervalMs = 10.minutes // Defaults to 5 minutes
  timeoutMs = 5.seconds // Defaults to 2 seconds

  // Callback for when a poll is completed
  onPollResult { result ->
    when (result) {
      is PollResult.Error -> println("Poll error: ${result.error}")
      is PollResult.Response -> println("Poll http response: ${result.response}")
    }
  }
}
```

--------------------------------

### Multiplatform Device Connectivity

Source: https://context7.com/jordond/connectivity/llms.txt

Uses the `expect fun Connectivity(...)` which resolves to AndroidConnectivity or AppleConnectivity per platform. Suitable for KMP modules targeting both Android and Apple without HTTP fallback.

```kotlin
// commonMain
// implementation("dev.jordond.connectivity:connectivity-device:<version>")

import dev.jordond.connectivity.Connectivity
import dev.jordond.connectivity.ConnectivityOptions
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.flow.launchIn
import kotlinx.coroutines.flow.onEach

class NetworkMonitor(private val scope: CoroutineScope = CoroutineScope(Dispatchers.Default)) {

    // expect fun — resolved to Android or Apple implementation at compile time
    private val connectivity = Connectivity(
        options = ConnectivityOptions(autoStart = false),
        scope = scope,
    )

    fun start() {
        connectivity.start()
        connectivity.statusUpdates
            .onEach { status ->
                if (status.isDisconnected) notifyOffline()
                else notifyOnline(status.isMetered)
            }
            .launchIn(scope)
    }

    fun stop() = connectivity.stop()

    private fun notifyOffline() { /* … */ }
    private fun notifyOnline(metered: Boolean) { /* … */ }
}
```

--------------------------------

### Apple: Connectivity() / AppleConnectivity() Factory

Source: https://context7.com/jordond/connectivity/llms.txt

Platform-specific factory for iOS, macOS, and tvOS using `NWPathMonitor` from the `Network` framework.

```APIDOC
## Apple: Connectivity() / AppleConnectivity() Factory

Platform-specific factory for iOS, macOS, and tvOS. Uses `NWPathMonitor` from the `Network` framework internally.

### Explicit Apple Factory
```kotlin
import dev.jordond.connectivity.AppleConnectivity
import dev.jordond.connectivity.Connectivity
import dev.jordond.connectivity.ConnectivityOptions
import kotlinx.coroutines.MainScope

val connectivity: Connectivity = AppleConnectivity(
    options = ConnectivityOptions(autoStart = true),
    scope = MainScope(),
)

connectivity.start()
```

### Generic Connectivity() Factory on Apple Targets
```kotlin
import dev.jordond.connectivity.Connectivity

val connectivity2: Connectivity = Connectivity {
    autoStart = true
}
```
```

--------------------------------

### Android Connectivity Factory

Source: https://context7.com/jordond/connectivity/llms.txt

Platform-specific factory for Android, relying on ContextProvider auto-initialized via androidx.startup. Uses ConnectivityManager + NetworkCallback internally.

```kotlin
// build.gradle.kts (Android-only project)
// implementation("dev.jordond.connectivity:connectivity-core:<version>")
// implementation("dev.jordond.connectivity:connectivity-android:<version>")

import dev.jordond.connectivity.Connectivity
import dev.jordond.connectivity.ConnectivityOptions
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Dispatchers

class MyRepository {
    private val scope = CoroutineScope(Dispatchers.Default)

    // No-arg factory — ContextProvider is injected automatically
    private val connectivity = Connectivity(
        options = ConnectivityOptions(autoStart = true),
        scope = scope,
    )

    // Builder-DSL variant
    private val connectivity2 = Connectivity(scope = scope) {
        autoStart = true
    }

    fun observeNetwork(onStatus: (Connectivity.Status) -> Unit) {
        scope.kotlinx.coroutines.launch {
            connectivity.statusUpdates.collect(onStatus)
        }
    }
}
```

--------------------------------

### Android: Connectivity() Factory

Source: https://context7.com/jordond/connectivity/llms.txt

Platform-specific factory for Android that utilizes `ContextProvider` for automatic initialization and `ConnectivityManager` with `NetworkCallback`.

```APIDOC
## Android: Connectivity() Factory

Platform-specific factory for Android. Relies on `ContextProvider` which is auto-initialised via `androidx.startup` (no manual setup required). Uses `ConnectivityManager` + `NetworkCallback` under the hood.

### No-arg Factory
```kotlin
import dev.jordond.connectivity.Connectivity
import dev.jordond.connectivity.ConnectivityOptions
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Dispatchers

class MyRepository {
    private val scope = CoroutineScope(Dispatchers.Default)

    private val connectivity = Connectivity(
        options = ConnectivityOptions(autoStart = true),
        scope = scope,
    )

    fun observeNetwork(onStatus: (Connectivity.Status) -> Unit) {
        scope.kotlinx.coroutines.launch {
            connectivity.statusUpdates.collect(onStatus)
        }
    }
}
```

### Builder-DSL Variant
```kotlin
import dev.jordond.connectivity.Connectivity
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Dispatchers

class MyRepository {
    private val scope = CoroutineScope(Dispatchers.Default)

    private val connectivity2 = Connectivity(scope = scope) {
        autoStart = true
    }
}
```
```

--------------------------------

### Compose: rememberConnectivityState for UI

Source: https://context7.com/jordond/connectivity/llms.txt

Wrap a Connectivity instance in a stable ConnectivityState for use in Compose UI. Displays network status (checking, online, offline, metered).

```kotlin
// implementation("dev.jordond.connectivity:connectivity-compose:<version>")

import androidx.compose.runtime.Composable
import androidx.compose.material3.Text
import dev.jordond.connectivity.Connectivity
import dev.jordond.connectivity.compose.rememberConnectivityState

@Composable
fun NetworkBanner(connectivity: Connectivity) {
    val state = rememberConnectivityState(connectivity)

    when {
        state.status == null     -> Text("Checking…")
        state.isConnected        -> Text("Online${if (state.isMetered) " (metered)" else ""}")
        state.isDisconnected     -> Text("Offline")
    }
}
```

--------------------------------

### ConnectivityProvider Interface

Source: https://context7.com/jordond/connectivity/llms.txt

The low-level ConnectivityProvider interface allows for custom network status monitoring. You can implement this interface directly or use extension functions to wrap existing flows.

```APIDOC
## ConnectivityProvider Interface

Low-level abstraction that supplies a `Flow<Connectivity.Status>`.

### Manual Implementation
```kotlin
import dev.jordond.connectivity.Connectivity
import dev.jordond.connectivity.ConnectivityProvider
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.flowOf

val customProvider = object : ConnectivityProvider {
    override fun monitor(): Flow<Connectivity.Status> = 
        flowOf(
            Connectivity.Status.Connected(metered = false),
            Connectivity.Status.Disconnected,
        )
}
```

### Factory Function Shorthand
```kotlin
import dev.jordond.connectivity.ConnectivityProvider
import kotlinx.coroutines.flow.flowOf

val providerFromFlow = ConnectivityProvider(
    flow = flowOf(Connectivity.Status.Connected(metered = true))
)
```

### Extension on Flow
```kotlin
import dev.jordond.connectivity.ConnectivityProvider
import kotlinx.coroutines.flow.flowOf
import dev.jordond.connectivity.asProvider

val flowProvider = flowOf(Connectivity.Status.Disconnected).asProvider()
```

### Wiring into Connectivity
```kotlin
import dev.jordond.connectivity.Connectivity

val connectivity = Connectivity(provider = customProvider)
```
```

--------------------------------

### rememberConnectivityState — HTTP Compose

Source: https://context7.com/jordond/connectivity/llms.txt

Composable factory that creates and remembers an HTTP-polling `Connectivity` instance for platforms without native network APIs (JVM, JS/WASM).

```APIDOC
## rememberConnectivityState — HTTP Compose (connectivity-compose-http)

Composable factory that creates and remembers an HTTP-polling `Connectivity` instance for platforms without native network APIs (JVM, JS/WASM).

```kotlin
// implementation("dev.jordond.connectivity:connectivity-compose-http:<version>")

import androidx.compose.runtime.Composable
import androidx.compose.material3.Text
import dev.jordond.connectivity.compose.rememberConnectivityState

@Composable
fun HttpNetworkIndicator() {
    val state = rememberConnectivityState {
        autoStart         = true
        urls("cloudflare.com", "github.com")
        pollingIntervalMs = 1.minutes
        timeoutMs         = 3.seconds
    }

    Text(if (state.isConnected) "🟢 Online" else "🔴 Offline")
}
```
```

--------------------------------

### Define Expect Connectivity Interface

Source: https://github.com/jordond/connectivity/blob/main/README.MD

Defines the expected interface for creating a Connectivity object in common code. This serves as a contract for platform-specific implementations.

```kotlin
expect fun createConnectivity(): Connectivity
```

--------------------------------

### rememberConnectivityState — Device Compose

Source: https://context7.com/jordond/connectivity/llms.txt

Composable factory for Android and Apple targets that creates and remembers a native `Connectivity` instance internally. It simplifies lifecycle management.

```APIDOC
## rememberConnectivityState — Device Compose (connectivity-compose-device)

Composable factory for Android and Apple targets that creates and remembers a native `Connectivity` instance internally. No need to manage lifecycle manually.

```kotlin
// implementation("dev.jordond.connectivity:connectivity-compose-device:<version>")

import androidx.compose.runtime.Composable
import androidx.compose.material3.Button
import androidx.compose.material3.Text
import dev.jordond.connectivity.compose.rememberConnectivityState

@Composable
fun NetworkStatusCard() {
    // Builder-DSL variant — options are remembered
    val state = rememberConnectivityState {
        autoStart = true
    }

    Text("Monitoring: ${state.isMonitoring}")
    Text("Status: ${if (state.isConnected) "Connected" else "Disconnected"}")

    Button(onClick = {
        if (state.isMonitoring) state.stopMonitoring()
        else state.startMonitoring()
    }) {
        Text(if (state.isMonitoring) "Stop" else "Start")
    }
}
```
```

--------------------------------

### Connectivity.force() Extension

Source: https://context7.com/jordond/connectivity/llms.txt

Manually trigger an immediate HTTP poll, bypassing the regular polling schedule.

```APIDOC
## Connectivity.force() Extension (connectivity-http)

Forces an immediate out-of-schedule HTTP poll on an `HttpConnectivity` instance. If the receiver is not an HTTP-based instance the call is a no-op.

```kotlin
import dev.jordond.connectivity.Connectivity
import dev.jordond.connectivity.force

val connectivity = Connectivity { urls("example.com") }
connectivity.start()

// Trigger an immediate recheck (e.g., after user taps "Retry")
connectivity.force()
```
```

--------------------------------

### Handle Network Status with Connectivity.Status

Source: https://context7.com/jordond/connectivity/llms.txt

Use a sealed `when` expression to handle different network states provided by `Connectivity.Status`. Convenience properties like `isConnected`, `isDisconnected`, and `isMetered` are available for direct checks.

```kotlin
import dev.jordond.connectivity.Connectivity

fun handleStatus(status: Connectivity.Status) {
    // Sealed when expression – exhaustive
    when (status) {
        is Connectivity.Status.Connected -> {
            println("Online, metered=${status.metered}")
            // status.isConnected == true
            // status.isMetered   == status.metered
        }
        is Connectivity.Status.Disconnected -> {
            println("Offline")
            // status.isDisconnected == true
        }
    }

    // Convenience checks without casting
    if (status.isConnected && !status.isMetered) {
        println("On unmetered WiFi/Ethernet — safe for large downloads")
    }
}
```

--------------------------------

### ConnectivityState API Usage

Source: https://context7.com/jordond/connectivity/llms.txt

The `ConnectivityState` holder exposes observable properties and imperative control functions. Use its properties like `isMonitoring`, `isConnected`, and `isMetered` within Composables for UI updates.

```kotlin
import dev.jordond.connectivity.Connectivity
import dev.jordond.connectivity.compose.ConnectivityState

// Properties (all Compose-observable via mutableStateOf):
// state.status        : Connectivity.Status?  — null until first emission
// state.isMonitoring  : Boolean
// state.isConnected   : Boolean
// state.isDisconnected: Boolean
// state.isMetered     : Boolean

// Imperative control:
fun exampleUsage(state: ConnectivityState) {
    state.startMonitoring()   // delegates to connectivity.start()
    state.stopMonitoring()    // delegates to connectivity.stop()
    state.forceCheck()        // one-shot suspend status() in the remembered scope
}

// Typical Composable usage
@androidx.compose.runtime.Composable
fun Indicator(state: ConnectivityState) {
    androidx.compose.material3.Text(
        text = when {
            !state.isMonitoring  -> "Not monitoring"
            state.isConnected    -> "Online${if (state.isMetered) " (metered)" else ""}"
            state.isDisconnected -> "Offline"
            else                 -> "Unknown"
        }
    )
}
```

--------------------------------

### Apple Connectivity Factory

Source: https://context7.com/jordond/connectivity/llms.txt

Platform-specific factory for iOS, macOS, and tvOS using NWPathMonitor from the Network framework. Can use explicit AppleConnectivity or the generic Connectivity() factory.

```kotlin
// commonMain expect — resolved to AppleConnectivityProvider on Apple targets
// build.gradle.kts:
// implementation("dev.jordond.connectivity:connectivity-apple:<version>")

import dev.jordond.connectivity.AppleConnectivity
import dev.jordond.connectivity.Connectivity
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.MainScope

// Explicit Apple factory
val connectivity: Connectivity = AppleConnectivity(
    options = dev.jordond.connectivity.ConnectivityOptions(autoStart = true),
    scope = MainScope(),
)

// Or use the generic Connectivity() factory on Apple targets
val connectivity2: Connectivity = Connectivity {
    autoStart = true
}

connectivity.start()
```

--------------------------------

### Force Immediate HTTP Poll

Source: https://context7.com/jordond/connectivity/llms.txt

Manually trigger an immediate HTTP poll on an HttpConnectivity instance, useful for on-demand checks. This is a no-op if the instance is not HTTP-based.

```kotlin
import dev.jordond.connectivity.Connectivity
import dev.jordond.connectivity.force

val connectivity = Connectivity { urls("example.com") }
connectivity.start()

// Trigger an immediate recheck (e.g., after user taps "Retry")
connectivity.force()
```

--------------------------------

### rememberConnectivityState — Compose

Source: https://context7.com/jordond/connectivity/llms.txt

A Composable function that provides the current connectivity status to Compose UI, managing the lifecycle of the Connectivity instance.

```APIDOC
## rememberConnectivityState — Compose (connectivity-compose)

Base Composable that wraps an existing `Connectivity` instance in a stable `ConnectivityState` holder. Use when you manage the `Connectivity` lifecycle yourself.

```kotlin
// implementation("dev.jordond.connectivity:connectivity-compose:<version>")

import androidx.compose.runtime.Composable
import androidx.compose.material3.Text
import dev.jordond.connectivity.Connectivity
import dev.jordond.connectivity.compose.rememberConnectivityState

@Composable
fun NetworkBanner(connectivity: Connectivity) {
    val state = rememberConnectivityState(connectivity)

    when {
        state.status == null     -> Text("Checking…")
        state.isConnected        -> Text("Online${if (state.isMetered) " (metered)" else ""}")
        state.isDisconnected     -> Text("Offline")
    }
}
```
```

--------------------------------

### ConnectivityState API

Source: https://context7.com/jordond/connectivity/llms.txt

The `ConnectivityState` is the stable Compose state holder returned by all `rememberConnectivityState` variants. It exposes observable state properties and imperative control functions.

```APIDOC
## ConnectivityState API (connectivity-compose)

`ConnectivityState` is the stable Compose state holder returned by all `rememberConnectivityState` variants. It exposes observable state properties and imperative control functions.

```kotlin
import dev.jordond.connectivity.Connectivity
import dev.jordond.connectivity.compose.ConnectivityState

// Properties (all Compose-observable via mutableStateOf):
// state.status        : Connectivity.Status?  — null until first emission
// state.isMonitoring  : Boolean
// state.isConnected   : Boolean
// state.isDisconnected: Boolean
// state.isMetered     : Boolean

// Imperative control:
fun exampleUsage(state: ConnectivityState) {
    state.startMonitoring()   // delegates to connectivity.start()
    state.stopMonitoring()    // delegates to connectivity.stop()
    state.forceCheck()        // one-shot suspend status() in the remembered scope
}

// Typical Composable usage
@androidx.compose.runtime.Composable
fun Indicator(state: ConnectivityState) {
    androidx.compose.material3.Text(
        text = when {
            !state.isMonitoring  -> "Not monitoring"
            state.isConnected    -> "Online${if (state.isMetered) " (metered)" else ""}"
            state.isDisconnected -> "Offline"
            else                 -> "Unknown"
        }
    )
}
```
```

--------------------------------

### Handle Poll Results with PollResult Sealed Interface

Source: https://context7.com/jordond/connectivity/llms.txt

Process poll results using the PollResult sealed interface. Differentiates between successful HTTP responses and errors, providing details for each.

```kotlin
import dev.jordond.connectivity.PollResult

fun logPollResult(result: PollResult) {
    when (result) {
        is PollResult.Response -> {
            val code = result.response.status.value
            println("HTTP $code — ${if (result.isSuccess) "OK" else "FAIL"}")
        }
        is PollResult.Error -> {
            println("Error: ${result.throwable::class.simpleName}: ${result.throwable.message}")
        }
    }
}
```

--------------------------------

### PollResult Sealed Interface

Source: https://context7.com/jordond/connectivity/llms.txt

Represents the outcome of an HTTP poll attempt, either a successful response or an error.

```APIDOC
## PollResult Sealed Interface

Returned to the `onPollResult` callback for each HTTP poll attempt. `Response` wraps a Ktor `HttpResponse` with `isSuccess` / `isFailure` shortcuts. `Error` wraps any `Throwable` (network errors, timeouts, cancellations excluded).

```kotlin
import dev.jordond.connectivity.PollResult

fun logPollResult(result: PollResult) {
    when (result) {
        is PollResult.Response -> {
            val code = result.response.status.value
            println("HTTP $code — ${if (result.isSuccess) "OK" else "FAIL"}")
        }
        is PollResult.Error -> {
            println("Error: ${result.throwable::class.simpleName}: ${result.throwable.message}")
        }
    }
}
```
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.