release: bump version to 0.7.10

- fix overlay positioning on external monitors (work_area validation fallback)
- hide Gemini API from model selector when no API key configured
- exclude Gemini from local model availability checks in onboarding
- add skip button on accessibility permissions onboarding
- skip accessibility checks for dev flavor (com.melvynx.parler.dev)
- add i18n skip translations for all 17 languages
- code formatting (prettier + cargo fmt)

Author: Melvynx

package.json

@@ -1,7 +1,7 @@
 {
   "name": "parler-app",
   "private": true,
-  "version": "0.7.9",
+  "version": "0.7.10",
   "type": "module",
   "scripts": {
     "dev": "vite",

src-tauri/Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "parler"
-version = "0.7.9"
+version = "0.7.10"
 description = "Parler"
 authors = ["cjpais"]
 edition = "2021"

src-tauri/Cargo.toml

@@ -434,7 +434,10 @@ impl ShortcutAction for TranscribeAction {
                             long_model_id
                         );
                         if let Err(e) = tm.load_model(long_model_id) {
-                            warn!("Failed to load long audio model '{}': {}, using current model", long_model_id, e);
+                            warn!(
+                                "Failed to load long audio model '{}': {}, using current model",
+                                long_model_id, e
+                            );
                         } else {
                             switched_model = true;
                         }

src-tauri/src/actions.rs

@@ -92,8 +92,7 @@ pub async fn reprocess_history_entry(
         return Err("Audio file not found".to_string());
     }
 
-    let samples =
-        crate::audio_toolkit::load_wav_file(&audio_path).map_err(|e| e.to_string())?;
+    let samples = crate::audio_toolkit::load_wav_file(&audio_path).map_err(|e| e.to_string())?;
 
     let previous_model = transcription_manager.get_current_model();
 

src-tauri/src/commands/history.rs

@@ -1,4 +1,4 @@
-use crate::managers::model::{ModelInfo, ModelManager};
+use crate::managers::model::{EngineType, ModelInfo, ModelManager};
 use crate::managers::transcription::TranscriptionManager;
 use crate::settings::{get_settings, write_settings};
 use std::sync::Arc;
@@ -119,7 +119,9 @@ pub async fn has_any_models_available(
     model_manager: State<'_, Arc<ModelManager>>,
 ) -> Result<bool, String> {
     let models = model_manager.get_available_models();
-    Ok(models.iter().any(|m| m.is_downloaded))
+    Ok(models
+        .iter()
+        .any(|m| m.is_downloaded && !matches!(m.engine_type, EngineType::GeminiApi)))
 }
 
 #[tauri::command]
@@ -128,8 +130,9 @@ pub async fn has_any_models_or_downloads(
     model_manager: State<'_, Arc<ModelManager>>,
 ) -> Result<bool, String> {
     let models = model_manager.get_available_models();
-    // Return true if any models are downloaded OR if any downloads are in progress
-    Ok(models.iter().any(|m| m.is_downloaded))
+    Ok(models.iter().any(|m| {
+        !matches!(m.engine_type, EngineType::GeminiApi) && (m.is_downloaded || m.is_downloading)
+    }))
 }
 
 #[tauri::command]

src-tauri/src/commands/models.rs

@@ -113,8 +113,7 @@ pub async fn transcribe_audio(api_key: &str, model: &str, audio_samples: &[f32])
     headers.insert(CONTENT_TYPE, HeaderValue::from_static("application/json"));
     headers.insert(
         "x-goog-api-key",
-        HeaderValue::from_str(api_key)
-            .map_err(|e| anyhow::anyhow!("Invalid API key: {}", e))?,
+        HeaderValue::from_str(api_key).map_err(|e| anyhow::anyhow!("Invalid API key: {}", e))?,
     );
 
     let client = reqwest::Client::new();

src-tauri/src/gemini_client.rs

@@ -403,7 +403,9 @@ impl ModelManager {
             ModelInfo {
                 id: "gemini-api".to_string(),
                 name: "Gemini API".to_string(),
-                description: "Cloud-based transcription via Google Gemini. Requires API key and internet.".to_string(),
+                description:
+                    "Cloud-based transcription via Google Gemini. Requires API key and internet."
+                        .to_string(),
                 filename: "".to_string(),
                 url: None,
                 size_mb: 0,
@@ -558,11 +560,13 @@ impl ModelManager {
             }
         }
 
-        // If no model is selected, pick the first downloaded one
+        // If no model is selected, pick the first downloaded local model.
+        // Gemini is cloud-only and should not be auto-selected.
         if settings.selected_model.is_empty() {
-            // Find the first available (downloaded) model
             let models = self.available_models.lock().unwrap();
-            if let Some(available_model) = models.values().find(|model| model.is_downloaded) {
+            if let Some(available_model) = models.values().find(|model| {
+                model.is_downloaded && !matches!(model.engine_type, EngineType::GeminiApi)
+            }) {
                 info!(
                     "Auto-selecting model: {} ({})",
                     available_model.id, available_model.name
@@ -1133,7 +1137,10 @@ impl ModelManager {
             .ok_or_else(|| anyhow::anyhow!("Model not found: {}", model_id))?;
 
         if matches!(model_info.engine_type, EngineType::GeminiApi) {
-            return Err(anyhow::anyhow!("Cloud model has no local path: {}", model_id));
+            return Err(anyhow::anyhow!(
+                "Cloud model has no local path: {}",
+                model_id
+            ));
         }
 
         if !model_info.is_downloaded {

src-tauri/src/managers/model.rs

@@ -485,11 +485,7 @@ impl TranscriptionManager {
                 // so block_in_place tells tokio to move its work off this thread first.
                 let result = tokio::task::block_in_place(|| {
                     tokio::runtime::Handle::current().block_on(
-                        crate::gemini_client::transcribe_audio(
-                            &api_key,
-                            &gemini_model,
-                            &audio,
-                        ),
+                        crate::gemini_client::transcribe_audio(&api_key, &gemini_model, &audio),
                     )
                 })?;
 

src-tauri/src/managers/transcription.rs

@@ -232,28 +232,56 @@ fn get_monitor_with_cursor(app_handle: &AppHandle) -> Option<tauri::Monitor> {
 
 fn calculate_overlay_position(app_handle: &AppHandle) -> Option<(f64, f64)> {
     if let Some(monitor) = get_monitor_with_cursor(app_handle) {
-        let work_area = monitor.work_area();
         let scale = monitor.scale_factor();
-        let work_area_width = work_area.size.width as f64 / scale;
-        let work_area_height = work_area.size.height as f64 / scale;
-        let work_area_x = work_area.position.x as f64 / scale;
-        let work_area_y = work_area.position.y as f64 / scale;
+        let monitor_x = monitor.position().x as f64 / scale;
+        let monitor_y = monitor.position().y as f64 / scale;
+        let monitor_width = monitor.size().width as f64 / scale;
+        let monitor_height = monitor.size().height as f64 / scale;
+
+        let work_area = monitor.work_area();
+        let wa_x = work_area.position.x as f64 / scale;
+        let wa_y = work_area.position.y as f64 / scale;
+        let wa_w = work_area.size.width as f64 / scale;
+        let wa_h = work_area.size.height as f64 / scale;
+
+        // Validate work_area: on macOS, work_area() can return bogus values
+        // for external monitors. Detect this by checking if work_area extends
+        // beyond the monitor bounds.
+        let wa_bottom = wa_y + wa_h;
+        let monitor_bottom = monitor_y + monitor_height;
+        let work_area_valid =
+            wa_y >= monitor_y && wa_bottom <= monitor_bottom + 1.0 && wa_w <= monitor_width + 1.0;
+
+        let (area_x, area_y, area_w, area_h) = if work_area_valid {
+            (wa_x, wa_y, wa_w, wa_h)
+        } else {
+            log::debug!(
+                "work_area invalid for monitor (wa_bottom={:.0} > monitor_bottom={:.0}), using monitor bounds with safe offset",
+                wa_bottom, monitor_bottom
+            );
+            // Use monitor bounds with a safe top offset for the macOS menu bar (~25px)
+            let menu_bar_offset = 25.0;
+            (
+                monitor_x,
+                monitor_y + menu_bar_offset,
+                monitor_width,
+                monitor_height - menu_bar_offset,
+            )
+        };
 
         let settings = settings::get_settings(app_handle);
 
-        let x = work_area_x + (work_area_width - OVERLAY_WIDTH) / 2.0;
+        let x = area_x + (area_w - OVERLAY_WIDTH) / 2.0;
         let y = match settings.overlay_position {
-            OverlayPosition::Top => work_area_y + OVERLAY_TOP_OFFSET,
+            OverlayPosition::Top => area_y + OVERLAY_TOP_OFFSET,
             OverlayPosition::Bottom | OverlayPosition::None => {
-                work_area_y + work_area_height - OVERLAY_HEIGHT - OVERLAY_BOTTOM_OFFSET
+                area_y + area_h - OVERLAY_HEIGHT - OVERLAY_BOTTOM_OFFSET
             }
         };
 
         log::debug!(
-            "Overlay position: ({:.0}, {:.0}) on monitor (scale={}, work_area=({:.0},{:.0},{:.0},{:.0}))",
-            x, y,
-            scale,
-            work_area_x, work_area_y, work_area_width, work_area_height
+            "Overlay position: ({:.0}, {:.0}) on monitor (scale={}, area=({:.0},{:.0},{:.0},{:.0}), wa_valid={})",
+            x, y, scale, area_x, area_y, area_w, area_h, work_area_valid
         );
 
         return Some((x, y));
@@ -356,7 +384,6 @@ pub fn create_recording_overlay(app_handle: &AppHandle) {
 }
 
 fn show_overlay_state(app_handle: &AppHandle, state: &str) {
-    // Check if overlay should be shown based on position setting
     let settings = settings::get_settings(app_handle);
     if settings.overlay_position == OverlayPosition::None {
         return;
@@ -367,7 +394,6 @@ fn show_overlay_state(app_handle: &AppHandle, state: &str) {
     if let Some(overlay_window) = app_handle.get_webview_window("recording_overlay") {
         let _ = overlay_window.show();
 
-        // On Windows, aggressively re-assert "topmost" in the native Z-order after showing
         #[cfg(target_os = "windows")]
         force_overlay_topmost(&overlay_window);