Architecture

┌─────────────────────────────────────────────┐
│         React 19 Frontend (TypeScript)       │
│  ┌─────────────────────────────────────┐   │
│  │  Components (shadcn/ui + Tailwind)   │   │
│  │  State (React hooks + Zustand)       │   │
│  │  Tauri API (@tauri-apps/api)         │   │
│  └─────────────────────────────────────┘   │
└─────────────────────────────────────────────┘
                    ↕ IPC
┌─────────────────────────────────────────────┐
│          Rust Backend (Tauri v2)            │
│  ┌─────────────────────────────────────┐   │
│  │  Commands (invoke handlers)          │   │
│  │  Audio (CoreAudio/CPAL)              │   │
│  │  Whisper (AI transcription)          │   │
│  │  Parakeet (Swift sidecar)            │   │
│  │  State Management                    │   │
│  └─────────────────────────────────────┘   │
└─────────────────────────────────────────────┘

src/
├── components/          # UI components
│   ├── ui/              # shadcn/ui primitives (Button, Input, etc.)
│   ├── tabs/            # Tab panel components (Settings, Models, etc.)
│   └── sections/        # Reusable page sections
├── contexts/            # React context providers
├── hooks/               # Custom React hooks
│   ├── useTranscription.ts
│   ├── useRecording.ts
│   └── useSettings.ts
├── lib/                 # Shared utilities
├── utils/               # Helper functions
├── services/            # External service integrations
├── state/               # State management (Zustand stores)
└── test/                # Integration tests

src-tauri/src/
├── commands/            # Tauri command handlers
│   ├── recording.rs
│   ├── transcription.rs
│   ├── settings.rs
│   └── models.rs
├── audio/               # Audio recording (CoreAudio/CPAL)
│   ├── recorder.rs
│   └── processor.rs
├── whisper/             # Whisper AI integration
│   ├── engine.rs
│   └── model.rs
├── ai/                  # AI model management
├── parakeet/            # Parakeet sidecar integration
├── state/               # Backend state management
├── utils/               # Rust utilities
└── tests/               # Rust unit tests

#[tauri::command]
async fn start_recording(state: State<'_, AppState>) -> Result<(), String> {
    // Command implementation
}

import { invoke } from '@tauri-apps/api/core';

// Invoke a command
const result = await invoke('start_recording');

// With parameters
const text = await invoke('transcribe_audio', {
  audioPath: '/path/to/audio.wav',
  modelName: 'base'
});

// Emit event from Rust
app.emit("transcription_progress", {
    progress: 0.5
})?;

// Listen in React
import { listen } from '@tauri-apps/api/event';

const unlisten = await listen('transcription_progress', (event) => {
  console.log('Progress:', event.payload.progress);
});

class EventCoordinator {
  private unlisteners: UnlistenFn[] = [];

  async subscribe(event: string, handler: (data: any) => void) {
    const unlisten = await listen(event, handler);
    this.unlisteners.push(unlisten);
  }

  cleanup() {
    this.unlisteners.forEach(fn => fn());
  }
}

const [isRecording, setIsRecording] = useState(false);

import { create } from 'zustand';

export const useAppStore = create((set) => ({
  settings: {},
  updateSettings: (newSettings) => set({ settings: newSettings })
}));

pub struct AppState {
    pub recording_state: Arc<Mutex<RecordingState>>,
    pub whisper_engine: Arc<Mutex<Option<WhisperEngine>>>,
}

#[tauri::command]
fn get_state(state: State<'_, AppState>) -> Result<String, String> {
    // Access shared state
}

{
  "permissions": [
    "core:default",
    "fs:read-file",
    "shell:execute",
    "global-shortcut:all"
  ]
}

pub struct SecureStore {
    cipher: Aes256Gcm,
    // ...
}

// Preload model in background
tokio::spawn(async move {
    let _ = whisper_engine.load_model("base").await;
});

// Save clipboard
let original = get_clipboard();
// Insert text
insert_text(transcription);
// Restore after delay
tokio::time::sleep(Duration::from_millis(500)).await;
set_clipboard(original);

#[tauri::command]
async fn download_model(url: String) -> Result<(), String> {
    // Async HTTP download
    let response = reqwest::get(url).await?;
    // ...
}