Architecture Details

SlasshyWispr Application
├── Frontend (TypeScript/Vite)
│   ├── UI Components
│   ├── State Management
│   └── Tauri API Bindings
└── Backend (Rust)
    ├── Tauri Commands
    ├── AppState Management
    ├── Pipeline Processors
    │   ├── STT Engine
    │   ├── AI Integration
    │   └── TTS Engine
    └── Local Model Daemons

## Rust Backend Components

### AppState Structure

The central state container managing all runtime data:

```rust
struct AppState {
    // Shared HTTP client with connection pooling
    http: Client,
    
    // Text rewrite workflow state
    pending_selection_rewrite: Mutex<Option<PendingSelectionRewrite>>,
    
    // Recent text selection context (TTL: RECENT_SELECTION_CONTEXT_TTL_SECS)
    recent_selection_context: Mutex<Option<RecentSelectionContext>>,
    
    // Last pipeline outputs
    last_transcript: Mutex<String>,
    last_assistant_response: Mutex<String>,
    
    // Local model download tracking
    local_stt_download_status: Mutex<LocalSttDownloadStatusResponse>,
    
    // Runtime status flag
    local_stt_runtime_loaded: Mutex<bool>,
}

struct CoquiBridgeDaemon {
    child: Child,              // Python process handle
    stdin: ChildStdin,         // JSON-RPC command pipe
    stdout: BufReader<ChildStdout>, // Response stream
}

struct LocalSttBridgeDaemon {
    child: Child,
    stdin: ChildStdin,
    stdout: BufReader<ChildStdout>,
    last_used: Instant,        // Idle tracking
    model_loaded: bool,        // Warm-start status
}

struct NativeParakeetRuntime {
    model_key: String,
    engine: ParakeetEngine,    // Rust-native STT engine
    last_used: Instant,
}

// Application shell structure
const appRoot = document.querySelector<HTMLDivElement>("#app");

appRoot.innerHTML = `
  <div class="app-frame">
    <header class="app-titlebar">...</header>
    <div class="flow-shell">
      <aside class="flow-sidebar">
        <nav class="nav-main">...</nav>
      </aside>
      <main class="flow-content">
        <section class="flow-page" data-page="home">...</section>
      </main>
    </div>
  </div>
`;

import { WebviewWindow } from "@tauri-apps/api/webviewWindow";
import { LogicalSize, getCurrentWindow } from "@tauri-apps/api/window";

// Window manipulation via Tauri API
const window = getCurrentWindow();
await window.minimize();
await window.toggleMaximize();
await window.close();

import { register as registerGlobalShortcut } from "@tauri-apps/plugin-global-shortcut";

// Register system-wide hotkey
await registerGlobalShortcut("CommandOrControl+Shift+Space", (event) => {
  // Trigger voice capture
});

// Request structure
struct AssistantPipelineRequest {
    audio_base64: String,
    audio_mime_type: String,
    stt_model: Option<String>,
    local_stt_model: Option<String>,
    stt_local_mode: Option<bool>,
    language: Option<String>,
    allowed_languages: Option<Vec<String>>,
    // ...
}

struct AssistantPipelineRequest {
    system_prompt: Option<String>,
    ai_model: Option<String>,
    temperature: Option<f32>,
    max_tokens: Option<u32>,
    selected_text: Option<String>,  // For selection rewrite mode
    command_mode: Option<bool>,
    // ...
}

struct AssistantPipelineRequest {
    tts_engine: Option<String>,  // "piper" | "coqui"
    piper: Option<PiperPipelineRequest>,
    coqui: Option<CoquiPipelineRequest>,
}

struct PiperPipelineRequest {
    speed: Option<f32>,
    quality: Option<String>,
    emotion: Option<String>,
}

struct CoquiPipelineRequest {
    python_path: Option<String>,
    model_name: Option<String>,
    speaker_id: Option<String>,
    speed: Option<f32>,
    use_gpu: Option<bool>,
    split_sentences: Option<bool>,
}

struct AssistantPipelineResponse {
    mode: String,                      // "dictation" | "command" | "rewrite"
    selection_rewrite: bool,
    selection_pending: bool,
    transcript: String,                // STT output
    assistant_response: String,        // AI output
    audio_base64: String,              // TTS output
    
    // Performance metrics
    stt_latency_ms: u64,
    ai_latency_ms: u64,
    tts_latency_ms: u64,
    total_latency_ms: u64,
}

// Automatic expiration on access
fn cleanup_expired_pending_selection_rewrite(
    slot: &mut Option<PendingSelectionRewrite>,
) -> bool {
    let expired = slot
        .as_ref()
        .map(|item| {
            item.created_at.elapsed() >= Duration::from_secs(PENDING_SELECTION_REWRITE_TTL_SECS)
        })
        .unwrap_or(false);
    if expired {
        *slot = None;
    }
    expired
}

struct LocalSttDownloadStatusResponse {
    active: bool,
    completed: bool,
    stage: String,              // "Downloading" | "Extracting" | "Complete"
    current_file: String,
    downloaded_bytes: u64,
    total_bytes: u64,
    files_completed: usize,
    files_total: usize,
    progress_percent: f64,      // Auto-calculated
    updated_at_ms: u64,
}

// Atomic updates with auto-timestamping
fn update_local_stt_download_status<F>(&self, mutator: F) -> Result<(), String>
where
    F: FnOnce(&mut LocalSttDownloadStatusResponse),
{
    let mut status = self.lock_local_stt_download_status()?;
    mutator(&mut status);
    status.progress_percent = calculate_local_stt_progress_percent(&status);
    status.updated_at_ms = now_unix_ms();
    Ok(())
}

#[cfg(target_os = "windows")]
use windows_sys::Win32::Security::Cryptography::{
    CryptProtectData,
    CryptUnprotectData,
    CRYPTPROTECT_UI_FORBIDDEN,
};

let http = Client::builder()
    .connect_timeout(Duration::from_secs(10))
    .timeout(Duration::from_secs(150))
    .pool_idle_timeout(Duration::from_secs(90))
    .pool_max_idle_per_host(8)         // Connection reuse
    .build()

#[tauri::command]
async fn example_command(state: State<'_, AppState>) -> Result<Response, String> {
    let data = state
        .last_transcript
        .lock()
        .map_err(|_| "State lock poisoned.")?;
    
    // Process...
    
    Ok(response)
}