@agent-native/core 0.152.1 → 0.153.1

package/corpus/templates/clips/desktop/src/styles.css

@@ -13,6 +13,7 @@
   --surface: #f7f7f7;
   --surface-hover: #f0f0f0;
   --surface-strong: #ebebeb;
+  --settings-nav-active: #ffffff;
   --fg: #171717;
   --fg-muted: #737373;
   --fg-subtle: #a3a3a3;
@@ -48,6 +49,7 @@
     --surface: #262626;
     --surface-hover: #2e2e2e;
     --surface-strong: #3d3d3d;
+    --settings-nav-active: var(--surface-hover);
     --fg: #f5f5f5;
     --fg-muted: #a3a3a3;
     --fg-subtle: #737373;
@@ -237,9 +239,9 @@ body[data-clips-route="recording-pill"] #root {
 }
 
 .settings-nav-button.is-active {
-  background: var(--bg);
+  background: var(--settings-nav-active);
   color: var(--fg);
-  box-shadow: var(--shadow-sm);
+  box-shadow: none;
 }
 
 .settings-nav-button:focus-visible {
@@ -2577,6 +2579,12 @@ body[data-clips-route="recording-pill"] #root {
   overscroll-behavior: contain;
 }
 
+.setup.settings-page {
+  padding: 0;
+  gap: 0;
+  overflow: hidden;
+}
+
 /* Meetings / dictation drill-ins: a touch more room under the last row so
    content isn't flush with the panel edge. Must follow `.setup` so it wins
    over the shorthand padding above. */

package/corpus/templates/clips/desktop/src-tauri/src/adhoc_meetings_watcher.rs

@@ -1,10 +1,10 @@
 //! Granola-style adhoc Zoom / Teams detection.
 //!
 //! Polls the frontmost macOS app every few seconds. When Zoom or Teams stays
-//! frontmost for a short dwell window, creates a meeting row via
-//! `create-meeting`, and silently starts transcription when the user has
-//! explicitly selected Auto mode. Ask/manual mode stays quiet because a
-//! frontmost Zoom window is not reliable evidence of an active call.
+//! frontmost for a short dwell window *and* that app is holding a live audio
+//! input, creates a meeting row via `create-meeting` and shows the same
+//! meeting-notification overlay used for calendar reminders — with
+//! `type: "adhoc"`.
 //!
 //! Reuses `MeetingsWatcherState` session (server URL + cookie + auth token)
 //! so the popover only needs to push credentials once.
@@ -130,6 +130,50 @@ fn match_vc_bundle(bundle: &str) -> Option<(&'static str, &'static str)> {
         .map(|(_, platform, title)| (*platform, *title))
 }
 
