### Extend HotwireActivity for Navigation

Source: https://context7.com/hotwired/hotwire-native-android/llms.txt

Activities must extend `HotwireActivity` and provide navigator configurations. This example shows a basic `MainActivity` setup.

```kotlin
import dev.hotwire.navigation.activities.HotwireActivity
import dev.hotwire.navigation.navigator.Navigator
import dev.hotwire.navigation.navigator.NavigatorConfiguration

class MainActivity : HotwireActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
    }

    // Provide navigator configurations for this activity
    override fun navigatorConfigurations(): List<NavigatorConfiguration> {
        return listOf(
            NavigatorConfiguration(
                name = "main",
                startLocation = "https://myapp.com",
                navigatorHostId = R.id.navigator_host
            )
        )
    }

    // Called when a navigator is ready for navigation
    override fun onNavigatorReady(navigator: Navigator) {
        // Navigator and its root destination are ready
        Log.d("MainActivity", "Navigator ${navigator.configuration.name} is ready")
    }
}
```

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

### Navigator: Reset Navigation

Source: https://context7.com/hotwired/hotwire-native-android/llms.txt

Use `navigator.clearAll()` to clear all destinations and reset to the start, or `navigator.reset()` for a full reset including the session.

```kotlin
navigator.clearAll {
    Log.d("Navigator", "Navigation cleared")
}

// Full reset including session
navigator.reset {
    Log.d("Navigator", "Navigator reset complete")
}
```

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

### Define Bottom Tabs and Navigator Configurations

Source: https://context7.com/hotwired/hotwire-native-android/llms.txt

Define a list of HotwireBottomTab objects, each specifying a title, icon, and NavigatorConfiguration. The NavigatorConfiguration includes the navigator name, host ID, and start location. Tabs can be conditionally shown or hidden using the isVisible property.

```kotlin
import dev.hotwire.navigation.tabs.HotwireBottomTab
import dev.hotwire.navigation.tabs.HotwireBottomNavigationController
import dev.hotwire.navigation.tabs.navigatorConfigurations
import dev.hotwire.navigation.navigator.NavigatorConfiguration

// Define tabs
val homeTabs = listOf(
    HotwireBottomTab(
        title = "Home",
        iconResId = R.drawable.ic_home,
        configuration = NavigatorConfiguration(
            name = "home",
            navigatorHostId = R.id.home_navigator_host,
            startLocation = "https://myapp.com"
        )
    ),
    HotwireBottomTab(
        title = "Search",
        iconResId = R.drawable.ic_search,
        configuration = NavigatorConfiguration(
            name = "search",
            navigatorHostId = R.id.search_navigator_host,
            startLocation = "https://myapp.com/search"
        )
    ),
    HotwireBottomTab(
        title = "Profile",
        iconResId = R.drawable.ic_profile,
        isVisible = true,  // Can conditionally show/hide tabs
        configuration = NavigatorConfiguration(
            name = "profile",
            navigatorHostId = R.id.profile_navigator_host,
            startLocation = "https://myapp.com/profile"
        )
    )
)
```

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

### Implement Custom Route Decision Handlers in Kotlin

Source: https://context7.com/hotwired/hotwire-native-android/llms.txt

Define custom route decision handlers for managing how different types of URLs are processed. This example shows handlers for external links and deep links.

