@agent-native/core 0.103.1 → 0.104.0

package/corpus/templates/clips/desktop/src/lib/single-flight.ts

@@ -0,0 +1,7 @@
+export function singleFlight<T>(operation: () => Promise<T>): () => Promise<T> {
+  let inFlight: Promise<T> | null = null;
+  return () => {
+    inFlight ??= operation();
+    return inFlight;
+  };
+}

package/corpus/templates/clips/desktop/src/lib/upload-verification.ts

@@ -0,0 +1,51 @@
+export interface FinalizeReceipt {
+  ok?: unknown;
+  finalized?: unknown;
+  status?: unknown;
+  sourceSizeBytes?: unknown;
+  durationMs?: unknown;
+}
+
+export interface LocalRecordingProof {
+  bytes: number;
+  durationMs: number;
+}
+
+export function verifyFinalizeReceipt(
+  receipt: FinalizeReceipt | null,
+  local: LocalRecordingProof,
+): void {
+  if (
+    !receipt ||
+    receipt.ok !== true ||
+    receipt.finalized !== true ||
+    receipt.status !== "ready"
+  ) {
+    throw new Error(
+      "Clip may be incomplete. Finalization was not confirmed; the local backup was kept.",
+    );
+  }
+
+  const sourceSizeBytes = Number(receipt.sourceSizeBytes);
+  if (
+    !Number.isFinite(sourceSizeBytes) ||
+    sourceSizeBytes <= 0 ||
+    sourceSizeBytes !== local.bytes
+  ) {
+    throw new Error(
+      `Clip may be incomplete. The server confirmed ${Number.isFinite(sourceSizeBytes) ? sourceSizeBytes : "an unknown number of"} of ${local.bytes} source bytes; the local backup was kept.`,
+    );
+  }
+
+  const durationMs = Number(receipt.durationMs);
+  const toleranceMs = Math.max(5_000, local.durationMs * 0.02);
+  if (
+    !Number.isFinite(durationMs) ||
+    durationMs <= 0 ||
+    Math.abs(durationMs - local.durationMs) > toleranceMs
+  ) {
+    throw new Error(
+      "Clip may be incomplete. The uploaded duration did not match the local recording; the local backup was kept.",
+    );
+  }
+}

package/corpus/templates/clips/desktop/src/overlays/bubble.tsx

@@ -48,7 +48,7 @@ type BubbleSize = "small" | "medium";
  *
  * # Hover controls (Loom-style)
  *
- * On pointerenter, a small horizontal pill fades in under the bubble
+ * On pointerenter, a small horizontal pill fades in above the bubble
  * with two size-dot buttons (small / medium) and an X close button.
  * Clicking a dot calls `set_bubble_size` on the Rust side, which
  * resizes this window and persists the choice to disk. On
