@appport/transport-tauri

The Tauri IPC transport.

import { invoke } from "@tauri-apps/api/core";
import { listen } from "@tauri-apps/api/event";
import { createTauriTransport } from "@appport/transport-tauri";

const transport = createTauriTransport({ invoke, listen });

Tauri already models IPC as serialized request/response commands plus one-way events, which is the same split AppPort makes between capabilities and events. One command carries every capability; the envelope names it.

The Rust side

#[tauri::command]
pub async fn appport_request(
    app: AppHandle,
    state: State<'_, AppPort>,
    envelope: Value,
) -> Result<Option<Value>, String> {
    match envelope.get("type").and_then(Value::as_str) {
        // Request envelopes are answered by the command's return value.
        Some("request") => Ok(Some(state.runtime.handle_request(envelope).await)),
        // Everything else replies asynchronously on one event channel.
        _ => {
            let handle = app.clone();
            state
                .runtime
                .handle_duplex(envelope, move |outgoing| {
                    let _ = handle.emit("appport://message", outgoing);
                })
                .await;
            Ok(None)
        }
    }
}

Without listen, the transport is request/response only — conformance level 1. With it, events and streams work exactly as they do over WebSocket.