```kotlin
import dev.hotwire.core.config.Hotwire
import dev.hotwire.navigation.config.registerRouteDecisionHandlers
import dev.hotwire.navigation.routing.Router
import dev.hotwire.navigation.routing.AppNavigationRouteDecisionHandler
import dev.hotwire.navigation.routing.BrowserTabRouteDecisionHandler
import dev.hotwire.navigation.navigator.NavigatorConfiguration
import dev.hotwire.navigation.activities.HotwireActivity
import android.net.Uri
import androidx.browser.customtabs.CustomTabsIntent
import android.content.Intent
import android.app.Application

// Custom route decision handler for external links
class ExternalLinkHandler : Router.RouteDecisionHandler {
    override val name = "ExternalLinkHandler"

    override fun matches(
        location: String,
        configuration: NavigatorConfiguration
    ): Boolean {
        val appDomain = Uri.parse(configuration.startLocation).host
        val linkDomain = Uri.parse(location).host
        return linkDomain != appDomain
    }

    override fun handle(
        location: String,
        configuration: NavigatorConfiguration,
        activity: HotwireActivity
    ): Router.Decision {
        // Open external links in Chrome Custom Tabs
        val customTabsIntent = CustomTabsIntent.Builder().build()
        customTabsIntent.launchUrl(activity, Uri.parse(location))
        return Router.Decision.CANCEL
    }
}

// Custom handler for deep links
class DeepLinkHandler : Router.RouteDecisionHandler {
    override val name = "DeepLinkHandler"

    override fun matches(
        location: String,
        configuration: NavigatorConfiguration
    ): Boolean {
        return location.startsWith("myapp://")
    }

    override fun handle(
        location: String,
        configuration: NavigatorConfiguration,
        activity: HotwireActivity
    ): Router.Decision {
        // Handle custom deep link
        val intent = Intent(Intent.ACTION_VIEW, Uri.parse(location))
        activity.startActivity(intent)
        return Router.Decision.CANCEL
    }
}

// Register handlers in Application
class MyApplication : Application() {
    override fun onCreate() {
        super.onCreate()

        Hotwire.registerRouteDecisionHandlers(
            AppNavigationRouteDecisionHandler(),  // Default in-app navigation
            ExternalLinkHandler(),
            DeepLinkHandler(),
            BrowserTabRouteDecisionHandler()      // Fallback to browser
        )
    }
}
```

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

### Initialize Hotwire Native Configuration

Source: https://context7.com/hotwired/hotwire-native-android/llms.txt

Configure the `Hotwire` object during application startup. Set default fragment destinations, register all possible fragment destinations, enable debug logging, and load path configurations from local assets or remote URLs.

```kotlin
import dev.hotwire.core.config.Hotwire
import dev.hotwire.core.turbo.config.PathConfiguration
import dev.hotwire.navigation.config.defaultFragmentDestination
import dev.hotwire.navigation.config.registerFragmentDestinations
import dev.hotwire.navigation.config.registerBridgeComponents

class MyApplication : Application() {
    override fun onCreate() {
        super.onCreate()

        // Set the default fragment destination for web requests
        Hotwire.defaultFragmentDestination = WebFragment::class

        // Register all fragment destinations that can be navigated to
        Hotwire.registerFragmentDestinations(
            WebFragment::class,
            WebBottomSheetFragment::class,
            NativeFragment::class
        )

        // Configure debug options (disable in production)
        Hotwire.config.debugLoggingEnabled = BuildConfig.DEBUG
        Hotwire.config.webViewDebuggingEnabled = BuildConfig.DEBUG

        // Set a custom user agent prefix
        Hotwire.config.applicationUserAgentPrefix = "MyApp/1.0;"

        // Load path configuration from local asset and remote URL
        Hotwire.loadPathConfiguration(
            context = this,
            location = PathConfiguration.Location(
                assetFilePath = "json/path-configuration.json",
                remoteFileUrl = "https://myapp.com/api/path-configuration.json"
            )
        )

        // Get WebView information
        val webViewInfo = Hotwire.webViewInfo(this)
        Log.d("WebView", "Version: ${webViewInfo.majorVersion}")
    }
}
```

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

### Activity Main Layout with NavigatorHost

Source: https://context7.com/hotwired/hotwire-native-android/llms.txt

The `activity_main.xml` layout file must include a `FragmentContainerView` with the `NavigatorHost` name to host the navigator.

