claude-mpm 5.4.41__py3-none-any.whl → 5.6.72__py3-none-any.whl

claude_mpm/skills/bundled/tauri/tauri-performance.md

@@ -0,0 +1,669 @@
+---
+name: tauri-performance
+description: Performance optimization for Tauri apps including serialization, batching, caching, lazy loading, and profiling techniques
+version: 1.0.0
+category: development
+author: Claude MPM Team
+license: MIT
+progressive_disclosure:
+  entry_point:
+    summary: "Performance optimization: minimize serialization, batch commands, implement caching, lazy load resources, profile bottlenecks"
+    when_to_use: "Optimizing Tauri app performance, reducing IPC overhead, improving responsiveness, or debugging performance issues"
+    quick_start: "1. Batch IPC calls 2. Cache frequently accessed data 3. Stream large data 4. Lazy load resources 5. Profile with DevTools"
+context_limit: 600
+tags:
+  - tauri
+  - performance
+  - optimization
+  - profiling
+  - caching
+requires_tools: []
+---
+
+# Tauri Performance Optimization
+
+## IPC Optimization
+
+### Minimize Serialization Overhead
+
+**Problem**: Each IPC call serializes data across the boundary
+
+```rust
+// ❌ BAD - multiple IPC calls
+#[tauri::command]
+async fn get_file_name(path: String) -> Result<String, String> { /* ... */ }
+
+#[tauri::command]
+async fn get_file_size(path: String) -> Result<u64, String> { /* ... */ }
+
+// Frontend makes 3 separate calls
+const name = await invoke('get_file_name', { path });
+const size = await invoke('get_file_size', { path });
+const modified = await invoke('get_file_modified', { path });
+```
+
+**Solution**: Batch data in single call
+
+```rust
+// ✅ GOOD - single IPC call
+#[derive(serde::Serialize)]
+pub struct FileInfo {
+    name: String,
+    size: u64,
+    modified: u64,
+    is_dir: bool,
+}
+
+#[tauri::command]
+async fn get_file_info(path: String) -> Result<FileInfo, String> {
+    let metadata = tokio::fs::metadata(&path)
+        .await
+        .map_err(|e| e.to_string())?;
+
+    Ok(FileInfo {
+        name: Path::new(&path)
+            .file_name()
+            .unwrap()
+            .to_string_lossy()
+            .to_string(),
+        size: metadata.len(),
+        modified: metadata.modified()
+            .unwrap()
+            .duration_since(UNIX_EPOCH)
+            .unwrap()
+            .as_secs(),
+        is_dir: metadata.is_dir(),
+    })
+}
+
+// Frontend makes 1 call
+const info = await invoke('get_file_info', { path });
+```
+
+### Batch Operations
+
+```rust
+// ❌ BAD - N IPC calls
+for file in files {
+    await invoke('process_file', { file });
+}
+
+// ✅ GOOD - 1 IPC call
+#[tauri::command]
+async fn process_files_batch(files: Vec<String>) -> Result<Vec<ProcessResult>, String> {
+    let mut results = Vec::new();
+
+    for file in files {
+        let result = process_file_internal(&file).await;
+        results.push(result);
+    }
+
+    Ok(results)
+}
+
+await invoke('process_files_batch', { files });
+```
+
+### Stream Large Data
+
+```rust
+use futures::stream::{self, StreamExt};
+
+#[tauri::command]
+async fn load_large_dataset(
+    window: tauri::Window,
+) -> Result<(), String> {
+    let data = fetch_large_dataset().await?;
+
+    // Stream in chunks instead of single payload
+    let chunks: Vec<_> = data.chunks(1000).collect();
+
+    for (index, chunk) in chunks.iter().enumerate() {
+        window.emit("data-chunk", serde_json::json!({
+            "index": index,
+            "data": chunk,
+            "total": chunks.len()
+        })).map_err(|e| e.to_string())?;
+
+        // Small delay to prevent overwhelming frontend
+        tokio::time::sleep(Duration::from_millis(10)).await;
+    }
+
+    window.emit("data-complete", ()).map_err(|e| e.to_string())?;
+
+    Ok(())
+}
+```
+
+**Frontend streaming handler**:
+```typescript
+let allData: DataItem[] = [];
+
+await listen('data-chunk', (event: { index: number; data: DataItem[]; total: number }) => {
+    allData = allData.concat(event.data);
+    updateProgress(event.index, event.total);
+});
+
+await listen('data-complete', () => {
+    renderData(allData);
+});
+
+await invoke('load_large_dataset');
+```
+
+## Caching Strategies
+
+### In-Memory Cache
+
+```rust
+use std::sync::Arc;
+use dashmap::DashMap;
+use std::time::{SystemTime, Duration};
+
+pub struct CachedValue<T> {
+    value: T,
+    expires_at: SystemTime,
+}
+
+pub struct Cache<T> {
+    store: Arc<DashMap<String, CachedValue<T>>>,
+    ttl: Duration,
+}
+
+impl<T: Clone> Cache<T> {
+    pub fn new(ttl_secs: u64) -> Self {
+        Self {
+            store: Arc::new(DashMap::new()),
+            ttl: Duration::from_secs(ttl_secs),
+        }
+    }
+
+    pub fn get(&self, key: &str) -> Option<T> {
+        self.store.get(key).and_then(|entry| {
+            if SystemTime::now() < entry.expires_at {
+                Some(entry.value.clone())
+            } else {
+                self.store.remove(key);
+                None
+            }
+        })
+    }
+
+    pub fn set(&self, key: String, value: T) {
+        self.store.insert(key, CachedValue {
+            value,
+            expires_at: SystemTime::now() + self.ttl,
+        });
+    }
+
+    pub fn clear(&self) {
+        self.store.clear();
+    }
+}
+
+// Usage in app state
+pub struct AppState {
+    file_cache: Cache<String>,
+}
+
+#[tauri::command]
+async fn read_file_cached(
+    path: String,
+    state: tauri::State<'_, AppState>,
+) -> Result<String, String> {
+    // Check cache first
+    if let Some(content) = state.file_cache.get(&path) {
+        return Ok(content);
+    }
+
+    // Cache miss - read from disk
+    let content = tokio::fs::read_to_string(&path)
+        .await
+        .map_err(|e| e.to_string())?;
+
+    // Store in cache
+    state.file_cache.set(path, content.clone());
+
+    Ok(content)
+}
+```
+
+### LRU Cache
+
+```rust
+use lru::LruCache;
+use std::sync::Arc;
+use tokio::sync::Mutex;
+use std::num::NonZeroUsize;
+
+pub struct AppState {
+    lru_cache: Arc<Mutex<LruCache<String, Vec<u8>>>>,
+}
+
+impl AppState {
+    pub fn new() -> Self {
+        Self {
+            lru_cache: Arc::new(Mutex::new(
+                LruCache::new(NonZeroUsize::new(100).unwrap())
+            )),
+        }
+    }
+}
+
+#[tauri::command]
+async fn get_data_with_lru(
+    key: String,
+    state: tauri::State<'_, AppState>,
+) -> Result<Vec<u8>, String> {
+    let mut cache = state.lru_cache.lock().await;
+
+    if let Some(data) = cache.get(&key) {
+        return Ok(data.clone());
+    }
+
+    // Cache miss
+    drop(cache);  // Release lock before expensive operation
+
+    let data = fetch_expensive_data(&key).await?;
+
+    let mut cache = state.lru_cache.lock().await;
+    cache.put(key, data.clone());
+
+    Ok(data)
+}
+```
+
+### Persistent Cache
+
+```rust
+use sled::Db;
+
+pub struct AppState {
+    disk_cache: Db,
+}
+
+impl AppState {
+    pub fn new() -> Result<Self, String> {
+        let cache = sled::open("cache.db")
+            .map_err(|e| e.to_string())?;
+
+        Ok(Self {
+            disk_cache: cache,
+        })
+    }
+}
+
+#[tauri::command]
+async fn get_cached_data(
+    key: String,
+    state: tauri::State<'_, AppState>,
+) -> Result<Option<String>, String> {
+    let data = state.disk_cache
+        .get(key.as_bytes())
+        .map_err(|e| e.to_string())?;
+
+    Ok(data.map(|bytes| String::from_utf8_lossy(&bytes).to_string()))
+}
+
+#[tauri::command]
+async fn set_cached_data(
+    key: String,
+    value: String,
+    state: tauri::State<'_, AppState>,
+) -> Result<(), String> {
+    state.disk_cache
+        .insert(key.as_bytes(), value.as_bytes())
+        .map_err(|e| e.to_string())?;
+
+    Ok(())
+}
+```
+
+## Lazy Loading
+
+### Lazy Component Loading
+
+```typescript
+// React lazy loading
+import { lazy, Suspense } from 'react';
+
+const HeavyComponent = lazy(() => import('./HeavyComponent'));
+
+function App() {
+    return (
+        <Suspense fallback={<div>Loading...</div>}>
+            <HeavyComponent />
+        </Suspense>
+    );
+}
+```
+
+### Lazy Data Loading
+
+```rust
+#[tauri::command]
+async fn get_preview(path: String) -> Result<PreviewData, String> {
+    // Return lightweight preview first
+    let preview = PreviewData {
+        name: get_filename(&path),
+        size: get_filesize(&path).await?,
+        thumbnail: None,  // Don't load heavy data yet
+    };
+
+    Ok(preview)
+}
+
+#[tauri::command]
+async fn get_full_data(path: String) -> Result<FullData, String> {
+    // Load heavy data only when requested
+    let content = tokio::fs::read(&path)
+        .await
+        .map_err(|e| e.to_string())?;
+
+    let thumbnail = generate_thumbnail(&content)?;
+
+    Ok(FullData {
+        content,
+        thumbnail: Some(thumbnail),
+    })
+}
+```
+
+**Frontend**:
+```typescript
+// Load preview immediately
+const preview = await invoke('get_preview', { path });
+showPreview(preview);
+
+// Load full data on demand
+button.onclick = async () => {
+    const fullData = await invoke('get_full_data', { path });
+    showFullData(fullData);
+};
+```
+
+## Database Optimization
+
+### Connection Pooling
+
+```rust
+use sqlx::{Pool, Sqlite, SqlitePool};
+
+pub struct AppState {
+    db_pool: Pool<Sqlite>,
+}
+
+impl AppState {
+    pub async fn new() -> Result<Self, sqlx::Error> {
+        let pool = SqlitePool::connect("sqlite://data.db").await?;
+
+        Ok(Self { db_pool: pool })
+    }
+}
+
+#[tauri::command]
+async fn query_users(
+    state: tauri::State<'_, AppState>,
+) -> Result<Vec<User>, String> {
+    let users = sqlx::query_as::<_, User>("SELECT * FROM users")
+        .fetch_all(&state.db_pool)
+        .await
+        .map_err(|e| e.to_string())?;
+
+    Ok(users)
+}
+```
+
+### Prepared Statements
+
+```rust
+use sqlx::{Sqlite, Statement};
+
+pub struct PreparedStatements {
+    get_user: Statement<'static, Sqlite>,
+    insert_user: Statement<'static, Sqlite>,
+}
+
+impl PreparedStatements {
+    pub async fn new(pool: &Pool<Sqlite>) -> Result<Self, sqlx::Error> {
+        Ok(Self {
+            get_user: pool.prepare("SELECT * FROM users WHERE id = ?").await?,
+            insert_user: pool.prepare("INSERT INTO users (name, email) VALUES (?, ?)").await?,
+        })
+    }
+}
+
+// Use prepared statements for repeated queries
+```
+
+## Async Performance
+
+### Concurrent Operations
+
+```rust
+use futures::future::join_all;
+
+#[tauri::command]
+async fn load_multiple_files(paths: Vec<String>) -> Result<Vec<FileData>, String> {
+    let tasks = paths.into_iter().map(|path| async move {
+        tokio::fs::read_to_string(&path)
+            .await
+            .map(|content| FileData { path, content })
+    });
+
+    let results = join_all(tasks).await;
+
+    let data: Vec<FileData> = results
+        .into_iter()
+        .filter_map(|r| r.ok())
+        .collect();
+
+    Ok(data)
+}
+```
+
+### Parallel Processing with Rayon
+
+```rust
+use rayon::prelude::*;
+
+#[tauri::command]
+async fn process_large_dataset(data: Vec<Item>) -> Result<Vec<ProcessedItem>, String> {
+    // Move to blocking thread pool for CPU-intensive work
+    let processed = tokio::task::spawn_blocking(move || {
+        data.par_iter()
+            .map(|item| process_item(item))
+            .collect::<Vec<_>>()
+    })
+    .await
+    .map_err(|e| e.to_string())?;
+
+    Ok(processed)
+}
+```
+
+## Profiling and Debugging
+
+### Backend Profiling
+
+```rust
+use std::time::Instant;
+
+#[tauri::command]
+async fn profiled_operation() -> Result<String, String> {
+    let start = Instant::now();
+
+    let result = expensive_operation().await?;
+
+    let duration = start.elapsed();
+    log::info!("Operation took {:?}", duration);
+
+    Ok(result)
+}
+```
+
+### Conditional Logging
+
+```rust
+#[cfg(debug_assertions)]
+macro_rules! debug_time {
+    ($label:expr, $code:block) => {{
+        let start = std::time::Instant::now();
+        let result = $code;
+        let duration = start.elapsed();
+        log::debug!("{} took {:?}", $label, duration);
+        result
+    }};
+}
+
+#[cfg(not(debug_assertions))]
+macro_rules! debug_time {
+    ($label:expr, $code:block) => {
+        $code
+    };
+}
+
+#[tauri::command]
+async fn operation() -> Result<String, String> {
+    let result = debug_time!("Database query", {
+        query_database().await
+    })?;
+
+    Ok(result)
+}
+```
+
+### Frontend Performance Monitoring
+
+```typescript
+// Performance marks
+performance.mark('command-start');
+const result = await invoke('heavy_command');
+performance.mark('command-end');
+
+performance.measure('command-duration', 'command-start', 'command-end');
+
+const measure = performance.getEntriesByName('command-duration')[0];
+console.log(`Command took ${measure.duration}ms`);
+```
+
+## Memory Optimization
+
+### Avoid Cloning
+
+```rust
+// ❌ BAD - unnecessary clone
+#[tauri::command]
+async fn process_data(data: String) -> Result<String, String> {
+    let processed = data.clone();  // Unnecessary
+    Ok(processed.to_uppercase())
+}
+
+// ✅ GOOD - consume owned value
+#[tauri::command]
+async fn process_data(data: String) -> Result<String, String> {
+    Ok(data.to_uppercase())  // Takes ownership
+}
+```
+
+### Use References Where Possible
+
+```rust
+async fn internal_processing(data: &str) -> String {
+    data.to_uppercase()
+}
+
+#[tauri::command]
+async fn process(data: String) -> Result<String, String> {
+    Ok(internal_processing(&data))
+}
+```
+
+### Drop Large Allocations Early
+
+```rust
+#[tauri::command]
+async fn process_file(path: String) -> Result<String, String> {
+    let large_buffer = tokio::fs::read(&path)
+        .await
+        .map_err(|e| e.to_string())?;
+
+    let summary = compute_summary(&large_buffer);
+
+    drop(large_buffer);  // Free memory before waiting
+
+    tokio::time::sleep(Duration::from_secs(1)).await;
+
+    Ok(summary)
+}
+```
+
+## Best Practices
+
+1. **Batch IPC calls** - Minimize serialization overhead
+2. **Cache aggressively** - In-memory, LRU, or persistent
+3. **Stream large data** - Chunk payloads instead of single large payload
+4. **Lazy load** - Only fetch data when needed
+5. **Use connection pools** - For database access
+6. **Concurrent operations** - Use join_all for parallel async
+7. **CPU-bound work** - Move to spawn_blocking or rayon
+8. **Profile regularly** - Identify bottlenecks with timing
+9. **Minimize cloning** - Use references or consume owned values
+10. **Drop early** - Free large allocations as soon as possible
+
+## Common Pitfalls
+
+❌ **Too many small IPC calls**:
+```typescript
+// WRONG - 100 IPC calls
+for (const file of files) {
+    await invoke('process_file', { file });
+}
+
+// CORRECT - 1 IPC call
+await invoke('process_files_batch', { files });
+```
+
+❌ **Not caching expensive operations**:
+```rust
+// WRONG - recomputes every time
+#[tauri::command]
+async fn get_config() -> Config {
+    parse_config().await  // Expensive every call
+}
+
+// CORRECT - cache result
+lazy_static! {
+    static ref CONFIG: Mutex<Option<Config>> = Mutex::new(None);
+}
+```
+
+❌ **Blocking async runtime**:
+```rust
+// WRONG - blocks async executor
+#[tauri::command]
+async fn cpu_intensive() -> String {
+    expensive_cpu_work()  // Blocks entire runtime
+}
+
+// CORRECT - move to blocking thread
+#[tauri::command]
+async fn cpu_intensive() -> String {
+    tokio::task::spawn_blocking(|| expensive_cpu_work())
+        .await
+        .unwrap()
+}
+```
+
+## Summary
+
+- **Batch IPC calls** to minimize serialization overhead
+- **Cache frequently accessed data** with TTL, LRU, or persistent
+- **Stream large datasets** in chunks to prevent memory spikes
+- **Lazy load resources** only when needed
+- **Connection pooling** for database efficiency
+- **Concurrent async** with join_all for parallel operations
+- **CPU-bound work** on spawn_blocking or rayon
+- **Profile performance** to identify bottlenecks
+- **Minimize cloning** and drop large allocations early
+- **Frontend monitoring** with Performance API