+/// Bundle ids belonging to one platform, lowercased for CoreAudio comparison.
+///
+/// Scoped to the frontmost platform rather than every call app: Teams sitting
+/// in a call must not vouch for a Zoom window that is merely open.
+fn bundles_for_platform(platform: &str) -> Vec<String> {
+    STRONG_VC_BUNDLES
+        .iter()
+        .filter(|(_, candidate, _)| *candidate == platform)
+        .map(|(bundle_id, _, _)| bundle_id.to_lowercase())
+        .collect()
+}
+
+/// Whether a live-input reading should veto a dwell-confirmed detection.
+///
+/// Only an explicit `Some(false)` blocks. `None` means the OS declined to
+/// answer — `kAudioProcessPropertyIsRunningInput` is macOS 14+ — and treating
+/// that as "no call" would leave every older machine detecting nothing at all,
+/// which is the failure mode this whole branch exists to undo.
+fn mic_vetoes_detection(mic_running: Option<bool>) -> bool {
+    mic_running == Some(false)
+}
+
+/// What a dwell-confirmed detection is allowed to do under the current mode.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+struct AdhocNotificationPlan {
+    /// Surface the meeting-notification overlay so the user can accept.
+    show_widget: bool,
+    /// Begin transcription without waiting for a click.
+    auto_start: bool,
+}
+
+/// Ask must surface the overlay. Collapsing this gate to `mode == Auto` is the
+/// regression that shipped in b00c38db4: Ask is the shipped default, so ad-hoc
+/// detection produced neither a prompt nor a capture and went silently dead.
+fn adhoc_notification_plan(config: &crate::config::FeatureConfig) -> AdhocNotificationPlan {
+    let auto_start = config.meeting_transcription_mode == MeetingTranscriptionMode::Auto;
+    AdhocNotificationPlan {
+        show_widget: config.show_meeting_widget_enabled
+            || config.meeting_transcription_mode == MeetingTranscriptionMode::Ask
+            || auto_start,
+        auto_start,
+    }
+}
+
 async fn tick_once(app: &AppHandle, client: &reqwest::Client) -> Result<(), String> {
     let config = feature_config(app);
     if !config.meetings_enabled {
@@ -158,7 +202,7 @@ async fn tick_macos(
     let front = crate::util::frontmost_bundle_id();
     let matched = front.as_deref().and_then(match_vc_bundle);
 
-    let Some((platform, _title)) = matched else {
+    let Some((platform, title)) = matched else {
         // VC app left front — clear session dedupe so a later re-focus can
         // fire again (cooldown still applies).
         clear_session_if_left(app, None);
@@ -174,7 +218,22 @@ async fn tick_macos(
         return Ok(());
     }
 
-    if config.meeting_transcription_mode != MeetingTranscriptionMode::Auto {
+    if config.meeting_transcription_mode == MeetingTranscriptionMode::Manual
+        && !config.show_meeting_widget_enabled
+    {
+        reset_dwell(app);
+        return Ok(());
+    }
+
+    // Frontmost dwell alone also matches Zoom parked on a second monitor or
+    // opened to check a schedule — the reason prompting was muted in the first
+    // place. A live input stream is what separates an app being open from a
+    // call being underway. `None` means the OS could not answer (the property
+    // is macOS 14+), so fall back to dwell-only rather than going silently
+    // dead on older systems.
+    let call_bundles = bundles_for_platform(platform);
+    let mic_running = crate::call_activity::call_app_uses_microphone(&call_bundles);
+    if mic_vetoes_detection(mic_running) {
         reset_dwell(app);
         return Ok(());
     }
@@ -249,14 +308,44 @@ async fn tick_macos(
         }
     };
 
-    let _ = app.emit(
-        "meetings:start-transcription",
-        serde_json::json!({
-            "meetingId": meeting_id,
-            "joinUrl": null,
-            "reason": "adhoc-auto",
-        }),
-    );
+    let AdhocNotificationPlan {
+        show_widget,
+        auto_start,
+    } = adhoc_notification_plan(config);
+
+    if show_widget {
+        let app_clone = app.clone();
+        let id_clone = meeting_id.clone();
+        let title_clone = title.to_string();
+        let platform_clone = platform.to_string();
+        let scheduled_start = chrono::Utc::now().to_rfc3339();
+        tauri::async_runtime::spawn(async move {
+            let _ = crate::notifications::notify_meeting_starting(
+                app_clone,
+                id_clone,
+                title_clone,
+                0,
+                None,
+                Some(scheduled_start),
+                None,
+                Some(platform_clone),
+                Some(auto_start),
+                Some("adhoc".to_string()),
+            )
+            .await;
+        });
+    }
+
+    if auto_start {
+        let _ = app.emit(
+            "meetings:start-transcription",
+            serde_json::json!({
+                "meetingId": meeting_id,
+                "joinUrl": null,
+                "reason": "adhoc-auto",
+            }),
+        );
+    }
 
     Ok(())
 }
@@ -265,6 +354,69 @@ async fn tick_macos(
 mod tests {
     use super::*;
 
+    fn config_with(
+        mode: MeetingTranscriptionMode,
+        show_meeting_widget_enabled: bool,
+    ) -> crate::config::FeatureConfig {
+        crate::config::FeatureConfig {
+            meeting_transcription_mode: mode,
+            show_meeting_widget_enabled,
+            ..Default::default()
+        }
+    }
+
+    #[test]
+    fn platform_bundles_do_not_vouch_for_each_other() {
+        let zoom = bundles_for_platform("zoom");
+        assert!(zoom.contains(&"us.zoom.xos".to_string()));
+        assert!(zoom.contains(&"us.zoom.zoomclips".to_string()));
+        assert!(!zoom.iter().any(|id| id.contains("teams")));
+
+        let teams = bundles_for_platform("teams");
+        assert!(teams.contains(&"com.microsoft.teams2".to_string()));
+        assert!(!teams.iter().any(|id| id.contains("zoom")));
+
+        assert!(bundles_for_platform("webex").is_empty());
+    }
+
+    #[test]
+    fn an_unreadable_microphone_does_not_veto_detection() {
+        // Only a definite "not in a call" blocks. Collapsing None into false
+        // would make ad-hoc detection dead on macOS 13, where the CoreAudio
+        // property does not exist — the exact silent-death this branch undoes.
+        assert!(mic_vetoes_detection(Some(false)));
+        assert!(!mic_vetoes_detection(Some(true)));
+        assert!(!mic_vetoes_detection(None));
+    }
+
+    #[test]
+    fn ask_mode_prompts_without_auto_starting() {
+        // The b00c38db4 regression: Ask is the shipped default, so if this
+        // stops surfacing the overlay, ad-hoc detection is dead for everyone
+        // who never opened Settings.
+        let plan = adhoc_notification_plan(&config_with(MeetingTranscriptionMode::Ask, false));
+        assert!(plan.show_widget);
+        assert!(!plan.auto_start);
+    }
+
+    #[test]
+    fn auto_mode_prompts_and_starts() {
+        let plan = adhoc_notification_plan(&config_with(MeetingTranscriptionMode::Auto, false));
+        assert!(plan.show_widget);
+        assert!(plan.auto_start);
+    }
+
+    #[test]
+    fn manual_mode_stays_silent_only_when_the_widget_is_disabled() {
+        let hidden = adhoc_notification_plan(&config_with(MeetingTranscriptionMode::Manual, false));
+        assert!(!hidden.show_widget);
+        assert!(!hidden.auto_start);
+
+        let shown = adhoc_notification_plan(&config_with(MeetingTranscriptionMode::Manual, true));
+        assert!(shown.show_widget);
+        assert!(!shown.auto_start);
+    }
+
     #[test]
     fn dismissal_refreshes_the_existing_cooldown_and_clears_dwell() {
         let now_ts = 1_000;

package/corpus/templates/clips/desktop/src-tauri/src/call_activity.rs

@@ -0,0 +1,146 @@
+//! Whether a conferencing app is holding a live audio input right now.
+//!
+//! Both meeting watchers read this, from opposite ends of a call: the ad-hoc
+//! detector treats a running input as corroboration that a call actually
+//! started, and the silence detector treats its release as evidence one ended.
+
+#[cfg(target_os = "macos")]
+pub(crate) fn default_call_app_bundle_ids() -> Vec<String> {
+    [
+        "us.zoom.xos",
+        "us.zoom.ZoomClips",
+        "com.microsoft.teams2",
+        "com.microsoft.teams",
+    ]
+    .into_iter()
+    .map(|bundle_id| bundle_id.to_lowercase())
+    .collect()
+}
+
+/// Returns whether one of the target conferencing apps currently has a live
+/// CoreAudio input stream. `None` means the OS could not provide a reliable
+/// answer, so callers must keep the existing conservative fallbacks.
+///
+/// `kAudioProcessPropertyIsRunningInput` is macOS 14+, so an older system is a
+/// `None` and never a `Some(false)`. Callers that collapse the two make the
+/// feature silently dead on Sonoma-minus rather than degraded.
+///
+/// Observation only: this enumerates process objects and never opens an input
+/// unit. A detector that grabbed one while idle would fight `whisper_speech`,
+/// which holds VPIO with uplink processing bypassed precisely so a call app
+/// cannot starve Clips of mic buffers.
+#[cfg(target_os = "macos")]
+pub(crate) fn call_app_uses_microphone(bundle_ids: &[String]) -> Option<bool> {
+    use core_foundation::base::TCFType;
+    use core_foundation::string::CFString;
+    use objc2_core_audio::{
+        kAudioHardwareNoError, kAudioHardwarePropertyProcessObjectList,
+        kAudioObjectPropertyElementMain, kAudioObjectPropertyScopeGlobal, kAudioObjectSystemObject,
+        kAudioProcessPropertyBundleID, kAudioProcessPropertyIsRunningInput,
+        AudioObjectGetPropertyData, AudioObjectGetPropertyDataSize, AudioObjectID,
+        AudioObjectPropertyAddress,
+    };
+    use std::ffi::c_void;
+    use std::mem::size_of;
+    use std::ptr::NonNull;
+
+    let mut list_address = AudioObjectPropertyAddress {
+        mSelector: kAudioHardwarePropertyProcessObjectList,
+        mScope: kAudioObjectPropertyScopeGlobal,
+        mElement: kAudioObjectPropertyElementMain,
+    };
+    let mut data_size = 0;
+    let list_status = unsafe {
+        AudioObjectGetPropertyDataSize(
+            kAudioObjectSystemObject as AudioObjectID,
+            NonNull::from(&mut list_address),
+            0,
+            std::ptr::null(),
+            NonNull::from(&mut data_size),
+        )
+    };
+    if list_status != kAudioHardwareNoError || data_size == 0 {
+        return None;
+    }
+
+    let mut processes = vec![0 as AudioObjectID; data_size as usize / size_of::<AudioObjectID>()];
+    let list_status = unsafe {
+        AudioObjectGetPropertyData(
+            kAudioObjectSystemObject as AudioObjectID,
+            NonNull::from(&mut list_address),
+            0,
+            std::ptr::null(),
+            NonNull::from(&mut data_size),
+            NonNull::new(processes.as_mut_ptr().cast::<c_void>())?,
+        )
+    };
+    if list_status != kAudioHardwareNoError {
+        return None;
+    }
+
+    // Set when a target bundle is found but its running-input state can't be
+    // read. Distinct from "no target bundle is running at all" — the caller's
+    // None/Some(false) contract depends on not conflating the two.
+    let mut matched_bundle_with_unreadable_input = false;
+
+    for process in processes {
+        let mut bundle_address = AudioObjectPropertyAddress {
+            mSelector: kAudioProcessPropertyBundleID,
+            mScope: kAudioObjectPropertyScopeGlobal,
+            mElement: kAudioObjectPropertyElementMain,
+        };
+        let mut bundle_ref: *const c_void = std::ptr::null();
+        let mut bundle_size = size_of::<*const c_void>() as u32;
+        let bundle_status = unsafe {
+            AudioObjectGetPropertyData(
+                process,
+                NonNull::from(&mut bundle_address),
+                0,
+                std::ptr::null(),
+                NonNull::from(&mut bundle_size),
+                NonNull::new((&mut bundle_ref as *mut *const c_void).cast::<c_void>())?,
+            )
+        };
+        if bundle_status != kAudioHardwareNoError || bundle_ref.is_null() {
+            continue;
+        }
+        let bundle_id = unsafe {
+            CFString::wrap_under_get_rule(bundle_ref as core_foundation::string::CFStringRef)
+        }
+        .to_string()
+        .to_lowercase();
+        if !bundle_ids.iter().any(|candidate| candidate == &bundle_id) {
+            continue;
+        }
+
+        let mut input_address = AudioObjectPropertyAddress {
+            mSelector: kAudioProcessPropertyIsRunningInput,
+            mScope: kAudioObjectPropertyScopeGlobal,
+            mElement: kAudioObjectPropertyElementMain,
+        };
+        let mut input_running: u32 = 0;
+        let mut input_size = size_of::<u32>() as u32;
+        let input_status = unsafe {
+            AudioObjectGetPropertyData(
+                process,
+                NonNull::from(&mut input_address),
+                0,
+                std::ptr::null(),
+                NonNull::from(&mut input_size),
+                NonNull::new((&mut input_running as *mut u32).cast::<c_void>())?,
+            )
+        };
+        if input_status != kAudioHardwareNoError {
+            matched_bundle_with_unreadable_input = true;
+            continue;
+        }
+        if input_running != 0 {
+            return Some(true);
+        }
+    }
+
+    if matched_bundle_with_unreadable_input {
+        return None;
+    }
+    Some(false)
+}

package/corpus/templates/clips/desktop/src-tauri/src/clips/mod.rs

@@ -70,7 +70,7 @@ const ONBOARDING_HEIGHT_LOGICAL: f64 = 640.0;
 const BUBBLE_SIZE_SMALL: u32 = 360;
 const BUBBLE_SIZE_MEDIUM: u32 = 504;
 const POPOVER_SHADOW_GUTTER_LOGICAL: f64 = 24.0;
-const POPOVER_DEFAULT_WIDTH_LOGICAL: f64 = 360.0;
+const POPOVER_DEFAULT_WIDTH_LOGICAL: f64 = 320.0;
 const POPOVER_DEFAULT_HEIGHT_LOGICAL: f64 = 520.0;
 const OVERLAY_SHADOW_GUTTER_LOGICAL: f64 = 18.0;
 
@@ -1342,7 +1342,7 @@ pub async fn resize_popover(app: AppHandle, height: f64, width: Option<f64>) ->
             })
             .unwrap_or(820.0);
         let clamped = height.clamp(200.0, max_logical_height);
-        let width = width.unwrap_or(360.0).clamp(320.0, 960.0);
+        let width = width.unwrap_or(320.0).clamp(320.0, 960.0);
         let (window_width, window_height) = popover_window_size_logical(width, clamped);
         let _ = w.set_size(tauri::Size::Logical(tauri::LogicalSize::new(
             window_width,

package/corpus/templates/clips/desktop/src-tauri/src/lib.rs

@@ -6,6 +6,7 @@
 
 mod accessibility;
 mod adhoc_meetings_watcher;
+mod call_activity;
 mod capture_audio_bus;
 mod capture_graph;
 mod clips;

package/corpus/templates/clips/desktop/src-tauri/src/silence_detector.rs

@@ -420,7 +420,7 @@ fn install_call_ended_watcher(app: &AppHandle, threshold_ms: u64) {
                     generation = Some(active_generation);
                 }
                 let call_app_bundle_ids = if configured_bundle_ids.is_empty() {
-                    default_call_app_bundle_ids()
+                    crate::call_activity::default_call_app_bundle_ids()
                 } else {
                     configured_bundle_ids
                 };
@@ -459,7 +459,7 @@ fn install_call_ended_watcher(app: &AppHandle, threshold_ms: u64) {
                 // transition that stays stable for 30 seconds; this tolerates
                 // a device handoff while avoiding a stop before the call has
                 // actually acquired its microphone.
-                match call_app_uses_microphone(&call_app_bundle_ids) {
+                match crate::call_activity::call_app_uses_microphone(&call_app_bundle_ids) {
                     Some(true) => {
                         call_app_used_microphone = true;
                         microphone_released_at = None;
@@ -503,19 +503,6 @@ fn install_call_ended_watcher(app: &AppHandle, threshold_ms: u64) {
 #[cfg(not(target_os = "macos"))]
 fn install_call_ended_watcher(_app: &AppHandle, _threshold_ms: u64) {}
 
-#[cfg(target_os = "macos")]
-fn default_call_app_bundle_ids() -> Vec<String> {
-    [
-        "us.zoom.xos",
-        "us.zoom.ZoomClips",
-        "com.microsoft.teams2",
-        "com.microsoft.teams",
-    ]
-    .into_iter()
-    .map(|bundle_id| bundle_id.to_lowercase())
-    .collect()
-}
-
 fn microphone_release_stop_ready(
     app_used_microphone: bool,
     released_for: Option<Duration>,
@@ -526,113 +513,6 @@ fn microphone_release_stop_ready(
             .unwrap_or(false)
 }
 
-/// Returns whether one of the target conferencing apps currently has a live
-/// CoreAudio input stream. `None` means the OS could not provide a reliable
-/// answer, so callers must keep the existing conservative fallbacks.
-#[cfg(target_os = "macos")]
-fn call_app_uses_microphone(bundle_ids: &[String]) -> Option<bool> {
-    use core_foundation::base::TCFType;
-    use core_foundation::string::CFString;
-    use objc2_core_audio::{
-        kAudioHardwareNoError, kAudioHardwarePropertyProcessObjectList,
-        kAudioObjectPropertyElementMain, kAudioObjectPropertyScopeGlobal, kAudioObjectSystemObject,
-        kAudioProcessPropertyBundleID, kAudioProcessPropertyIsRunningInput,
-        AudioObjectGetPropertyData, AudioObjectGetPropertyDataSize, AudioObjectID,
-        AudioObjectPropertyAddress,
-    };
-    use std::ffi::c_void;
-    use std::mem::size_of;
-    use std::ptr::NonNull;
-
-    let mut list_address = AudioObjectPropertyAddress {
-        mSelector: kAudioHardwarePropertyProcessObjectList,
-        mScope: kAudioObjectPropertyScopeGlobal,
-        mElement: kAudioObjectPropertyElementMain,
-    };
-    let mut data_size = 0;
-    let list_status = unsafe {
-        AudioObjectGetPropertyDataSize(
-            kAudioObjectSystemObject as AudioObjectID,
-            NonNull::from(&mut list_address),
-            0,
-            std::ptr::null(),
-            NonNull::from(&mut data_size),
-        )
-    };
-    if list_status != kAudioHardwareNoError || data_size == 0 {
-        return None;
-    }
-
-    let mut processes = vec![0 as AudioObjectID; data_size as usize / size_of::<AudioObjectID>()];
-    let list_status = unsafe {
-        AudioObjectGetPropertyData(
-            kAudioObjectSystemObject as AudioObjectID,
-            NonNull::from(&mut list_address),
-            0,
-            std::ptr::null(),
-            NonNull::from(&mut data_size),
-            NonNull::new(processes.as_mut_ptr().cast::<c_void>())?,
-        )
-    };
-    if list_status != kAudioHardwareNoError {
-        return None;
-    }
-
-    for process in processes {
-        let mut bundle_address = AudioObjectPropertyAddress {
-            mSelector: kAudioProcessPropertyBundleID,
-            mScope: kAudioObjectPropertyScopeGlobal,
-            mElement: kAudioObjectPropertyElementMain,
-        };
-        let mut bundle_ref: *const c_void = std::ptr::null();
-        let mut bundle_size = size_of::<*const c_void>() as u32;
-        let bundle_status = unsafe {
-            AudioObjectGetPropertyData(
-                process,
-                NonNull::from(&mut bundle_address),
-                0,
-                std::ptr::null(),
-                NonNull::from(&mut bundle_size),
-                NonNull::new((&mut bundle_ref as *mut *const c_void).cast::<c_void>())?,
-            )
-        };
-        if bundle_status != kAudioHardwareNoError || bundle_ref.is_null() {
-            continue;
-        }
-        let bundle_id = unsafe {
-            CFString::wrap_under_get_rule(bundle_ref as core_foundation::string::CFStringRef)
-        }
-        .to_string()
-        .to_lowercase();
-        if !bundle_ids.iter().any(|candidate| candidate == &bundle_id) {
-            continue;
-        }
-
-        let mut input_address = AudioObjectPropertyAddress {
-            mSelector: kAudioProcessPropertyIsRunningInput,
-            mScope: kAudioObjectPropertyScopeGlobal,
-            mElement: kAudioObjectPropertyElementMain,
-        };
-        let mut input_running: u32 = 0;
-        let mut input_size = size_of::<u32>() as u32;
-        let input_status = unsafe {
-            AudioObjectGetPropertyData(
-                process,
-                NonNull::from(&mut input_address),
-                0,
-                std::ptr::null(),
-                NonNull::from(&mut input_size),
-                NonNull::new((&mut input_running as *mut u32).cast::<c_void>())?,
-            )
-        };
-        if input_status == kAudioHardwareNoError && input_running != 0 {
-            return Some(true);
-        }
-    }
-
-    Some(false)
-}
-
 fn scheduled_end_reached(scheduled_end_ms: Option<u64>, now_ms: u64) -> bool {
     scheduled_end_ms
         .map(|end_ms| now_ms >= end_ms)

package/corpus/templates/clips/desktop/src-tauri/src/util.rs

@@ -7,7 +7,7 @@ use crate::state::{
 };
 
 const POPOVER_SHADOW_GUTTER_LOGICAL: f64 = 24.0;
-const POPOVER_DEFAULT_WIDTH_LOGICAL: f64 = 360.0;
+const POPOVER_DEFAULT_WIDTH_LOGICAL: f64 = 320.0;
 const POPOVER_DEFAULT_HEIGHT_LOGICAL: f64 = 520.0;
 
 // ---------------------------------------------------------------------------

package/corpus/templates/clips/server/lib/recording-page-access.ts

@@ -1,4 +1,9 @@
-export type RecordingPageAccessRole = "owner" | "admin" | "editor" | "viewer";
+export type RecordingPageAccessRole =
+  | "owner"
+  | "admin"
+  | "editor"
+  | "commenter"
+  | "viewer";
 
 /**
  * Match the public recording and video routes: only a finite expiry date can

package/corpus/templates/clips/server/routes/api/public-recording.get.ts

@@ -524,6 +524,11 @@ export default defineEventHandler(async (event) => {
             viewerRole === "owner" ||
             viewerRole === "admin" ||
             viewerRole === "editor",
+          canComment:
+            viewerRole === "owner" ||
+            viewerRole === "admin" ||
+            viewerRole === "editor" ||
+            viewerRole === "commenter",
           isOwner: viewerRole === "owner",
           role: viewerRole ?? "viewer",
           canOpenDashboard,

package/corpus/templates/clips/shared/share-meta.ts

@@ -17,6 +17,19 @@ export type ClipsShareMetaRecording = {
   animatedThumbnailUrl?: string | null;
 };
 
+export type PreferredThumbnailVariant = "still" | "animated";
+
+export function preferredThumbnailVariant(
+  recording: Pick<
+    ClipsShareMetaRecording,
+    "thumbnailUrl" | "animatedThumbnailUrl"
+  > | null,
+): PreferredThumbnailVariant | null {
+  if (recording?.thumbnailUrl?.trim()) return "still";
+  if (recording?.animatedThumbnailUrl?.trim()) return "animated";
+  return null;
+}
+
 export function hasGeneratedTitle(title: string | null | undefined): boolean {
   const trimmed = (title ?? "").trim();
   return Boolean(
@@ -51,9 +64,12 @@ export function clipsShareDescription(
 export function preferredSocialImage(
   recording: ClipsShareMetaRecording | null,
 ): string | undefined {
-  return (
-    recording?.thumbnailUrl || recording?.animatedThumbnailUrl || undefined
-  );
+  const variant = preferredThumbnailVariant(recording);
+  return variant === "still"
+    ? recording?.thumbnailUrl?.trim()
+    : variant === "animated"
+      ? recording?.animatedThumbnailUrl?.trim()
+      : undefined;
 }
 
 function absoluteUrl(value: string, origin: string | null): string {