```xml
<!-- activity_main.xml -->
<androidx.coordinatorlayout.widget.CoordinatorLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent">

    <androidx.fragment.app.FragmentContainerView
        android:id="@+id/navigator_host"
        android:name="dev.hotwire.navigation.navigator.NavigatorHost"
        android:layout_width="match_parent"
        android:layout_height="match_parent" />

</androidx.coordinatorlayout.widget.CoordinatorLayout>
```

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

### Activity with Bottom Navigation Controller

Source: https://context7.com/hotwired/hotwire-native-android/llms.txt

Set up the MainActivity to use HotwireBottomNavigationController. Load the defined tabs and handle tab selection events to update the selected tab index in the ViewModel. Ensure navigatorConfigurations are provided.

```kotlin
import dev.hotwire.navigation.tabs.HotwireBottomTab
import dev.hotwire.navigation.tabs.HotwireBottomNavigationController
import dev.hotwire.navigation.tabs.navigatorConfigurations
import dev.hotwire.navigation.navigator.NavigatorConfiguration

// Activity with bottom navigation
class MainActivity : HotwireActivity() {
    private lateinit var bottomNavigationController: HotwireBottomNavigationController
    private val viewModel: MainViewModel by viewModels()

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        val bottomNav = findViewById<BottomNavigationView>(R.id.bottom_nav)
        bottomNavigationController = HotwireBottomNavigationController(this, bottomNav)
        bottomNavigationController.load(homeTabs, viewModel.selectedTabIndex)

        bottomNavigationController.setOnTabSelectedListener {
            index, tab ->
            viewModel.selectedTabIndex = index
        }
    }

    override fun navigatorConfigurations() = homeTabs.navigatorConfigurations
}
```

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

### Accessing and Observing Path Configuration

Source: https://context7.com/hotwired/hotwire-native-android/llms.txt

Retrieve path configuration properties for a given URL, check presentation modes, contexts, and pull-to-refresh settings. Observe the load state of the path configuration to react to changes.

```kotlin
import dev.hotwire.core.config.Hotwire
import dev.hotwire.core.turbo.config.*

// Access path configuration properties for a URL
val properties = Hotwire.config.pathConfiguration.properties("https://myapp.com/posts/new")

// Check presentation mode
val presentation = properties.presentation  // Presentation.DEFAULT, PUSH, REPLACE, etc.
val context = properties.context            // PresentationContext.DEFAULT or MODAL
val pullToRefresh = properties.pullToRefreshEnabled  // Boolean

// Access custom settings
val settings = Hotwire.config.pathConfiguration.settings
val featureEnabled = settings["enable_feature_x"] as? Boolean ?: false

// Observe load state
Hotwire.config.pathConfiguration.loadState.collect { state ->
    when (state) {
        is PathConfigurationLoadState.NotLoaded -> { /* Initial state */ }
        is PathConfigurationLoadState.Loaded.FromBundledAsset -> { /* Loaded from local */ }
        is PathConfigurationLoadState.Loaded.FromCachedRemote -> { /* Loaded from cache */ }
        is PathConfigurationLoadState.Loaded.FromRemote -> { /* Fresh remote load */ }
    }
}
```

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

### Navigator: Navigate to New Page

Source: https://context7.com/hotwired/hotwire-native-android/llms.txt

Use the `navigator.route()` method to navigate to new locations. Custom `VisitOptions` can be provided, and additional bundle arguments can be passed.

