fix(transcription): compile the GGUF session owner on Linux

src/linux_transcriber.rs

@@ -5,7 +5,7 @@ use std::time::Instant;
 use color_eyre::eyre::{Result, WrapErr, eyre};
 use transcribe_cpp::{Backend, Model, ModelOptions, RunOptions, TimestampKind};
 
-use crate::transcription::OfflineGgufSession;
+use crate::offline_gguf::OfflineGgufSession;
 use crate::transcription_models::{
     ModelDefinition, TranscriptionModelId, TranscriptionSelection, definition,
     download_with_progress, model_path, validate,

src/main.rs

@@ -93,6 +93,8 @@ mod microphone_activity;
 mod moonshine;
 #[cfg(all(target_os = "macos", debug_assertions))]
 mod moonshine_lab;
+#[cfg(any(target_os = "macos", target_os = "linux"))]
+mod offline_gguf;
 #[cfg(target_os = "macos")]
 mod onboarding;
 #[cfg(target_os = "macos")]

src/offline_gguf.rs

@@ -0,0 +1,47 @@
+//! The GGUF inference session owner shared by the macOS and Linux adapters.
+//!
+//! Both platforms load the same `transcribe-cpp` models, so the session
+//! lifecycle rules that keep inference scratch memory bounded belong in one
+//! place rather than per platform.
+
+pub(crate) struct OfflineGgufSession {
+    model: transcribe_cpp::Model,
+    session: Option<transcribe_cpp::Session>,
+}
+
+impl OfflineGgufSession {
+    pub(crate) fn new(model: transcribe_cpp::Model) -> transcribe_cpp::Result<Self> {
+        let session = model.session()?;
+        Ok(Self {
+            model,
+            session: Some(session),
+        })
+    }
+
+    pub(crate) fn run(
+        &mut self,
+        samples: &[f32],
+        options: &transcribe_cpp::RunOptions,
+    ) -> transcribe_cpp::Result<transcribe_cpp::Transcript> {
+        // transcribe-cpp 0.1.x retains input-sized scheduler buffers for the
+        // session lifetime. Drop each used session before creating its
+        // successor so a long inference cannot pin that high-water mark or
+        // overlap two sessions' persistent decoder state.
+        let mut session = match self.session.take() {
+            Some(session) => session,
+            None => self.model.session()?,
+        };
+        let result = session.run(samples, options);
+        drop(session);
+        match self.model.session() {
+            Ok(session) => {
+                self.session = Some(session);
+                result
+            }
+            Err(recovery_error) => match result {
+                Ok(_) => Err(recovery_error),
+                Err(run_error) => Err(run_error),
+            },
+        }
+    }
+}

src/parakeet.rs

@@ -18,11 +18,12 @@ use crate::dictation::{DictationClip, DictationProtocol, pad_for_parakeet};
 use crate::dictation_processor::ProcessingObservation;
 use crate::history::{History, HistoryDraft, HistoryKind};
 use crate::meeting::{self, TranscriptEntry, TranscriptPublication};
+use crate::offline_gguf::OfflineGgufSession;
 use crate::paste::{PasteMode, Paster};
 use crate::suppression::InputActivity;
 #[cfg(test)]
 use crate::text_replacements::ReplacementSet;
-use crate::transcription::{OfflineGgufSession, Transcriber, WarmTranscriber};
+use crate::transcription::{Transcriber, WarmTranscriber};
 use crate::transcription_models::{
     TranscriptionModelId, TranscriptionSelection, model_path, validate,
 };

src/transcription.rs

@@ -19,11 +19,6 @@ pub struct WarmTranscriber {
     active: Option<Transcriber>,
 }
 
-pub(crate) struct OfflineGgufSession {
-    model: transcribe_cpp::Model,
-    session: Option<transcribe_cpp::Session>,
-}
-
 #[derive(Debug, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct TranscriptSegment {
@@ -127,43 +122,6 @@ impl WarmTranscriber {
     }
 }
 
-impl OfflineGgufSession {
-    pub(crate) fn new(model: transcribe_cpp::Model) -> transcribe_cpp::Result<Self> {
-        let session = model.session()?;
-        Ok(Self {
-            model,
-            session: Some(session),
-        })
-    }
-
-    pub(crate) fn run(
-        &mut self,
-        samples: &[f32],
-        options: &transcribe_cpp::RunOptions,
-    ) -> transcribe_cpp::Result<transcribe_cpp::Transcript> {
-        // transcribe-cpp 0.1.x retains input-sized scheduler buffers for the
-        // session lifetime. Drop each used session before creating its
-        // successor so a long inference cannot pin that high-water mark or
-        // overlap two sessions' persistent decoder state.
-        let mut session = match self.session.take() {
-            Some(session) => session,
-            None => self.model.session()?,
-        };
-        let result = session.run(samples, options);
-        drop(session);
-        match self.model.session() {
-            Ok(session) => {
-                self.session = Some(session);
-                result
-            }
-            Err(recovery_error) => match result {
-                Ok(_) => Err(recovery_error),
-                Err(run_error) => Err(run_error),
-            },
-        }
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use super::{Transcript, UNIFIED_ENGLISH_TRAILING_SILENCE_SAMPLES, prepare_gguf_samples};