@@ -752,7 +752,7 @@ export function Bubble() {
           </svg>
         </button>
       </div>
-      {/* Size control pill — fades in under the bubble on hover. Marked
+      {/* Size control pill — fades in above the bubble on hover. Marked
           `data-no-drag` so clicks land on the onClick handlers. */}
       <div
         className={`bubble-controls ${showControls ? "is-visible" : ""}`}

package/corpus/templates/clips/desktop/src/overlays/finalizing.tsx

@@ -20,6 +20,7 @@ type ProcessingProgress = {
   stage?: string;
   progress?: number | null;
   viewUrl?: string;
+  savedLocally?: boolean;
 };
 
 type NativeUploadFinished = {
@@ -52,7 +53,10 @@ function takePersistedFinalizingResult(): NativeUploadFinished | null {
       viewUrl: payload.viewUrl,
       ok: payload.ok,
       error: typeof payload.error === "string" ? payload.error : null,
-      localFilePath: null,
+      localFilePath:
+        typeof payload.localFilePath === "string"
+          ? payload.localFilePath
+          : null,
     };
   } catch {
     return null;
@@ -78,6 +82,7 @@ export function Finalizing() {
     let completionTimer: ReturnType<typeof window.setTimeout> | null = null;
     let openingWatchdog: ReturnType<typeof window.setTimeout> | null = null;
     const hardWatchdog = window.setTimeout(() => {
+      void invoke("show_popover").catch(() => {});
       void invoke("hide_finalizing").catch(() => {});
     }, 120_000);
     let finishedHandled = false;
@@ -164,6 +169,7 @@ export function Finalizing() {
         stage: "failed",
         progress: 1,
         viewUrl: payload.viewUrl,
+        savedLocally: Boolean(payload.localFilePath),
       });
       completionTimer = window.setTimeout(() => {
         void invoke("show_popover").catch(() => {});
@@ -212,7 +218,9 @@ export function Finalizing() {
     progress.stage === "uploaded"
       ? "Uploaded"
       : progress.stage === "failed"
-        ? "Upload paused"
+        ? progress.savedLocally
+          ? "Upload paused — clip saved locally"
+          : "Upload paused — open Clips to recover"
         : progress.stage === "uploading" ||
             progress.stage === "processing" ||
             progress.stage === "opening"

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

@@ -3131,25 +3131,27 @@ body[data-clips-route="recording-pill"] #root {
 
 /*
  * The Tauri bubble window is sized (in Rust) to exactly the circle diameter
- * PLUS a `--bubble-controls-budget` strip at the bottom, so the hover pill
+ * PLUS a `--bubble-controls-budget` strip at the top, so the hover pill
  * has real window real-estate to render into. Everything outside window
  * bounds is invisible no matter the CSS `overflow` — you can't paint where
  * the OS hasn't given you pixels — so we build in the budget up front.
  *
  *   ┌──────────────┐
+ *   │  ·  ●        │  ← .bubble-controls pill (hover-faded)
+ *   └──────────────┘
+ *   ┌──────────────┐
  *   │ .bubble-root │  ← circle (drag region, data-tauri-drag-region)
  *   │     ◯        │    Canvas lives here with pointer-events: none so
  *   │              │    drags reach the drag-region parent.
  *   └──────────────┘
- *   ┌──────────────┐
- *   │  ·  ●        │  ← .bubble-controls pill (hover-faded)
- *   └──────────────┘
  */
 .bubble-wrapper {
   position: fixed;
   inset: var(--overlay-shadow-gutter);
   display: flex;
-  flex-direction: column;
+  /* Reverse the stack so the circle stays at the bottom of the window and
+     the hover pill occupies the reserved space above it. */
+  flex-direction: column-reverse;
   align-items: center;
   /* Transparent background — the Tauri window is `transparent: true`,
      so the circular camera surface below paints through. */
@@ -3159,9 +3161,9 @@ body[data-clips-route="recording-pill"] #root {
 }
 
 .bubble-root {
-  /* Circle fills the top of the wrapper. We use `flex: 0 0 auto` + a
+  /* Circle fills the bottom of the wrapper. We use `flex: 0 0 auto` + a
      1:1 aspect-ratio so the circle is always square regardless of the
-     actual window height (which includes the controls budget). */
+     actual window height (which includes the controls budget above it). */
   flex: 0 0 auto;
   aspect-ratio: 1 / 1;
   /* Width = 100% of wrapper → the wrapper is exactly bubble-diameter
@@ -3269,15 +3271,15 @@ body[data-clips-route="recording-pill"] #root {
   color: white;
 }
 
-/* Size-control pill — lives in the bottom strip of the wrapper (beneath
+/* Size-control pill — lives in the top strip of the wrapper (above
    the circle). Centered horizontally, fades in on hover, matches Loom's
    visual weight. Because it's a sibling of `.bubble-root` (not a child),
    the border-radius clipping on the circle can't eat it. */
 .bubble-controls {
-  /* `flex: 0 0 auto` + margin-top creates the small gap between the
-     circle and the pill. */
+  /* `flex: 0 0 auto` + margin-bottom creates the small gap between the
+     pill and the circle. */
   flex: 0 0 auto;
-  margin-top: 8px;
+  margin-bottom: 8px;
   display: inline-flex;
   align-items: center;
   gap: 8px;

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

@@ -87,7 +87,7 @@ enum TextInsertionStrategy {
     UnicodeType,
 }
 
-/// Extra vertical real-estate reserved beneath the circular bubble for the
+/// Extra vertical real-estate reserved above the circular bubble for the
 /// hover-controls pill (small-dot + medium-dot). The Tauri window is
 /// `transparent: true`, so the budget paints through as empty space until the
 /// user hovers the bubble and the pill fades in. We'd otherwise have no pixels
@@ -95,7 +95,7 @@ enum TextInsertionStrategy {
 /// matter what CSS `overflow` says.
 ///
 /// 80 physical px ≈ 40 logical px on retina — enough for the ~28px pill plus
-/// an 8px gap from the circle, with a small cushion at the window bottom.
+/// an 8px gap from the circle, with a small cushion at the window top.
 const BUBBLE_CONTROLS_BUDGET_PX: u32 = 80;
 
 fn overlay_scale_factor(app: &AppHandle) -> f64 {
@@ -128,7 +128,7 @@ fn bubble_size_for_name(name: &str) -> u32 {
 }
 
 /// Total window height for a bubble of the given diameter — includes the
-/// controls-budget strip beneath the circle.
+/// controls-budget strip above the circle.
 fn bubble_window_height_for(size: u32) -> u32 {
     size + BUBBLE_CONTROLS_BUDGET_PX
 }
@@ -874,18 +874,17 @@ pub async fn show_bubble(app: AppHandle) -> Result<(), String> {
     let size_name = load_bubble_size_name(&app);
     let size: u32 = bubble_size_for_name(&size_name);
     // The actual window is TALLER than the circle — see
-    // `BUBBLE_CONTROLS_BUDGET_PX` — to give the hover controls pill room.
+    // `BUBBLE_CONTROLS_BUDGET_PX` — to give the hover controls pill room
+    // above the face while keeping the face aligned to the bottom edge.
     let gutter = overlay_shadow_gutter_physical(&app);
-    let content_h: u32 = bubble_window_height_for(size);
     let (win_w, win_h) = bubble_window_size_for(&app, size);
 
     let (mon_x, mon_y, mon_w, mon_h) = tray_monitor_physical_rect(&app);
 
-    // Default Loom-style anchor: flush-left with a small margin, a hair
-    // above the bottom edge of the target monitor. On Retina the 60
-    // physical-px offset maps to ~30 logical px.
+    // Default Loom-style anchor: flush-left with the circle resting against
+    // the bottom edge of the target monitor (inside the shadow gutter).
     let default_x: i32 = mon_x + 48 - gutter as i32;
-    let default_y: i32 = mon_y + mon_h as i32 - content_h as i32 - 60 - gutter as i32;
+    let default_y: i32 = mon_y + mon_h as i32 - win_h as i32;
     let (default_x, default_y) =
         clamp_bubble_window_position(&app, default_x, default_y, win_w, win_h);
     // Keep saved positions, but normalize them against the current display

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

@@ -298,6 +298,7 @@ async fn tick_once(app: &AppHandle, client: &reqwest::Client) -> Result<(), Stri
         // upcoming window to include recently-started events (see action).
         ("includeStartedWithinMin", "5"),
         ("excludePersonalSoloEvents", "true"),
+        ("excludeDeclinedEvents", "true"),
     ]);
     req = req.header("X-Request-Source", "clips-desktop");
     if let Some(c) = cookie.as_deref() {

package/corpus/templates/clips/desktop/src-tauri/src/native_screen/custom_capture.rs

@@ -1088,6 +1088,93 @@ impl MixerTimeline {
             (0.0, 0.0)
         }
     }
+
+    fn push_at(
+        &mut self,
+        frame_index: i64,
+        interleaved: &[f32],
+        min_base_frame: i64,
+        max_gap: i64,
+    ) {
+        let frames = interleaved.len() / 2;
+        if frames == 0 {
+            return;
+        }
+        if !self.started {
+            self.started = true;
+            self.base_frame = frame_index.max(min_base_frame);
+        }
+
+        let cur_end = self.end_frame();
+        if frame_index > cur_end {
+            let gap = (frame_index - cur_end).min(max_gap) as usize;
+            self.samples
+                .extend(std::iter::repeat(0.0_f32).take(gap * 2));
+        }
+
+        let overlap_frames = (cur_end - frame_index).max(0) as usize;
+        if overlap_frames < frames {
+            self.samples
+                .extend_from_slice(&interleaved[overlap_frames * 2..]);
+        }
+    }
+}
+
+#[cfg(test)]
+mod mixer_timeline_tests {
+    use super::MixerTimeline;
+
+    fn stereo_frames(values: &[f32]) -> Vec<f32> {
+        values.iter().flat_map(|value| [*value, *value]).collect()
+    }
+
+    #[test]
+    fn trims_overlapping_frames_instead_of_extending_the_timeline() {
+        let mut timeline = MixerTimeline::new();
+        timeline.push_at(0, &stereo_frames(&[1.0, 2.0, 3.0, 4.0]), 0, 96_000);
+        timeline.push_at(3, &stereo_frames(&[4.0, 5.0, 6.0, 7.0]), 0, 96_000);
+
+        assert_eq!(
+            timeline.samples,
+            stereo_frames(&[1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0])
+        );
+        assert_eq!(timeline.end_frame(), 7);
+    }
+
+    #[test]
+    fn ignores_fully_duplicated_buffers() {
+        let mut timeline = MixerTimeline::new();
+        let frames = stereo_frames(&[1.0, 2.0, 3.0]);
+        timeline.push_at(0, &frames, 0, 96_000);
+        timeline.push_at(0, &frames, 0, 96_000);
+
+        assert_eq!(timeline.samples, frames);
+        assert_eq!(timeline.end_frame(), 3);
+    }
+
+    #[test]
+    fn trims_input_that_starts_behind_already_emitted_output() {
+        let mut timeline = MixerTimeline::new();
+        timeline.started = true;
+        timeline.base_frame = 10;
+        timeline.push_at(8, &stereo_frames(&[1.0, 2.0, 3.0, 4.0]), 10, 96_000);
+
+        assert_eq!(timeline.samples, stereo_frames(&[3.0, 4.0]));
+        assert_eq!(timeline.end_frame(), 12);
+    }
+
+    #[test]
+    fn preserves_forward_timestamp_gaps_as_silence() {
+        let mut timeline = MixerTimeline::new();
+        timeline.push_at(0, &stereo_frames(&[1.0, 2.0]), 0, 96_000);
+        timeline.push_at(5, &stereo_frames(&[6.0]), 0, 96_000);
+
+        assert_eq!(
+            timeline.samples,
+            stereo_frames(&[1.0, 2.0, 0.0, 0.0, 0.0, 6.0])
+        );
+        assert_eq!(timeline.end_frame(), 6);
+    }
 }
 
 enum SourceBound {
@@ -1198,19 +1285,7 @@ impl LiveAudioMixer {
             MixSource::System => &mut self.system,
             MixSource::Mic => &mut self.mic,
         };
-        if !timeline.started {
-            timeline.started = true;
-            // Never start behind already-emitted output.
-            timeline.base_frame = frame_index.max(out_pos);
-        }
-        let cur_end = timeline.end_frame();
-        if frame_index > cur_end {
-            let gap = (frame_index - cur_end).min(max_gap) as usize;
-            timeline
-                .samples
-                .extend(std::iter::repeat(0.0_f32).take(gap * 2));
-        }
-        timeline.samples.extend_from_slice(interleaved);
+        timeline.push_at(frame_index, interleaved, out_pos, max_gap);
         timeline.last_push = Some(Instant::now());
     }
 

package/corpus/templates/clips/desktop/src-tauri/src/native_screen/live_upload.rs

@@ -161,6 +161,7 @@ async fn send_live_upload_post_with_retry(
     total: usize,
     is_final: bool,
     duration_ms: Option<u128>,
+    expected_source_bytes: Option<u64>,
     bytes: &[u8],
 ) -> Result<(), String> {
     let rec = &params.recording_id;
@@ -192,6 +193,7 @@ async fn send_live_upload_post_with_retry(
             params.has_camera,
             NativeUploadMode::Buffered,
             false,
+            expected_source_bytes,
             bytes.to_vec(),
         )
         .await;
@@ -258,7 +260,7 @@ async fn live_upload_loop(
                 bytes.len()
             );
             if let Err(e) = send_live_upload_post_with_retry(
-                &client, &ctrl, &params, index, 0, false, None, &bytes,
+                &client, &ctrl, &params, index, 0, false, None, None, &bytes,
             )
             .await
             {
@@ -301,7 +303,15 @@ async fn live_upload_loop(
                     "[live-upload] {rec}: sending tail chunk #{index} offset={offset} size={take} final={is_last}"
                 );
                 if let Err(e) = send_live_upload_post_with_retry(
-                    &client, &ctrl, &params, index, total, is_last, duration, &bytes,
+                    &client,
+                    &ctrl,
+                    &params,
+                    index,
+                    total,
+                    is_last,
+                    duration,
+                    is_last.then_some(final_len),
+                    &bytes,
                 )
                 .await
                 {
@@ -329,6 +339,7 @@ async fn live_upload_loop(
                     index + 1,
                     true,
                     Some(duration_ms),
+                    Some(final_len),
                     &[],
                 )
                 .await