```kotlin
import dev.hotwire.navigation.navigator.Navigator
import dev.hotwire.core.turbo.visit.VisitOptions
import dev.hotwire.core.turbo.visit.VisitAction

class MyFragment : HotwireWebFragment() {

    fun navigateToNewPage() {
        // Route to a location with default options
        navigator.route("https://myapp.com/posts")

        // Route with custom visit options
        navigator.route(
            location = "https://myapp.com/posts/new",
            options = VisitOptions(action = VisitAction.REPLACE)
        )

        // Pass additional bundle arguments
        navigator.route(
            location = "https://myapp.com/posts/1",
            bundle = bundleOf("postId" to 1)
        )
    }

    fun navigateBack() {
        // Pop the backstack
        navigator.pop()
    }

    fun resetNavigation() {
        // Clear all destinations and reset to start
        navigator.clearAll {
            Log.d("Navigator", "Navigation cleared")
        }

        // Full reset including session
        navigator.reset {
            Log.d("Navigator", "Navigator reset complete")
        }
    }

    fun checkNavigatorState() {
        // Check if navigator is ready
        val isReady = navigator.isReady()

        // Check if at start destination
        val isAtStart = navigator.isAtStartDestination()

        // Get current and previous locations
        val currentLocation = navigator.location
        val previousLocation = navigator.previousLocation

        // Access the session
        val session = navigator.session
        val isSessionReady = session.isReady
    }
}
```

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

### Configure Custom WebView Factory

Source: https://context7.com/hotwired/hotwire-native-android/llms.txt

Provide a custom factory function to `Hotwire.config.makeCustomWebView` to create and configure your WebView instance. This allows for detailed customization of WebView settings like JavaScript enablement, DOM storage, and text zoom. Ensure all necessary imports are included.

```kotlin
import dev.hotwire.core.config.Hotwire
import dev.hotwire.core.turbo.webview.HotwireWebView

class MyApplication : Application() {
    override fun onCreate() {
        super.onCreate() 

        // Provide a custom WebView factory
        Hotwire.config.makeCustomWebView = { context ->
            HotwireWebView(context, null).apply {
                settings.apply {
                    // Customize WebView settings
                    javaScriptEnabled = true
                    domStorageEnabled = true
                    databaseEnabled = true
                    mediaPlaybackRequiresUserGesture = false
                    allowFileAccess = false

                    // Set text zoom
                    textZoom = 100
                }
            }
        }

        // Set custom JSON converter for bridge components
        Hotwire.config.jsonConverter = KotlinXJsonConverter()
    }
}
```

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

### Activity Main XML Layout

Source: https://context7.com/hotwired/hotwire-native-android/llms.txt

Define the layout for the activity, including a FrameLayout to contain multiple NavigatorHost instances for each tab and a BottomNavigationView for user interaction.

```xml
<!-- activity_main.xml -->
<LinearLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical">

    <FrameLayout
        android:id="@+id/fragment_container"
        android:layout_width="match_parent"
        android:layout_height="0dp"
        android:layout_weight="1">

        <androidx.fragment.app.FragmentContainerView
            android:id="@+id/home_navigator_host"
            android:name="dev.hotwire.navigation.navigator.NavigatorHost"
            android:layout_width="match_parent"
            android:layout_height="match_parent" />

        <androidx.fragment.app.FragmentContainerView
            android:id="@+id/search_navigator_host"
            android:name="dev.hotwire.navigation.navigator.NavigatorHost"
            android:layout_width="match_parent"
            android:layout_height="match_parent" />

        <androidx.fragment.app.FragmentContainerView
            android:id="@+id/profile_navigator_host"
            android:name="dev.hotwire.navigation.navigator.NavigatorHost"
            android:layout_width="match_parent"
            android:layout_height="match_parent" />
    </FrameLayout>

    <com.google.android.material.bottomnavigation.BottomNavigationView
        android:id="@+id/bottom_nav"
        android:layout_width="match_parent"
        android:layout_height="wrap_content" />

</LinearLayout>
```

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

### Implement WebFragment for Web Destinations

Source: https://context7.com/hotwired/hotwire-native-android/llms.txt

Extend HotwireWebFragment to manage WebView display, loading states, and bridge component integration for web-based destinations. Customize progress and error views, and handle visit errors.

```kotlin
import dev.hotwire.navigation.fragments.HotwireWebFragment
import dev.hotwire.navigation.destinations.HotwireDestinationDeepLink
import dev.hotwire.core.turbo.errors.VisitError
import dev.hotwire.core.turbo.webview.HotwireWebChromeClient

@HotwireDestinationDeepLink(uri = "hotwire://fragment/web")
open class WebFragment : HotwireWebFragment() {

    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)
        setupToolbar()
    }

    // Customize the progress view shown during loading
    override fun createProgressView(location: String): View {
        return layoutInflater.inflate(R.layout.custom_progress, null)
    }

    // Customize the error view shown on visit errors
    override fun createErrorView(error: VisitError): View {
        return layoutInflater.inflate(R.layout.custom_error, null).apply {
            findViewById<TextView>(R.id.error_message).text = error.description()
        }
    }

    // Provide a custom WebChromeClient
    override fun createWebChromeClient(): HotwireWebChromeClient {
        return HotwireWebChromeClient(navigator.session)
    }

    // Handle visit errors
    override fun onVisitErrorReceived(location: String, error: VisitError) {
        when (error) {
            is HttpError.ServerError -> showServerError()
            is HttpError.ClientError -> showClientError()
            else -> super.onVisitErrorReceived(location, error)
        }
    }

    // Called when form submission starts
    override fun onFormSubmissionStarted(location: String) {
        showProgressIndicator()
    }

    // Called when form submission finishes
    override fun onFormSubmissionFinished(location: String) {
        hideProgressIndicator()
    }

    // Refresh the page content
    override fun refresh(displayProgress: Boolean) {
        super.refresh(displayProgress)
    }

    private fun setupToolbar() {
        toolbarForNavigation()?.apply {
            inflateMenu(R.menu.web_menu)
            setOnMenuItemClickListener { item ->
                when (item.itemId) {
                    R.id.action_refresh -> {
                        refresh()
                        true
                    }
                    else -> false
                }
            }
        }
    }
}
```

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

### Implement HotwireFragment for Native Destinations

Source: https://context7.com/hotwired/hotwire-native-android/llms.txt

Extend HotwireFragment for fully native screens that do not display web content. Access path properties, the location, and navigate to other routes. Provide a custom toolbar.

```kotlin
import dev.hotwire.navigation.fragments.HotwireFragment
import dev.hotwire.navigation.destinations.HotwireDestinationDeepLink

@HotwireDestinationDeepLink(uri = "hotwire://fragment/numbers")
class NumbersFragment : HotwireFragment() {

    override fun onCreateView(
        inflater: LayoutInflater,
        container: ViewGroup?,
        savedInstanceState: Bundle?
    ): View {
        return inflater.inflate(R.layout.fragment_numbers, container, false)
    }

    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)

        // Access path properties for this destination
        val title = pathProperties.title ?: "Numbers"
        toolbarForNavigation()?.title = title

        // Access the location
        Log.d("NumbersFragment", "Location: $location")

        // Navigate to another location
        view.findViewById<Button>(R.id.button).setOnClickListener {
            navigator.route("https://myapp.com/numbers/1")
        }
    }

    // Provide the toolbar for navigation
    override fun toolbarForNavigation(): Toolbar? {
        return view?.findViewById(R.id.toolbar)
    }

    override fun onBeforeNavigation() {
        // Clean up state before navigating away
    }
}
```

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

### Manage WebView and Turbo Visits with Session

Source: https://context7.com/hotwired/hotwire-native-android/llms.txt

The Session class manages the WebView instance and Turbo visits, handling page loading, caching, and offline support. Access session state, reset the session, pre-cache locations, and cache snapshots.

```kotlin
import dev.hotwire.core.turbo.session.Session
import dev.hotwire.core.turbo.visit.Visit
import dev.hotwire.core.turbo.visit.VisitOptions
import dev.hotwire.core.turbo.visit.VisitAction

// Access session from navigator
val session = navigator.session

// Check session state
val isReady = session.isReady
val isRenderProcessGone = session.isRenderProcessGone
val currentVisit = session.currentVisit

// Reset the session (forces cold boot on next visit)
session.reset()

// Pre-cache a location for offline use
session.preCacheLocation("https://myapp.com/important-page")

// Cache current page snapshot
session.cacheSnapshot()

// Access WebView
val webView = session.webView

// Access file chooser delegate for file uploads
val fileChooserDelegate = session.fileChooserDelegate

// Access geolocation permission delegate
val geolocationDelegate = session.geolocationPermissionDelegate
```

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

### Navigator: Check State

Source: https://context7.com/hotwired/hotwire-native-android/llms.txt

The `Navigator` class provides methods to check its readiness, current location, previous location, and session status.

```kotlin
// Check if navigator is ready
val isReady = navigator.isReady()

// Check if at start destination
val isAtStart = navigator.isAtStartDestination()

// Get current and previous locations
val currentLocation = navigator.location
val previousLocation = navigator.previousLocation

// Access the session
val session = navigator.session
val isSessionReady = session.isReady
```

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

### Path Configuration JSON Structure

Source: https://context7.com/hotwired/hotwire-native-android/llms.txt

Defines navigation rules for Hotwire Native using URL patterns. Specifies how URLs are presented (push, replace, modal) and which Fragment handles each route, including custom settings and fallback URIs.

```json
{
  "settings": {
    "enable_feature_x": true
  },
  "rules": [
    {
      "patterns": [".*"],
      "properties": {
        "context": "default",
        "uri": "hotwire://fragment/web",
        "fallback_uri": "hotwire://fragment/web",
        "pull_to_refresh_enabled": true
      }
    },
    {
      "patterns": ["^$", "^/$"],
      "properties": {
        "presentation": "clear_all"
      }
    },
    {
      "patterns": ["/new$", "/edit$", "/modal"],
      "properties": {
        "context": "modal",
        "pull_to_refresh_enabled": false
      }
    },
    {
      "patterns": ["/numbers$"],
      "properties": {
        "uri": "hotwire://fragment/numbers",
        "title": "Numbers"
      }
    },
    {
      "patterns": [".+\.(?:jpg|jpeg|png|gif|webp)"],
      "properties": {
        "context": "modal",
        "uri": "hotwire://fragment/image_viewer"
      }
    }
  ]
}
```

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

### Navigator: Navigate Back

Source: https://context7.com/hotwired/hotwire-native-android/llms.txt

Use `navigator.pop()` to remove the current destination from the backstack.

```kotlin
navigator.pop()
```

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

### Create Custom WebView Subclass

Source: https://context7.com/hotwired/hotwire-native-android/llms.txt

Extend `HotwireWebView` to create a custom WebView subclass for advanced customization. Override methods like `onScrollChanged` to implement custom handling for specific events. This allows for more complex behaviors beyond standard WebView functionality.

```kotlin
// Custom WebView subclass for advanced customization
class CustomWebView(context: Context, attrs: AttributeSet?) : HotwireWebView(context, attrs) {

    init {
        // Additional initialization
    }

    override fun onScrollChanged(l: Int, t: Int, oldl: Int, oldt: Int) {
        super.onScrollChanged(l, t, oldl, oldt)
        // Custom scroll handling
    }
}
```

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

### Handle Messages with the Message Class

Source: https://context7.com/hotwired/hotwire-native-android/llms.txt

Use the `Message` class to access properties like ID, component, event, metadata, and raw JSON data. Deserialize to typed data and create modified messages for replies.

```kotlin
import dev.hotwire.core.bridge.Message

class MyComponent( 
    name: String,
    delegate: BridgeDelegate<HotwireDestination>
) : BridgeComponent<HotwireDestination>(name, delegate) {

    override fun onReceive(message: Message) {
        // Access message properties
        val id = message.id              // Unique message identifier
        val component = message.component // Component name (e.g., "form")
        val event = message.event        // Event name (e.g., "connect")
        val metadata = message.metadata  // Contains URL info
        val jsonData = message.jsonData  // Raw JSON string data

        // Deserialize to typed data
        val data = message.data<MyData>()

        // Create a modified message for reply
        val replyMessage = message.replacing(
            event = "response",
            jsonData = "{\"success\": true}"
        )

        // Or with typed data
        val typedReply = message.replacing(
            event = "response",
            data = ResponseData(success = true)
        )
    }

    fun sendReply() {
        // Reply with modified message
        val message = receivedMessageFor("connect")
        message?.let {
            replyWith(it.replacing(jsonData = "{\"submitted\": true}"))
        }

        // Or reply to a specific event
        replyTo("connect")

        // Reply with custom data
        replyTo("connect", "{\"status\": \"success\"}")
        replyTo("connect", ResponseData(status = "success"))
    }

    @Serializable
    data class MyData(val title: String)

    @Serializable
    data class ResponseData(
        val success: Boolean = false,
        val status: String = ""
    )
}

```

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

### Define and Register a Bridge Component

Source: https://context7.com/hotwired/hotwire-native-android/llms.txt

Create a custom `FormComponent` that extends `BridgeComponent` to handle specific events from JavaScript. Register this component in your `Application` class using `BridgeComponentFactory`.

```kotlin
import dev.hotwire.core.bridge.BridgeComponent
import dev.hotwire.core.bridge.BridgeComponentFactory
import dev.hotwire.core.bridge.BridgeDelegate
import dev.hotwire.core.bridge.Message
import dev.hotwire.navigation.destinations.HotwireDestination
import kotlinx.serialization.Serializable
import kotlinx.serialization.SerialName

// Define a bridge component
class FormComponent( 
    name: String,
    private val delegate: BridgeDelegate<HotwireDestination>
) : BridgeComponent<HotwireDestination>(name, delegate) {

    private val fragment: Fragment
        get() = delegate.destination.fragment

    private val toolbar: Toolbar?
        get() = fragment.view?.findViewById(R.id.toolbar)

    // Handle messages received from JavaScript
    override fun onReceive(message: Message) {
        when (message.event) {
            "connect" -> handleConnect(message)
            "submitEnabled" -> handleSubmitEnabled()
            "submitDisabled" -> handleSubmitDisabled()
            else -> Log.w("FormComponent", "Unknown event: ${message.event}")
        }
    }

    private fun handleConnect(message: Message) {
        // Deserialize message data
        val data = message.data<ConnectData>() ?: return

        // Add submit button to toolbar
        toolbar?.menu?.add(data.submitTitle)?.apply {
            setShowAsAction(MenuItem.SHOW_AS_ACTION_ALWAYS)
            setOnMenuItemClickListener {
                performSubmit()
                true
            }
        }
    }

    private fun performSubmit(): Boolean {
        // Reply to JavaScript with the original connect event
        return replyTo("connect")
    }

    private fun handleSubmitEnabled() {
        // Enable submit button
    }

    private fun handleSubmitDisabled() {
        // Disable submit button
    }

    // Called when destination becomes active
    override fun onStart() {
        Log.d("FormComponent", "Component started")
    }

    // Called when destination becomes inactive
    override fun onStop() {
        Log.d("FormComponent", "Component stopped")
    }

    @Serializable
    data class ConnectData(
        @SerialName("submitTitle") val submitTitle: String
    )
}

// Register bridge components in Application
class MyApplication : Application() {
    override fun onCreate() {
        super.onCreate()

        Hotwire.registerBridgeComponents(
            BridgeComponentFactory("form", ::FormComponent),
            BridgeComponentFactory("menu", ::MenuComponent),
            BridgeComponentFactory("toast", ::ToastComponent)
        )
    }
}

```

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