Skip to content

armgit / Cap

Public Imported from GitHub
0

Open source Loom alternative. Beautiful, shareable screen recordings.

162 KB
Raw Blame
use std::collections::{HashMap, VecDeque};
use std::io::{Read, Seek, SeekFrom};
use std::path::{Path, PathBuf};
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::{Arc, Mutex, OnceLock};
use std::time::{Duration, Instant};

use cap_enc_ffmpeg::segmented_stream::{SegmentCompletedEvent, SegmentMediaType};
use cap_project::{RecordingMeta, S3UploadMeta, SharingMeta, UploadMeta, VideoUploadInfo};
use cap_recording::upload_preparation::{Preparation, Segment};
use futures_util::{StreamExt as _, stream::FuturesUnordered};
use reqwest::StatusCode;
use serde::{Deserialize, Serialize};
use serde_json::{Value, json};

use crate::auth::{self, AuthApiError};

pub(crate) mod instant_cleanup;
#[cfg(test)]
mod multipart_tests;
pub(crate) mod queue;
#[cfg(test)]
mod real_app_tests;
#[cfg(test)]
mod verify_tests;

const MIN_CHUNK_SIZE: u64 = 5 * 1024 * 1024;
const MAX_CHUNK_SIZE: u64 = 15 * 1024 * 1024;
const DRIVE_CHUNK_ALIGNMENT: u64 = 256 * 1024;
const MAX_SEGMENT_UPLOADS: usize = 6;
const SEGMENT_URL_PREFETCH: u32 = 20;
const SEGMENT_UPLOAD_ATTEMPTS: u32 = 3;
const SEGMENT_RETRY_WINDOW: Duration = Duration::from_secs(5 * 60);
const SEGMENT_RETRY_MIN_DELAY: Duration = Duration::from_secs(2);
const SEGMENT_RETRY_MAX_DELAY: Duration = Duration::from_secs(30);
const MANIFEST_UPLOAD_INTERVAL: Duration = Duration::from_secs(1);
const MANIFEST_SUBPATH: &str = "segments/manifest.json";
// Presigned S3 PUT URLs are signed for 30 minutes and accept repeated PUTs, so
// the manifest reuses one well inside that window instead of signing a new URL
// every second. Google Drive upload sessions are single use and never reused.
const MANIFEST_URL_REUSE: Duration = Duration::from_secs(10 * 60);
const UPLOAD_CONNECT_TIMEOUT: Duration = Duration::from_secs(15);
const UPLOAD_TCP_KEEPALIVE: Duration = Duration::from_secs(30);
const UPLOAD_POOL_IDLE_TIMEOUT: Duration = Duration::from_secs(30);

#[derive(Debug, Clone, Deserialize)]
struct SignedUploadTarget {
    url: String,
    #[serde(default)]
    headers: HashMap<String, String>,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub enum UploadResult {
    Success(String),
    NotAuthenticated,
    UpgradeRequired,
}

pub struct InstantUpload {
    pub video: VideoUploadInfo,
    segment_upload: Option<tokio::task::JoinHandle<Result<(), String>>>,
    cancel: Arc<AtomicBool>,
    metadata_lock: Arc<Mutex<()>>,
    completion_permit: Option<tokio::sync::oneshot::Sender<()>>,
    completion_control: Option<CompletionControl>,
    bridge: Option<std::thread::JoinHandle<()>>,
    ownership: Option<cap_recording::upload_resume::UploadLock>,
    prior_attempts: u32,
    request_context: Option<auth::UploadRequestContext>,
    reads: Arc<UploadReads>,
}

#[derive(Default)]
struct UploadReads {
    active: std::sync::atomic::AtomicUsize,
    finished: tokio::sync::Notify,
}

struct UploadReadGuard(Arc<UploadReads>);

impl Drop for UploadReadGuard {
    fn drop(&mut self) {
        if self.0.active.fetch_sub(1, Ordering::AcqRel) == 1 {
            self.0.finished.notify_one();
        }
    }
}

impl UploadReads {
    async fn join(&self) {
        while self.active.load(Ordering::Acquire) != 0 {
            self.finished.notified().await;
        }
    }
}

tokio::task_local! {
    static UPLOAD_READS: Arc<UploadReads>;
}

async fn tracked_upload_read<T: Send + 'static>(
    read: impl FnOnce() -> T + Send + 'static,
) -> Result<T, tokio::task::JoinError> {
    let guard = UPLOAD_READS
        .try_with(|reads| {
            reads.active.fetch_add(1, Ordering::AcqRel);
            UploadReadGuard(reads.clone())
        })
        .ok();
    tokio::task::spawn_blocking(move || {
        let _guard = guard;
        read()
    })
    .await
}

async fn with_upload_context<F: Future>(
    context: Option<auth::UploadRequestContext>,
    reads: Arc<UploadReads>,
    future: F,
) -> F::Output {
    UPLOAD_READS
        .scope(reads, async move {
            match context {
                Some(context) => context.run(future).await,
                None => future.await,
            }
        })
        .await
}

#[derive(Clone)]
pub(crate) struct CompletionControl {
    denied: tokio::sync::watch::Sender<bool>,
    cancel: Arc<AtomicBool>,
    expected_manifest: Arc<Mutex<Option<SegmentUploadManifest>>>,
}

impl CompletionControl {
    pub(crate) fn deny(&self) {
        self.cancel.store(true, Ordering::Release);
        self.denied.send_replace(true);
    }
}

pub(crate) struct CompletionAuthorization {
    permit: tokio::sync::oneshot::Sender<()>,
    required: CompletionRequirement,
    control: CompletionControl,
}

struct CompletionRequirement {
    permission: tokio::sync::oneshot::Receiver<()>,
    denied: tokio::sync::watch::Receiver<bool>,
    expected_manifest: Arc<Mutex<Option<SegmentUploadManifest>>>,
}

impl CompletionAuthorization {
    pub(crate) fn new() -> Self {
        let (permit, permission) = tokio::sync::oneshot::channel();
        let (denied, denial) = tokio::sync::watch::channel(false);
        let expected_manifest = Arc::new(Mutex::new(None));
        Self {
            permit,
            required: CompletionRequirement {
                permission,
                denied: denial,
                expected_manifest: expected_manifest.clone(),
            },
            control: CompletionControl {
                denied,
                cancel: Arc::new(AtomicBool::new(false)),
                expected_manifest,
            },
        }
    }
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
struct SegmentManifestEntry {
    index: u32,
    duration: f64,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
struct SegmentUploadManifest {
    version: u32,
    video_init_uploaded: bool,
    audio_init_uploaded: bool,
    video_segments: Vec<SegmentManifestEntry>,
    audio_segments: Vec<SegmentManifestEntry>,
    is_complete: bool,
}

impl Default for SegmentUploadManifest {
    fn default() -> Self {
        Self {
            version: 2,
            video_init_uploaded: false,
            audio_init_uploaded: false,
            video_segments: Vec::new(),
            audio_segments: Vec::new(),
            is_complete: false,
        }
    }
}

impl SegmentUploadManifest {
    fn record(&mut self, event: &SegmentCompletedEvent) {
        match (event.is_init, event.media_type) {
            (true, SegmentMediaType::Video) => self.video_init_uploaded = true,
            (true, SegmentMediaType::Audio) => self.audio_init_uploaded = true,
            (false, media_type) => {
                let segments = match media_type {
                    SegmentMediaType::Video => &mut self.video_segments,
                    SegmentMediaType::Audio => &mut self.audio_segments,
                };
                if let Some(segment) = segments
                    .iter_mut()
                    .find(|segment| segment.index == event.index)
                {
                    segment.duration = event.duration;
                } else {
                    segments.push(SegmentManifestEntry {
                        index: event.index,
                        duration: event.duration,
                    });
                    segments.sort_unstable_by_key(|segment| segment.index);
                }
            }
        }
    }

    fn has_video_content(&self) -> bool {
        self.video_init_uploaded && !self.video_segments.is_empty()
    }
}

// Only the share page's early playback reads this; the complete manifest stays
// the source of truth for everything else.
const RECORDED_LENGTH_SUBPATH: &str = "segments/recording.json";
const RECORDED_LENGTH_TIMEOUT: Duration = Duration::from_secs(10);

fn recorded_length_json(manifest: &SegmentUploadManifest) -> Option<Vec<u8>> {
    let duration: f64 = manifest
        .video_segments
        .iter()
        .map(|segment| segment.duration)
        .sum();
    if manifest.video_segments.is_empty() || !duration.is_finite() || duration <= 0.0 {
        return None;
    }
    serde_json::to_vec(&json!({
        "version": 1,
        "duration": duration,
        "video_segments": manifest.video_segments.len(),
        "audio_segments": manifest.audio_segments.len(),
    }))
    .ok()
}

async fn publish_recorded_length(video_id: String, bytes: Vec<u8>, cancel: Arc<AtomicBool>) {
    match tokio::time::timeout(
        RECORDED_LENGTH_TIMEOUT,
        presigned_put_bytes_inner(&video_id, RECORDED_LENGTH_SUBPATH, bytes, Some(&cancel)),
    )
    .await
    {
        Ok(Ok(())) => {}
        Ok(Err(error)) => tracing::debug!(%error, "Recorded length upload failed"),
        Err(_) => tracing::debug!("Recorded length upload timed out"),
    }
}

async fn alongside<T>(main: impl Future<Output = T>, side: impl Future<Output = ()>) -> T {
    let main = std::pin::pin!(main);
    let side = std::pin::pin!(side);
    match futures_util::future::select(main, side).await {
        futures_util::future::Either::Left((output, _)) => output,
        futures_util::future::Either::Right(((), main)) => main.await,
    }
}

pub async fn prepare_instant_upload(
    camera_only: bool,
    project_name: String,
    organization_id: Option<String>,
) -> Result<VideoUploadInfo, String> {
    if store_auth_missing() {
        return Err("Please sign in to use instant recording".to_string());
    }

    let recording_mode = if camera_only {
        "desktopMP4"
    } else {
        "desktopSegments"
    };
    let config = create_or_get_video_with_mode(
        false,
        None,
        Some(project_name),
        None,
        organization_id,
        recording_mode,
    )
    .await
    .map_err(|error| match error {
        AuthApiError::InvalidAuthentication => {
            "Your session has expired. Please sign in again to use instant recording.".to_string()
        }
        AuthApiError::UpgradeRequired => "Instant recording requires an upgraded plan.".to_string(),
        error => format!("Could not create the shareable link: {error}"),
    })?;

    Ok(VideoUploadInfo {
        id: config.id.clone(),
        link: format!("{}/s/{}", auth::server_url(), config.id),
        config,
    })
}

pub(crate) fn start_instant_upload(
    video: VideoUploadInfo,
    project_path: PathBuf,
    segment_rx: Option<std::sync::mpsc::Receiver<SegmentCompletedEvent>>,
    metadata_lock: Arc<Mutex<()>>,
    authorization: Option<CompletionAuthorization>,
) -> Result<InstantUpload, String> {
    let ownership = cap_recording::upload_resume::UploadLock::acquire(&project_path)
        .map_err(|error| error.to_string())?;
    let state =
        queue::read_state(&project_path)?.ok_or("The recording has no saved upload identity")?;
    let request_context = state.request_context()?;
    start_instant_upload_with_ownership(
        video,
        project_path,
        segment_rx,
        metadata_lock,
        authorization,
        ownership,
        state.attempt_count(),
        Some(request_context),
    )
}

#[allow(clippy::too_many_arguments)]
fn start_instant_upload_with_ownership(
    video: VideoUploadInfo,
    project_path: PathBuf,
    segment_rx: Option<std::sync::mpsc::Receiver<SegmentCompletedEvent>>,
    metadata_lock: Arc<Mutex<()>>,
    authorization: Option<CompletionAuthorization>,
    ownership: cap_recording::upload_resume::UploadLock,
    prior_attempts: u32,
    request_context: Option<auth::UploadRequestContext>,
) -> Result<InstantUpload, String> {
    let (completion_permit, required, completion_control) = match authorization {
        Some(authorization) => (
            Some(authorization.permit),
            Some(authorization.required),
            Some(authorization.control),
        ),
        None => (None, None, None),
    };
    let cancel = completion_control.as_ref().map_or_else(
        || Arc::new(AtomicBool::new(false)),
        |control| control.cancel.clone(),
    );
    let reads = Arc::new(UploadReads::default());
    let mut bridge = None;
    let segment_upload = if let Some(segment_rx) = segment_rx {
        let (events_tx, events_rx) = flume::unbounded();
        let bridge_cancel = cancel.clone();
        bridge = Some(
            std::thread::Builder::new()
                .name("gpui-instant-segments".to_string())
                .stack_size(crate::MEDIA_THREAD_STACK_SIZE)
                .spawn(move || {
                    while !bridge_cancel.load(Ordering::Acquire) && !events_tx.is_disconnected() {
                        match segment_rx.recv_timeout(Duration::from_millis(20)) {
                            Ok(event) => {
                                if events_tx.send(event).is_err() {
                                    break;
                                }
                            }
                            Err(std::sync::mpsc::RecvTimeoutError::Timeout) => {}
                            Err(std::sync::mpsc::RecvTimeoutError::Disconnected) => break,
                        }
                    }
                })
                .map_err(|error| format!("Failed to start instant upload: {error}"))?,
        );

        let upload_video = video.clone();
        let upload_cancel = cancel.clone();
        let upload_metadata_lock = metadata_lock.clone();
        let context = request_context.clone();
        let upload_reads = reads.clone();
        Some(tokio::spawn(with_upload_context(
            context,
            upload_reads,
            async move {
                run_segment_upload(
                    upload_video,
                    project_path,
                    events_rx,
                    upload_cancel,
                    upload_metadata_lock,
                    required,
                )
                .await
            },
        )))
    } else {
        None
    };

    Ok(InstantUpload {
        video,
        segment_upload,
        cancel,
        metadata_lock,
        completion_permit,
        completion_control,
        bridge,
        ownership: Some(ownership),
        prior_attempts,
        request_context,
        reads,
    })
}

impl InstantUpload {
    pub fn video(&self) -> &VideoUploadInfo {
        &self.video
    }

    pub(crate) fn metadata_lock(&self) -> &Mutex<()> {
        &self.metadata_lock
    }

    #[cfg(test)]
    pub(crate) fn cancellation_token(&self) -> Arc<AtomicBool> {
        self.cancel.clone()
    }

    #[cfg(target_os = "linux")]
    pub(crate) fn completion_control(&self) -> Option<CompletionControl> {
        self.completion_control.clone()
    }

    pub(crate) fn authorize_completion(&mut self) -> Result<(), String> {
        if self.cancel.load(Ordering::Acquire) {
            return Err("Cancelled Instant recording cannot complete".into());
        }
        if let Some(permit) = self.completion_permit.take() {
            permit
                .send(())
                .map_err(|_| "Instant completion authorization was lost".to_string())?;
        }
        Ok(())
    }

    fn authorize_manifest(&mut self, expected: SegmentUploadManifest) -> Result<(), String> {
        let control = self
            .completion_control
            .as_ref()
            .ok_or("Upload has no completion guard")?;
        *control
            .expected_manifest
            .lock()
            .unwrap_or_else(|error| error.into_inner()) = Some(expected);
        self.authorize_completion()
    }

    pub async fn finish_segments(&mut self) -> Result<(), String> {
        check_segment_cancelled(&self.cancel)?;
        let Some(upload) = self.segment_upload.as_mut() else {
            return Ok(());
        };
        let result = upload
            .await
            .map_err(|error| format!("Instant segment upload task failed: {error}"));
        drop(self.segment_upload.take());
        self.join_bridge()?;
        check_segment_cancelled(&self.cancel)?;
        result?
    }

    fn join_bridge(&mut self) -> Result<(), String> {
        if let Some(bridge) = self.bridge.take() {
            bridge
                .join()
                .map_err(|_| "Instant upload event bridge failed".to_string())?;
        }
        Ok(())
    }

    fn screenshot_upload(
        &self,
        project_path: &Path,
    ) -> impl Future<Output = Result<(), String>> + Send + use<> {
        let video_id = self.video.id.clone();
        let path = project_path.join("screenshots/display.jpg");
        #[cfg(target_os = "linux")]
        let cancel = self.cancel.clone();
        async move {
            #[cfg(target_os = "linux")]
            let result = upload_screenshot_with_cancel(&video_id, &path, &cancel).await;
            #[cfg(not(target_os = "linux"))]
            let result = upload_screenshot(&video_id, &path).await;
            result.map_err(|error| format!("Instant recording thumbnail upload failed: {error}"))
        }
    }

    async fn finish_with_screenshot(
        &mut self,
        project_path: &Path,
        manifest: SegmentUploadManifest,
    ) -> Result<(), String> {
        let screenshot = self.screenshot_upload(project_path);
        self.authorize_manifest(manifest)?;
        let (screenshot, segments) = tokio::join!(screenshot, self.finish_segments());
        screenshot?;
        segments
    }

    pub async fn cancel(&mut self, query: Option<&str>) -> Result<(), String> {
        self.abort_segments().await;
        if let Some(ownership) = &self.ownership {
            queue::record_cancelled(ownership.project_path())?;
        }
        with_upload_context(
            self.request_context.clone(),
            self.reads.clone(),
            delete_instant_video_with_query(&self.video.id, query),
        )
        .await
    }

    pub(crate) async fn abort_segments(&mut self) {
        if let Some(control) = &self.completion_control {
            control.deny();
        }
        drop(self.completion_permit.take());
        self.cancel.store(true, Ordering::Release);
        if let Some(upload) = self.segment_upload.take() {
            upload.abort();
            let _ = upload.await;
        }
        if let Err(error) = self.join_bridge() {
            tracing::warn!(%error, "Instant upload bridge cleanup failed");
        }
        self.reads.join().await;
    }
}

pub(crate) async fn delete_instant_video_with_query(
    video_id: &str,
    query: Option<&str>,
) -> Result<(), String> {
    let mut path = format!(
        "/api/desktop/video/delete?videoId={}",
        urlencoding(video_id)
    );
    if let Some(query) = query {
        path.push('&');
        path.push_str(query);
    }
    let response = auth::authed_request(reqwest::Method::DELETE, &path, None)
        .await
        .map_err(|error| format!("Failed to delete instant recording: {error}"))?;
    let status = response.status();
    if status.is_success() || status == StatusCode::NOT_FOUND {
        return Ok(());
    }
    Err(format!(
        "Failed to delete instant recording {video_id}: {status}"
    ))
}

async fn run_segment_upload(
    video: VideoUploadInfo,
    project_path: PathBuf,
    events: flume::Receiver<SegmentCompletedEvent>,
    cancel: Arc<AtomicBool>,
    metadata_lock: Arc<Mutex<()>>,
    authorization: Option<CompletionRequirement>,
) -> Result<(), String> {
    let result = upload_segments(
        &LiveSegmentTransport::default(),
        &video.id,
        events,
        cancel.clone(),
        authorization,
    )
    .await;
    if let Err(error) = &result
        && !cancel.load(Ordering::Acquire)
        && let Err(save_error) =
            crate::recording::persist_instant_upload_failure(&project_path, error, &metadata_lock)
    {
        tracing::error!("Failed to persist instant upload failure: {save_error}");
    }
    result
}

#[derive(Debug)]
enum SegmentUploadError {
    Fatal(String),
    Retryable {
        event: SegmentCompletedEvent,
        error: String,
    },
}

impl From<String> for SegmentUploadError {
    fn from(error: String) -> Self {
        Self::Fatal(error)
    }
}

fn segment_error_is_retryable(error: &AuthApiError) -> bool {
    match error {
        AuthApiError::InvalidAuthentication | AuthApiError::UpgradeRequired => false,
        AuthApiError::Status(status, _) => {
            !status.is_client_error()
                || matches!(
                    *status,
                    StatusCode::REQUEST_TIMEOUT | StatusCode::TOO_MANY_REQUESTS
                )
        }
        AuthApiError::Timeout | AuthApiError::Other(_) => true,
    }
}

fn exhausted_segment_error(
    event: SegmentCompletedEvent,
    error: AuthApiError,
) -> SegmentUploadError {
    let message = format!(
        "Failed to upload instant segment {}: {error}",
        segment_subpath(&event)
    );
    if segment_error_is_retryable(&error) {
        SegmentUploadError::Retryable {
            event,
            error: message,
        }
    } else {
        SegmentUploadError::Fatal(message)
    }
}

fn segment_retry_backoff(round: u32) -> Duration {
    SEGMENT_RETRY_MIN_DELAY
        .saturating_mul(1 << round.min(8))
        .min(SEGMENT_RETRY_MAX_DELAY)
}

trait SegmentTransport: Send + Sync {
    fn prepare(
        &self,
        _video_id: &str,
        _segments: Vec<Segment>,
    ) -> impl Future<Output = Result<Option<Vec<Segment>>, String>> + Send {
        std::future::ready(Ok(None))
    }
    fn prefetch(
        &self,
        video_id: &str,
        start: u32,
        count: u32,
    ) -> impl Future<Output = Result<HashMap<String, String>, String>> + Send;
    fn segment(
        &self,
        video_id: String,
        event: SegmentCompletedEvent,
        signed_urls: Arc<Mutex<HashMap<String, String>>>,
        cancel: Arc<AtomicBool>,
    ) -> impl Future<Output = Result<SegmentCompletedEvent, SegmentUploadError>> + Send;
    fn manifest(
        &self,
        video_id: &str,
        manifest: &SegmentUploadManifest,
        cancel: &Arc<AtomicBool>,
    ) -> impl Future<Output = Result<(), String>> + Send;
    fn complete(
        &self,
        video_id: &str,
        cancel: &Arc<AtomicBool>,
    ) -> impl Future<Output = Result<(), String>> + Send;
}

struct ReusableUploadTarget {
    target: SignedUploadTarget,
    signed_at: tokio::time::Instant,
}

impl ReusableUploadTarget {
    fn new(target: SignedUploadTarget, signed_at: tokio::time::Instant) -> Option<Self> {
        (!is_google_drive_resumable_url(&target.url)).then_some(Self { target, signed_at })
    }

    fn is_fresh(&self) -> bool {
        self.signed_at.elapsed() < MANIFEST_URL_REUSE
    }
}

#[derive(Default)]
struct LiveSegmentTransport {
    manifest_target: Mutex<Option<ReusableUploadTarget>>,
}

impl LiveSegmentTransport {
    fn reusable_manifest_target(&self) -> Option<ReusableUploadTarget> {
        self.manifest_target
            .lock()
            .unwrap_or_else(|error| error.into_inner())
            .take()
            .filter(ReusableUploadTarget::is_fresh)
    }

    fn keep_manifest_target(&self, target: Option<ReusableUploadTarget>) {
        *self
            .manifest_target
            .lock()
            .unwrap_or_else(|error| error.into_inner()) = target;
    }
}

impl SegmentTransport for LiveSegmentTransport {
    async fn prepare(
        &self,
        video_id: &str,
        segments: Vec<Segment>,
    ) -> Result<Option<Vec<Segment>>, String> {
        tokio::time::timeout(Duration::from_secs(20), async {
            #[derive(Deserialize)]
            struct Response {
                version: u32,
                prepared: Vec<Segment>,
            }
            let response = auth::authed_request(
                reqwest::Method::POST,
                "/api/recording/prepare",
                Some(json!({ "videoId": video_id, "segments": segments })),
            )
            .await
            .map_err(|error| error.to_string())?;
            let status = response.status();
            if status == StatusCode::NOT_FOUND || status == StatusCode::METHOD_NOT_ALLOWED {
                return Ok(None);
            }
            if !status.is_success() {
                return Err(format!("Recording preparation returned {status}"));
            }
            let response = response
                .json::<Response>()
                .await
                .map_err(|error| error.to_string())?;
            Ok((response.version == 1 && response.prepared.len() <= 32)
                .then_some(response.prepared))
        })
        .await
        .map_err(|error| error.to_string())?
    }
    async fn prefetch(
        &self,
        video_id: &str,
        start: u32,
        count: u32,
    ) -> Result<HashMap<String, String>, String> {
        let signed_at = tokio::time::Instant::now();
        let mut urls = prefetch_segment_urls(video_id, start, count)
            .await
            .map_err(|error| error.to_string())?;
        if let Some(url) = urls.remove(MANIFEST_SUBPATH) {
            self.keep_manifest_target(ReusableUploadTarget::new(
                SignedUploadTarget {
                    url,
                    headers: HashMap::new(),
                },
                signed_at,
            ));
        }
        Ok(urls)
    }
    async fn segment(
        &self,
        video_id: String,
        event: SegmentCompletedEvent,
        signed_urls: Arc<Mutex<HashMap<String, String>>>,
        cancel: Arc<AtomicBool>,
    ) -> Result<SegmentCompletedEvent, SegmentUploadError> {
        upload_segment_with_retry(video_id, event, signed_urls, cancel).await
    }
    async fn manifest(
        &self,
        video_id: &str,
        manifest: &SegmentUploadManifest,
        cancel: &Arc<AtomicBool>,
    ) -> Result<(), String> {
        upload_segment_manifest_with_retry(self, video_id, manifest, cancel).await
    }
    async fn complete(&self, video_id: &str, cancel: &Arc<AtomicBool>) -> Result<(), String> {
        signal_recording_complete_with_retry(video_id, cancel).await
    }
}

async fn upload_segments(
    transport: &impl SegmentTransport,
    video_id: &str,
    events: flume::Receiver<SegmentCompletedEvent>,
    cancel: Arc<AtomicBool>,
    mut authorization: Option<CompletionRequirement>,
) -> Result<(), String> {
    let mut authorized = authorization.is_none();
    let mut manifest = SegmentUploadManifest::default();
    let mut uploads = FuturesUnordered::new();
    let mut events_closed = false;
    let mut last_manifest_upload: Option<tokio::time::Instant> = None;
    let mut preparation = Preparation::default();
    let mut preparation_enabled = true;
    let mut preparation_batch = Vec::new();
    let mut preparation_interval = tokio::time::interval(Duration::from_secs(30));
    preparation_interval.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Skip);
    let mut preparation_request = None;
    let mut next_preparation_request = tokio::time::Instant::now();
    let mut next_prefetch = SEGMENT_URL_PREFETCH + 1;
    let mut deferred = VecDeque::new();
    let mut first_failures: HashMap<String, (tokio::time::Instant, String)> = HashMap::new();
    let mut retry_round = 0u32;
    let mut retry_at = tokio::time::Instant::now();
    let prefetched = checked_segment_step(&cancel, || async {
        Ok(transport.prefetch(video_id, 1, SEGMENT_URL_PREFETCH).await)
    })
    .await?;
    let signed_urls = Arc::new(Mutex::new(prefetched.unwrap_or_else(|error| {
        tracing::warn!("Failed to prefetch instant upload URLs: {error}");
        HashMap::new()
    })));

    loop {
        if cancel.load(Ordering::Acquire) {
            return Err("Instant recording upload cancelled".into());
        }
        if events_closed && uploads.is_empty() && deferred.is_empty() && authorized {
            break;
        }
        let retry_deadline = first_failures
            .values()
            .map(|(first_failure, _)| *first_failure + SEGMENT_RETRY_WINDOW)
            .min();
        let guarded = authorization.is_some();
        let (permission, denial) = match authorization.as_mut() {
            Some(required) => (Some(&mut required.permission), Some(&mut required.denied)),
            None => (None, None),
        };
        tokio::select! {
            _ = preparation_interval.tick(), if preparation_enabled && preparation_request.is_none() => {
                if tokio::time::Instant::now() < next_preparation_request { continue; }
                preparation_batch = preparation.next_batch(manifest.video_segments.iter().map(|segment| segment.index), manifest.audio_segments.iter().map(|segment| segment.index));
                if !preparation_batch.is_empty() {
                    preparation_request = Some(Box::pin(transport.prepare(video_id, preparation_batch.clone())));
                }
            }
            response = async { preparation_request.as_mut().unwrap().await }, if preparation_request.is_some() => {
                preparation_request = None;
                match response {
                    Ok(Some(prepared)) => preparation.acknowledge(&preparation_batch, &prepared),
                    Ok(None) => preparation_enabled = false,
                    Err(error) => {
                        preparation.request_failed();
                        tracing::debug!(%error, "Optional recording preparation unavailable");
                    }
                }
                next_preparation_request = tokio::time::Instant::now() + preparation.retry_delay();
            }
            permission = async { permission.unwrap().await }, if !authorized => {
                permission.map_err(|_| "Instant completion was not authorized".to_string())?;
                authorized = true;
            }
            _ = async {
                let denial = denial.unwrap();
                let denied = *denial.borrow_and_update();
                if !denied { let _ = denial.changed().await; }
            }, if guarded => {
                return Err("Instant completion authorization was revoked".into());
            }
            next_event = events.recv_async(), if !events_closed && uploads.len() < MAX_SEGMENT_UPLOADS => {
                match next_event {
                    Ok(event) => {
                        if cancel.load(Ordering::Acquire) {
                            return Err("Instant recording upload cancelled".to_string());
                        }
                        if event.media_type == SegmentMediaType::Video
                            && event.index.saturating_add(5) >= next_prefetch
                        {
                            match checked_segment_step(&cancel, || async {
                                Ok(transport.prefetch(video_id, next_prefetch, SEGMENT_URL_PREFETCH).await)
                            }).await? {
                                Ok(urls) => {
                                    signed_urls.lock().unwrap_or_else(|error| error.into_inner()).extend(urls);
                                    next_prefetch = next_prefetch.saturating_add(SEGMENT_URL_PREFETCH);
                                }
                                Err(error) => tracing::warn!("Failed to extend instant upload URLs: {error}"),
                            }
                        }
                        uploads.push(transport.segment(
                            video_id.to_string(),
                            event,
                            signed_urls.clone(),
                            cancel.clone(),
                        ));
                    }
                    Err(_) => events_closed = true,
                }
            }
            _ = async { tokio::time::sleep_until(retry_deadline.unwrap()).await }, if retry_deadline.is_some() => {
                let error = first_failures
                    .values()
                    .min_by_key(|(first_failure, _)| *first_failure)
                    .map(|(_, error)| error.clone())
                    .unwrap_or_default();
                return Err(error);
            }
            _ = tokio::time::sleep_until(retry_at), if !deferred.is_empty() && uploads.len() < MAX_SEGMENT_UPLOADS => {
                while uploads.len() < MAX_SEGMENT_UPLOADS {
                    let Some(event) = deferred.pop_front() else { break };
                    uploads.push(transport.segment(
                        video_id.to_string(),
                        event,
                        signed_urls.clone(),
                        cancel.clone(),
                    ));
                }
            }
            Some(upload) = uploads.next(), if !uploads.is_empty() => {
                check_segment_cancelled(&cancel)?;
                let event = match upload {
                    Ok(event) => event,
                    Err(SegmentUploadError::Fatal(error)) => return Err(error),
                    Err(SegmentUploadError::Retryable { event, error }) => {
                        let now = tokio::time::Instant::now();
                        let (first_failure, last_error) = first_failures
                            .entry(segment_subpath(&event))
                            .or_insert_with(|| (now, String::new()));
                        if now.duration_since(*first_failure) >= SEGMENT_RETRY_WINDOW {
                            return Err(error);
                        }
                        last_error.clone_from(&error);
                        if retry_at <= now {
                            retry_at = now + segment_retry_backoff(retry_round);
                            retry_round = retry_round.saturating_add(1);
                        }
                        tracing::warn!(deferred = deferred.len() + 1, "Instant segment upload deferred for retry: {error}");
                        deferred.push_back(event);
                        continue;
                    }
                };
                if !first_failures.is_empty() {
                    first_failures.remove(&segment_subpath(&event));
                    retry_round = 0;
                    retry_at = tokio::time::Instant::now();
                }
                manifest.record(&event);
                if manifest.has_video_content()
                    && last_manifest_upload.is_none_or(|last| last.elapsed() >= MANIFEST_UPLOAD_INTERVAL)
                {
                    check_segment_cancelled(&cancel)?;
                    let uploaded = transport.manifest(video_id, &manifest, &cancel).await;
                    check_segment_cancelled(&cancel)?;
                    if let Err(error) = uploaded {
                        tracing::warn!("Instant progress manifest upload failed; retrying at the next interval: {error}");
                    }
                    last_manifest_upload = Some(tokio::time::Instant::now());
                }
            }
            else => break,
        }
    }

    drop(preparation_request);
    if cancel.load(Ordering::Acquire) {
        return Err("Instant recording upload cancelled".to_string());
    }
    if !manifest.has_video_content() {
        return Err(format!(
            "Segment upload completed without video segments for {video_id}"
        ));
    }

    manifest.is_complete = true;
    let expected = authorization.as_ref().and_then(|required| {
        required
            .expected_manifest
            .lock()
            .unwrap_or_else(|error| error.into_inner())
            .clone()
    });
    if expected
        .as_ref()
        .is_some_and(|expected| expected != &manifest)
    {
        return Err("Uploaded segments do not match the complete local recording".into());
    }
    checked_segment_step(&cancel, || transport.manifest(video_id, &manifest, &cancel)).await?;
    if expected.is_some() {
        return Ok(());
    }
    checked_segment_step(&cancel, || transport.complete(video_id, &cancel)).await
}

fn check_segment_cancelled(cancel: &AtomicBool) -> Result<(), String> {
    if cancel.load(Ordering::Acquire) {
        Err("Instant recording upload cancelled".into())
    } else {
        Ok(())
    }
}

async fn checked_segment_step<T, F>(
    cancel: &AtomicBool,
    step: impl FnOnce() -> F,
) -> Result<T, String>
where
    F: Future<Output = Result<T, String>>,
{
    check_segment_cancelled(cancel)?;
    let result = step().await;
    check_segment_cancelled(cancel)?;
    result
}

async fn segment_retry_delay(cancel: &AtomicBool, delay: Duration) -> Result<(), String> {
    checked_segment_step(cancel, || async {
        tokio::time::sleep(delay).await;
        Ok(())
    })
    .await
}

fn prefetched_segment_paths(start: u32, count: u32) -> Vec<String> {
    let mut subpaths = Vec::with_capacity((count as usize).saturating_mul(2).saturating_add(3));
    if start == 1 {
        subpaths.push("segments/video/init.mp4".to_string());
        subpaths.push("segments/audio/init.mp4".to_string());
        subpaths.push(MANIFEST_SUBPATH.to_string());
    }
    for index in start..start.saturating_add(count) {
        subpaths.push(format!("segments/video/segment_{index:03}.m4s"));
        subpaths.push(format!("segments/audio/segment_{index:03}.m4s"));
    }
    subpaths
}

async fn prefetch_segment_urls(
    video_id: &str,
    start: u32,
    count: u32,
) -> Result<HashMap<String, String>, AuthApiError> {
    #[derive(Deserialize)]
    struct BatchResponse {
        urls: HashMap<String, String>,
    }

    let response = auth::authed_request(
        reqwest::Method::POST,
        "/api/upload/signed/batch",
        Some(json!({
            "videoId": video_id,
            "subpaths": prefetched_segment_paths(start, count),
        })),
    )
    .await?;
    let status = response.status();
    if !status.is_success() {
        return Err(AuthApiError::Other(format!(
            "api/upload_signed_batch/{status}"
        )));
    }
    response
        .json::<BatchResponse>()
        .await
        .map(|batch| batch.urls)
        .map_err(|error| AuthApiError::Other(format!("api/upload_signed_batch/response: {error}")))
}

async fn upload_segment_with_retry(
    video_id: String,
    event: SegmentCompletedEvent,
    signed_urls: Arc<Mutex<HashMap<String, String>>>,
    cancel: Arc<AtomicBool>,
) -> Result<SegmentCompletedEvent, SegmentUploadError> {
    let subpath = segment_subpath(&event);
    let bytes = read_completed_segment(&event, &subpath, &cancel).await?;
    let mut cached_url = signed_urls
        .lock()
        .unwrap_or_else(|error| error.into_inner())
        .remove(&subpath);

    for attempt in 0..SEGMENT_UPLOAD_ATTEMPTS {
        if cancel.load(Ordering::Acquire) {
            return Err("Instant recording upload cancelled".to_string().into());
        }
        if attempt > 0 {
            segment_retry_delay(&cancel, Duration::from_millis(250u64 << attempt)).await?;
        }

        let result = if let Some(url) = cached_url.take() {
            upload_signed_bytes_inner(
                SignedUploadTarget {
                    url,
                    headers: HashMap::new(),
                },
                &subpath,
                bytes.clone(),
                Some(&cancel),
            )
            .await
        } else {
            presigned_put_bytes_inner(&video_id, &subpath, bytes.clone(), Some(&cancel)).await
        };

        check_segment_cancelled(&cancel)?;

        match result {
            Ok(()) => return Ok(event),
            Err(AuthApiError::InvalidAuthentication) => {
                return Err(SegmentUploadError::Fatal(
                    "Authentication expired while uploading the instant recording".into(),
                ));
            }
            Err(error) if attempt + 1 == SEGMENT_UPLOAD_ATTEMPTS => {
                return Err(exhausted_segment_error(event, error));
            }
            Err(error) => tracing::warn!(
                subpath,
                attempt = attempt + 1,
                "Instant recording segment upload failed; retrying: {error}"
            ),
        }
    }

    Err(SegmentUploadError::Fatal(format!(
        "Failed to upload instant segment {subpath}"
    )))
}

async fn read_completed_segment(
    event: &SegmentCompletedEvent,
    subpath: &str,
    cancel: &AtomicBool,
) -> Result<Vec<u8>, String> {
    if event.file_size == 0 {
        return Err(format!(
            "Instant recording segment has no completed byte count: {subpath}"
        ));
    }
    let started = Instant::now();
    loop {
        if cancel.load(Ordering::Acquire) {
            return Err("Instant recording upload cancelled".to_string());
        }
        let bytes = tracked_upload_read({
            let path = event.path.clone();
            move || std::fs::read(path)
        })
        .await
        .map_err(|error| format!("Failed to read instant segment {subpath}: {error}"))?;

        match bytes {
            Ok(bytes) if !bytes.is_empty() && bytes.len() as u64 == event.file_size => {
                return Ok(bytes);
            }
            Ok(_) if started.elapsed() >= Duration::from_secs(10) => {
                return Err(format!(
                    "Instant recording segment is incomplete: {subpath}"
                ));
            }
            Err(error) if started.elapsed() >= Duration::from_secs(10) => {
                return Err(format!("Failed to read instant segment {subpath}: {error}"));
            }
            _ => tokio::time::sleep(Duration::from_millis(50)).await,
        }
    }
}

fn segment_subpath(event: &SegmentCompletedEvent) -> String {
    match (event.is_init, event.media_type) {
        (true, SegmentMediaType::Video) => "segments/video/init.mp4".to_string(),
        (true, SegmentMediaType::Audio) => "segments/audio/init.mp4".to_string(),
        (false, SegmentMediaType::Video) => {
            format!("segments/video/segment_{:03}.m4s", event.index)
        }
        (false, SegmentMediaType::Audio) => {
            format!("segments/audio/segment_{:03}.m4s", event.index)
        }
    }
}

async fn upload_segment_manifest(
    transport: &LiveSegmentTransport,
    video_id: &str,
    manifest: &SegmentUploadManifest,
    cancel: &AtomicBool,
) -> Result<(), String> {
    let bytes = serde_json::to_vec(manifest)
        .map_err(|error| format!("Failed to serialize instant upload manifest: {error}"))?;
    if let Some(reusable) = transport.reusable_manifest_target() {
        match upload_signed_bytes_inner(
            reusable.target.clone(),
            MANIFEST_SUBPATH,
            bytes.clone(),
            Some(cancel),
        )
        .await
        {
            Ok(()) => {
                transport.keep_manifest_target(Some(reusable));
                return Ok(());
            }
            Err(error @ AuthApiError::Status(..)) => {
                check_segment_cancelled(cancel)?;
                tracing::debug!(
                    "Reused instant manifest URL was rejected; signing a new one: {error}"
                );
            }
            Err(error) => {
                return Err(format!(
                    "Failed to upload instant recording manifest: {error}"
                ));
            }
        }
    }
    let signed_at = tokio::time::Instant::now();
    let target = presign_put_target(video_id, MANIFEST_SUBPATH, Some(cancel))
        .await
        .map_err(|error| format!("Failed to upload instant recording manifest: {error}"))?;
    let reusable = ReusableUploadTarget::new(target.clone(), signed_at);
    upload_signed_bytes_inner(target, MANIFEST_SUBPATH, bytes, Some(cancel))
        .await
        .map_err(|error| format!("Failed to upload instant recording manifest: {error}"))?;
    transport.keep_manifest_target(reusable);
    Ok(())
}

async fn upload_segment_manifest_with_retry(
    transport: &LiveSegmentTransport,
    video_id: &str,
    manifest: &SegmentUploadManifest,
    cancel: &AtomicBool,
) -> Result<(), String> {
    for attempt in 0..SEGMENT_UPLOAD_ATTEMPTS {
        if cancel.load(Ordering::Acquire) {
            return Err("Instant recording upload cancelled".to_string());
        }
        match checked_segment_step(cancel, || {
            upload_segment_manifest(transport, video_id, manifest, cancel)
        })
        .await
        {
            Ok(()) => return Ok(()),
            Err(error) if attempt + 1 == SEGMENT_UPLOAD_ATTEMPTS => return Err(error),
            Err(error) => {
                tracing::warn!(
                    attempt = attempt + 1,
                    "Instant manifest upload failed: {error}"
                );
                segment_retry_delay(cancel, Duration::from_millis(250u64 << attempt)).await?;
            }
        }
    }
    Err("Instant recording manifest upload failed".to_string())
}

async fn signal_recording_complete_with_retry(
    video_id: &str,
    cancel: &AtomicBool,
) -> Result<(), String> {
    for attempt in 0..SEGMENT_UPLOAD_ATTEMPTS {
        if cancel.load(Ordering::Acquire) {
            return Err("Instant recording upload cancelled".to_string());
        }
        match checked_segment_step(cancel, || signal_recording_complete(video_id)).await {
            Ok(()) => return Ok(()),
            Err(error) if attempt + 1 == SEGMENT_UPLOAD_ATTEMPTS => return Err(error),
            Err(error) => {
                tracing::warn!(
                    attempt = attempt + 1,
                    "Instant completion signal failed: {error}"
                );
                segment_retry_delay(cancel, Duration::from_millis(250u64 << attempt)).await?;
            }
        }
    }
    Err("Failed to finish instant recording upload".to_string())
}

async fn signal_recording_complete(video_id: &str) -> Result<(), String> {
    let response = auth::authed_request(
        reqwest::Method::POST,
        "/api/upload/recording-complete",
        Some(json!({ "videoId": video_id })),
    )
    .await
    .map_err(|error| format!("Failed to finish instant recording upload: {error}"))?;
    let status = response.status();
    if status.is_success() {
        return Ok(());
    }
    Err(format!(
        "Failed to finish instant recording upload: {status}"
    ))
}

#[derive(Debug, Clone, Serialize)]
#[serde(rename_all = "camelCase")]
struct UploadedPart {
    part_number: u32,
    etag: String,
    size: usize,
    #[serde(skip)]
    object_identity: Option<String>,
}

#[derive(Debug, Clone, Serialize)]
#[serde(rename_all = "camelCase")]
struct VideoMeta {
    #[serde(rename = "durationInSecs")]
    duration_in_secs: f64,
    width: u32,
    height: u32,
    #[serde(skip_serializing_if = "Option::is_none")]
    fps: Option<f32>,
}

fn check_export_cancelled(cancel: &AtomicBool) -> Result<(), AuthApiError> {
    if cancel.load(Ordering::Acquire) {
        Err(AuthApiError::Other("Export cancelled".into()))
    } else {
        Ok(())
    }
}

async fn checked_upload_step<T, F>(
    cancel: &AtomicBool,
    step: impl FnOnce() -> F,
) -> Result<T, AuthApiError>
where
    F: Future<Output = Result<T, AuthApiError>>,
{
    check_export_cancelled(cancel)?;
    let result = step().await;
    check_export_cancelled(cancel)?;
    result
}

pub async fn upload_exported_video(
    project_path: PathBuf,
    organization_id: Option<String>,
    progress: impl Fn(f64),
    cancel: std::sync::Arc<AtomicBool>,
) -> Result<UploadResult, String> {
    upload_exported_video_inner(project_path, organization_id, progress, cancel, false)
        .await
        .map(|(result, _)| result)
}

async fn upload_exported_video_inner(
    project_path: PathBuf,
    organization_id: Option<String>,
    progress: impl Fn(f64),
    cancel: Arc<AtomicBool>,
    defer_completion: bool,
) -> Result<(UploadResult, Option<String>), String> {
    check_export_cancelled(&cancel).map_err(|error| error.to_string())?;
    if store_auth_missing() {
        let _ = crate::store::set_auth(None);
        return Ok((UploadResult::NotAuthenticated, None));
    }

    let mut meta = RecordingMeta::load_for_project(&project_path)
        .map_err(|error| format!("Failed to load recording metadata: {error}"))?;
    let file_path = meta.output_path();
    if !file_path.exists() {
        if !defer_completion {
            crate::app_sounds::play_notification();
        }
        return Err("Failed to upload video: Rendered video not found".into());
    }

    let metadata = build_video_meta(&file_path)?;
    if !crate::store::auth_snapshot().is_upgraded() && metadata.duration_in_secs > 300.0 {
        return Ok((UploadResult::UpgradeRequired, None));
    }

    progress(0.0);
    if cancel.load(Ordering::Relaxed) {
        return Err("Export cancelled".into());
    }

    // The recording-time thumbnail is best-effort, so regenerate a missing
    // `screenshots/display.jpg` from the exported video rather than shipping a
    // share with no thumbnail or failing a video that could still be shared.
    let screenshot_path = meta.project_path.join("screenshots/display.jpg");
    if !screenshot_path.exists()
        && let Err(error) = crate::library::create_screenshot(&file_path, &screenshot_path, None)
    {
        return Err(format!("Failed to generate thumbnail: {error}"));
    }

    let video_id = match reusable_video_id(meta.sharing.as_ref(), meta.upload.as_ref()) {
        Some(video_id) => video_id,
        None => {
            let video_id = match checked_upload_step(&cancel, request_video_id).await {
                Ok(video_id) => video_id,
                Err(AuthApiError::InvalidAuthentication) => {
                    return Ok((UploadResult::NotAuthenticated, None));
                }
                Err(AuthApiError::UpgradeRequired) => {
                    return Ok((UploadResult::UpgradeRequired, None));
                }
                Err(error) => return Err(error.to_string()),
            };
            meta.upload = Some(UploadMeta::SinglePartUpload {
                video_id: video_id.clone(),
                file_path: file_path.clone(),
                screenshot_path: screenshot_path.clone(),
                recording_dir: project_path.clone(),
            });
            meta.save_for_project()
                .map_err(|error| format!("Failed to persist upload identity: {error}"))?;
            video_id
        }
    };

    let s3_config = match checked_upload_step(&cancel, || {
        create_or_get_video(
            false,
            Some(video_id.clone()),
            Some(meta.pretty_name.clone()),
            Some(&metadata),
            organization_id,
        )
    })
    .await
    {
        Ok(config) => config,
        Err(AuthApiError::InvalidAuthentication) => {
            return Ok((UploadResult::NotAuthenticated, None));
        }
        Err(AuthApiError::UpgradeRequired) => return Ok((UploadResult::UpgradeRequired, None)),
        Err(error) => return Err(error.to_string()),
    };
    if s3_config.id != video_id {
        return Err("Server did not preserve the reserved upload identity".into());
    }

    meta.upload = Some(UploadMeta::SinglePartUpload {
        video_id: s3_config.id.clone(),
        file_path: file_path.clone(),
        screenshot_path: screenshot_path.clone(),
        recording_dir: project_path.clone(),
    });
    meta.save_for_project()
        .map_err(|error| format!("Failed to persist upload state: {error}"))?;

    match checked_upload_step(&cancel, || {
        upload_video(
            &s3_config.id,
            &file_path,
            &metadata,
            progress,
            &cancel,
            meta.sharing.is_some(),
        )
    })
    .await
    {
        Ok((link, object_identity)) => {
            let link = meta
                .sharing
                .as_ref()
                .map(|sharing| sharing.link.clone())
                .unwrap_or(link);
            meta.sharing = Some(SharingMeta {
                link: link.clone(),
                id: s3_config.id.clone(),
                content_hash: None,
            });
            meta.save_for_project()
                .map_err(|error| format!("Failed to persist sharing state: {error}"))?;

            if let Err(error) = checked_upload_step(&cancel, || {
                upload_screenshot_with_cancel(&s3_config.id, &screenshot_path, &cancel)
            })
            .await
            {
                return Err(format!("thumbnail upload failed: {error}"));
            }

            check_export_cancelled(&cancel).map_err(|error| error.to_string())?;
            if !defer_completion {
                meta.upload = Some(UploadMeta::Complete);
                meta.save_for_project()
                    .map_err(|error| format!("Failed to persist completed upload: {error}"))?;
            }
            check_export_cancelled(&cancel).map_err(|error| error.to_string())?;
            Ok((UploadResult::Success(link), object_identity))
        }
        Err(AuthApiError::UpgradeRequired) => Ok((UploadResult::UpgradeRequired, None)),
        Err(AuthApiError::InvalidAuthentication) => Ok((UploadResult::NotAuthenticated, None)),
        Err(error) => {
            if !defer_completion && !cancel.load(Ordering::Relaxed) {
                crate::app_sounds::play_notification();
            }
            Err(error.to_string())
        }
    }
}

fn reusable_video_id(sharing: Option<&SharingMeta>, upload: Option<&UploadMeta>) -> Option<String> {
    sharing
        .map(|sharing| sharing.id.clone())
        .or_else(|| match upload {
            Some(UploadMeta::SinglePartUpload { video_id, .. })
            | Some(UploadMeta::SegmentUpload { video_id, .. })
            | Some(UploadMeta::MultipartUpload { video_id, .. }) => Some(video_id.clone()),
            _ => None,
        })
}

fn store_auth_missing() -> bool {
    !crate::store::auth_snapshot().signed_in()
}

async fn request_video_id() -> Result<String, AuthApiError> {
    let response =
        auth::authed_request(reqwest::Method::GET, "/api/desktop/video/new-id", None).await?;
    if response.status() != StatusCode::OK {
        let status = response.status();
        return Err(AuthApiError::Other(format!(
            "request_video_id/error/{status}"
        )));
    }
    let text = response
        .text()
        .await
        .map_err(|error| AuthApiError::Other(format!("Failed to read response body: {error}")))?;
    let config = serde_json::from_str::<S3UploadMeta>(&text)
        .map_err(|_| AuthApiError::Other("Invalid reserved video ID response".into()))?;
    Ok(config.id)
}

/// `create_or_get_video` (`src-tauri/upload.rs:340-436`): passing an existing
/// `video_id` re-uses that server record (which is what keeps a share link
/// stable across re-uploads), and `is_screenshot` marks the record the way the
/// screenshot share flow needs (`isScreenshot=true` on the create URL).
async fn create_or_get_video(
    is_screenshot: bool,
    video_id: Option<String>,
    name: Option<String>,
    meta: Option<&VideoMeta>,
    organization_id: Option<String>,
) -> Result<S3UploadMeta, AuthApiError> {
    create_or_get_video_with_mode(
        is_screenshot,
        video_id,
        name,
        meta,
        organization_id,
        "desktopMP4",
    )
    .await
}

async fn create_or_get_video_with_mode(
    is_screenshot: bool,
    video_id: Option<String>,
    name: Option<String>,
    meta: Option<&VideoMeta>,
    organization_id: Option<String>,
    recording_mode: &str,
) -> Result<S3UploadMeta, AuthApiError> {
    let mut path = format!(
        "/api/desktop/video/create?recordingMode={}",
        urlencoding(recording_mode)
    );
    if let Some(id) = video_id {
        path.push_str(&format!("&videoId={id}"));
        path.push_str("&createWithId=true");
    }
    if is_screenshot {
        path.push_str("&isScreenshot=true");
    }
    if let Some(name) = name {
        path.push_str(&format!("&name={}", urlencoding(&name)));
    }
    if let Some(meta) = meta {
        path.push_str(&format!("&durationInSecs={}", meta.duration_in_secs));
        path.push_str(&format!("&width={}", meta.width));
        path.push_str(&format!("&height={}", meta.height));
        if let Some(fps) = meta.fps {
            path.push_str(&format!("&fps={fps}"));
        }
    }
    if let Some(org_id) = organization_id {
        path.push_str(&format!("&orgId={org_id}"));
    }

    let response = auth::authed_request(reqwest::Method::GET, &path, None).await?;
    if response.status() != StatusCode::OK {
        let status = response.status();
        let body = response.text().await.unwrap_or_default();
        if status == StatusCode::FORBIDDEN && body.contains("upgrade_required") {
            return Err(AuthApiError::UpgradeRequired);
        }
        return Err(AuthApiError::Other(format!(
            "create_or_get_video/error/{status}"
        )));
    }
    let text = response
        .text()
        .await
        .map_err(|error| AuthApiError::Other(format!("Failed to read response body: {error}")))?;
    serde_json::from_str::<S3UploadMeta>(&text)
        .map_err(|_| AuthApiError::Other("Invalid video creation response".into()))
}

#[derive(Debug)]
enum ReplacementUploadAttempt<T, S = ()> {
    Completed(T),
    RestartRequired(S),
}

async fn retry_replacement_upload<T, S, F, Fut>(
    replace_existing: bool,
    cancel: &AtomicBool,
    mut state: S,
    mut attempt: F,
) -> Result<T, AuthApiError>
where
    F: FnMut(S) -> Fut,
    Fut: Future<Output = Result<ReplacementUploadAttempt<T, S>, AuthApiError>>,
{
    for attempt_index in 0..2 {
        match checked_upload_step(cancel, || attempt(state)).await? {
            ReplacementUploadAttempt::Completed(value) => return Ok(value),
            ReplacementUploadAttempt::RestartRequired(next)
                if replace_existing && attempt_index == 0 =>
            {
                // Aborting a legacy Drive session can delete the published mapping.
                state = next;
            }
            ReplacementUploadAttempt::RestartRequired(_) => break,
        }
    }
    Err(replacement_restart_error())
}

fn replacement_restart_error() -> AuthApiError {
    AuthApiError::Other("api/upload_multipart_complete/409/REPLACEMENT_RESTART_REQUIRED".into())
}

fn is_legacy_replacement_upload(replace_existing: bool, upload_id: &str) -> bool {
    replace_existing && !upload_id.starts_with("cap-reupload.")
}

fn validate_replacement_restart_session(
    restarted: bool,
    upload_id: &str,
) -> Result<(), AuthApiError> {
    if restarted && !upload_id.starts_with("cap-reupload.") {
        return Err(replacement_restart_error());
    }
    Ok(())
}

#[derive(Debug, PartialEq, Eq)]
struct ReplacementUploadFile {
    path: PathBuf,
    size: u64,
    modified: std::time::SystemTime,
}

impl ReplacementUploadFile {
    fn read(path: &Path) -> Result<Self, AuthApiError> {
        let metadata = std::fs::symlink_metadata(path).map_err(|error| {
            AuthApiError::Other(format!("Failed to inspect replacement export: {error}"))
        })?;
        if !metadata.file_type().is_file() || metadata.len() == 0 {
            return Err(replacement_source_changed());
        }
        Ok(Self {
            path: path.canonicalize().map_err(|error| {
                AuthApiError::Other(format!("Failed to resolve replacement export: {error}"))
            })?,
            size: metadata.len(),
            modified: metadata.modified().map_err(|error| {
                AuthApiError::Other(format!(
                    "Failed to inspect replacement export time: {error}"
                ))
            })?,
        })
    }
}

#[derive(Debug, PartialEq, Eq)]
struct ReplacementUploadChunk {
    offset: u64,
    size: usize,
    md5: String,
}

#[derive(Debug)]
struct ReplacementUploadSource {
    file: ReplacementUploadFile,
    chunks: Vec<ReplacementUploadChunk>,
    sealed: bool,
}

fn replacement_source_changed() -> AuthApiError {
    AuthApiError::Other("Rendered video changed during replacement upload".into())
}

impl ReplacementUploadSource {
    fn new(path: &Path) -> Result<Self, AuthApiError> {
        Ok(Self {
            file: ReplacementUploadFile::read(path)?,
            chunks: Vec::new(),
            sealed: false,
        })
    }

    fn validate_file(&self, path: &Path) -> Result<(), AuthApiError> {
        if ReplacementUploadFile::read(path)? != self.file {
            return Err(replacement_source_changed());
        }
        Ok(())
    }

    fn check_chunk(
        &mut self,
        part_number: u32,
        offset: u64,
        bytes: &[u8],
        file_size: u64,
    ) -> Result<(), AuthApiError> {
        let index = usize::try_from(part_number)
            .ok()
            .and_then(|part| part.checked_sub(1))
            .ok_or_else(replacement_source_changed)?;
        if file_size != self.file.size || bytes.is_empty() {
            return Err(replacement_source_changed());
        }
        let chunk = ReplacementUploadChunk {
            offset,
            size: bytes.len(),
            md5: md5_base64(bytes),
        };
        if self.sealed {
            if self.chunks.get(index) != Some(&chunk) {
                return Err(replacement_source_changed());
            }
        } else {
            let expected_offset = self
                .chunks
                .last()
                .map(|previous| previous.offset.saturating_add(previous.size as u64))
                .unwrap_or(0);
            if index != self.chunks.len() || offset != expected_offset {
                return Err(replacement_source_changed());
            }
            self.chunks.push(chunk);
        }
        Ok(())
    }

    fn seal_parts(&mut self, parts: &[UploadedPart]) -> Result<(), AuthApiError> {
        if parts.len() != self.chunks.len() || parts.is_empty() {
            return Err(replacement_source_changed());
        }
        let mut size = 0u64;
        for (index, (part, chunk)) in parts.iter().zip(&self.chunks).enumerate() {
            if usize::try_from(part.part_number).ok() != Some(index + 1)
                || part.size != chunk.size
                || chunk.offset != size
            {
                return Err(replacement_source_changed());
            }
            size = size
                .checked_add(chunk.size as u64)
                .ok_or_else(replacement_source_changed)?;
        }
        if size != self.file.size {
            return Err(replacement_source_changed());
        }
        self.sealed = true;
        Ok(())
    }
}

async fn upload_video(
    video_id: &str,
    file_path: &Path,
    metadata: &VideoMeta,
    progress: impl Fn(f64),
    cancel: &AtomicBool,
    replace_existing: bool,
) -> Result<(String, Option<String>), AuthApiError> {
    let progress = &progress;
    let result = retry_replacement_upload(
        replace_existing,
        cancel,
        None,
        |mut source: Option<ReplacementUploadSource>| async move {
            if let Some(source) = &source {
                source.validate_file(file_path)?;
            }
            let initiate =
                checked_upload_step(cancel, || multipart_initiate(video_id, replace_existing))
                    .await?;
            validate_replacement_restart_session(source.is_some(), &initiate.upload_id)?;
            if source.is_none()
                && is_legacy_replacement_upload(replace_existing, &initiate.upload_id)
            {
                source = Some(ReplacementUploadSource::new(file_path)?);
            }
            let is_drive =
                is_google_drive_upload(initiate.provider.as_deref(), &initiate.upload_id);
            let parts = upload_parts(
                video_id,
                &initiate.upload_id,
                file_path,
                is_drive,
                progress,
                cancel,
                source.as_mut(),
            )
            .await?;
            check_export_cancelled(cancel)?;
            if let Some(source) = &mut source {
                source.validate_file(file_path)?;
                source.seal_parts(&parts)?;
            }
            let completed_identity = checked_upload_step(cancel, || {
                multipart_complete(
                    video_id,
                    &initiate.upload_id,
                    &parts,
                    Some(metadata),
                    replace_existing,
                )
            })
            .await?;
            let completed_identity = match completed_identity {
                ReplacementUploadAttempt::Completed(identity) => identity,
                ReplacementUploadAttempt::RestartRequired(()) => {
                    if source.is_none() {
                        return Err(replacement_restart_error());
                    }
                    return Ok(ReplacementUploadAttempt::RestartRequired(source));
                }
            };
            let object_identity = if is_drive {
                parts
                    .iter()
                    .rev()
                    .find_map(|part| part.object_identity.clone())
            } else {
                completed_identity
            };
            Ok(ReplacementUploadAttempt::Completed((
                format!("{}/s/{video_id}", auth::server_url()),
                object_identity,
            )))
        },
    )
    .await?;
    progress(1.0);
    Ok(result)
}

#[derive(Debug, Deserialize)]
#[serde(rename_all = "camelCase")]
struct InitiateResponse {
    upload_id: String,
    provider: Option<String>,
}

async fn multipart_initiate(
    video_id: &str,
    replace_existing: bool,
) -> Result<InitiateResponse, AuthApiError> {
    let response = auth::authed_request(
        reqwest::Method::POST,
        "/api/upload/multipart/initiate",
        Some(json!({
            "videoId": video_id,
            "contentType": "video/mp4",
            "replaceExisting": replace_existing
        })),
    )
    .await
    .map_err(|error| {
        AuthApiError::Other(format!("api/upload_multipart_initiate/request: {error}"))
    })?;
    if !response.status().is_success() {
        let status = response.status().as_u16();
        return Err(AuthApiError::Other(format!(
            "api/upload_multipart_initiate/{status}"
        )));
    }
    response.json().await.map_err(|error| {
        AuthApiError::Other(format!("api/upload_multipart_initiate/response: {error}"))
    })
}

async fn multipart_presign(
    client: &reqwest::Client,
    video_id: &str,
    upload_id: &str,
    part_number: u32,
    md5_sum: Option<&str>,
) -> Result<String, AuthApiError> {
    #[derive(Deserialize)]
    #[serde(rename_all = "camelCase")]
    struct Response {
        presigned_url: String,
    }

    let mut body = serde_json::Map::from_iter([
        ("videoId".into(), json!(video_id)),
        ("uploadId".into(), json!(upload_id)),
        ("partNumber".into(), json!(part_number)),
    ]);
    if let Some(md5_sum) = md5_sum {
        body.insert("md5Sum".into(), json!(md5_sum));
    }

    let response = auth::authed_request_with(
        client,
        reqwest::Method::POST,
        "/api/upload/multipart/presign-part",
        Some(Value::Object(body)),
    )
    .await
    .map_err(|error| {
        AuthApiError::Other(format!(
            "api/upload_multipart_presign_part/request: {error}"
        ))
    })?;
    if !response.status().is_success() {
        let status = response.status().as_u16();
        return Err(AuthApiError::Other(format!(
            "api/upload_multipart_presign_part/{status}"
        )));
    }
    response
        .json::<Response>()
        .await
        .map(|data| data.presigned_url)
        .map_err(|error| {
            AuthApiError::Other(format!(
                "api/upload_multipart_presign_part/response: {error}"
            ))
        })
}

async fn multipart_complete(
    video_id: &str,
    upload_id: &str,
    parts: &[UploadedPart],
    meta: Option<&VideoMeta>,
    replace_existing: bool,
) -> Result<ReplacementUploadAttempt<Option<String>>, AuthApiError> {
    let mut body = json!({
        "videoId": video_id,
        "uploadId": upload_id,
        "parts": parts,
        "replaceExisting": replace_existing,
    });
    if let Some(meta) = meta
        && let Value::Object(object) = &mut body
        && let Ok(Value::Object(extra)) = serde_json::to_value(meta)
    {
        object.extend(extra);
    }

    let response = auth::authed_request(
        reqwest::Method::POST,
        "/api/upload/multipart/complete",
        Some(body),
    )
    .await
    .map_err(|error| {
        AuthApiError::Other(format!("api/upload_multipart_complete/request: {error}"))
    })?;
    let status = response.status();
    if !status.is_success() {
        if status == StatusCode::CONFLICT {
            let body = response.json::<Value>().await.unwrap_or(Value::Null);
            if replacement_restart_required(status, &body) {
                return Ok(ReplacementUploadAttempt::RestartRequired(()));
            }
        }
        return Err(AuthApiError::Other(format!(
            "api/upload_multipart_complete/{}",
            status.as_u16()
        )));
    }
    let response = response.json::<Value>().await.unwrap_or(Value::Null);
    Ok(ReplacementUploadAttempt::Completed(
        response
            .get("objectIdentity")
            .and_then(Value::as_str)
            .map(str::to_string),
    ))
}

fn replacement_restart_required(status: StatusCode, body: &Value) -> bool {
    status == StatusCode::CONFLICT
        && body.get("code").and_then(Value::as_str) == Some("REPLACEMENT_RESTART_REQUIRED")
}

async fn upload_parts(
    video_id: &str,
    upload_id: &str,
    file_path: &Path,
    is_drive: bool,
    progress: &impl Fn(f64),
    cancel: &AtomicBool,
    replacement_source: Option<&mut ReplacementUploadSource>,
) -> Result<Vec<UploadedPart>, AuthApiError> {
    let file_size = std::fs::metadata(file_path)
        .map_err(|error| AuthApiError::Other(format!("Failed to read export size: {error}")))?
        .len();
    if file_size == 0 {
        return Err(AuthApiError::Other("Rendered video is empty".into()));
    }
    let transport = LivePartTransport {
        video_id,
        upload_id,
        is_drive,
        use_md5: auth::is_server_url_custom(),
        api: auth::api_client()?,
        storage: reqwest::Client::new(),
    };
    upload_file_parts(
        &transport,
        file_path,
        file_size,
        chunk_size_for(file_size),
        progress,
        cancel,
        replacement_source,
    )
    .await
}

struct PartChunk {
    part_number: u32,
    offset: u64,
    bytes: bytes::Bytes,
}

struct PresignedPart {
    url: String,
    md5: Option<String>,
}

trait PartTransport: Sync {
    fn presign(
        &self,
        chunk: &PartChunk,
        cancel: &AtomicBool,
    ) -> impl Future<Output = Result<PresignedPart, AuthApiError>> + Send;
    fn put(
        &self,
        presigned: &PresignedPart,
        chunk: &PartChunk,
        total_size: u64,
        cancel: &AtomicBool,
    ) -> impl Future<Output = Result<UploadedPart, AuthApiError>> + Send;
}

/// Every part of one upload goes through the same two clients, so parts after
/// the first reuse the open API and storage connections. The clients live only
/// as long as the upload, so a later upload never starts on a pooled
/// connection from an earlier network.
struct LivePartTransport<'a> {
    video_id: &'a str,
    upload_id: &'a str,
    is_drive: bool,
    use_md5: bool,
    api: reqwest::Client,
    storage: reqwest::Client,
}

impl PartTransport for LivePartTransport<'_> {
    async fn presign(
        &self,
        chunk: &PartChunk,
        cancel: &AtomicBool,
    ) -> Result<PresignedPart, AuthApiError> {
        let md5 = self.use_md5.then(|| md5_base64(&chunk.bytes));
        let url = checked_upload_step(cancel, || {
            multipart_presign(
                &self.api,
                self.video_id,
                self.upload_id,
                chunk.part_number,
                md5.as_deref(),
            )
        })
        .await?;
        Ok(PresignedPart { url, md5 })
    }

    async fn put(
        &self,
        presigned: &PresignedPart,
        chunk: &PartChunk,
        total_size: u64,
        cancel: &AtomicBool,
    ) -> Result<UploadedPart, AuthApiError> {
        put_presigned_part(
            &self.storage,
            &presigned.url,
            chunk,
            total_size,
            self.is_drive,
            presigned.md5.as_deref(),
            cancel,
        )
        .await
    }
}

/// Part requests only observe cancellation between requests, so this races
/// them against the cancel flag to drop an in-flight part promptly.
async fn upload_part_chunk(
    transport: &impl PartTransport,
    chunk: &PartChunk,
    total_size: u64,
    cancel: &AtomicBool,
) -> Result<UploadedPart, AuthApiError> {
    tokio::select! {
        biased;
        () = wait_for_export_cancel(cancel) => Err(AuthApiError::Other("Export cancelled".into())),
        result = async {
            let presigned = transport.presign(chunk, cancel).await?;
            transport.put(&presigned, chunk, total_size, cancel).await
        } => result,
    }
}

async fn wait_for_export_cancel(cancel: &AtomicBool) {
    while !cancel.load(Ordering::Acquire) {
        tokio::time::sleep(Duration::from_millis(100)).await;
    }
}

/// Parts go strictly one at a time, so an interrupted connection only ever
/// loses the one part that was in flight.
async fn upload_file_parts(
    transport: &impl PartTransport,
    file_path: &Path,
    file_size: u64,
    chunk_size: u64,
    progress: &impl Fn(f64),
    cancel: &AtomicBool,
    mut replacement_source: Option<&mut ReplacementUploadSource>,
) -> Result<Vec<UploadedPart>, AuthApiError> {
    let mut parts = Vec::new();
    let mut failed = Vec::new();
    let mut offset = 0u64;
    let mut uploaded_bytes = 0u64;
    let mut part_number = 1u32;

    while offset < file_size {
        if cancel.load(Ordering::Relaxed) {
            return Err(AuthApiError::Other("Export cancelled".into()));
        }
        let size = (file_size - offset).min(chunk_size) as usize;
        let chunk = read_chunk(file_path, offset, size)?;
        if let Some(source) = &mut replacement_source {
            source.check_chunk(part_number, offset, &chunk, file_size)?;
        }
        let chunk = PartChunk {
            part_number,
            offset,
            bytes: chunk.into(),
        };
        match upload_part_chunk(transport, &chunk, file_size, cancel).await {
            Ok(part) => {
                uploaded_bytes += size as u64;
                progress((uploaded_bytes as f64 / file_size as f64).min(0.99));
                parts.push(part);
            }
            Err(error) => {
                check_export_cancelled(cancel)?;
                tracing::warn!(part_number, error = %error, "chunk upload failed; will retry");
                failed.push((chunk, error));
            }
        }
        offset += size as u64;
        part_number += 1;
    }

    for (chunk, first_error) in failed {
        if cancel.load(Ordering::Relaxed) {
            return Err(AuthApiError::Other("Export cancelled".into()));
        }
        match upload_part_chunk(transport, &chunk, file_size, cancel).await {
            Ok(part) => {
                uploaded_bytes += chunk.bytes.len() as u64;
                progress((uploaded_bytes as f64 / file_size as f64).min(0.99));
                parts.push(part);
            }
            Err(_) => {
                check_export_cancelled(cancel)?;
                return Err(first_error);
            }
        }
    }

    parts.sort_by_key(|part| part.part_number);
    let mut deduped = HashMap::new();
    for part in parts {
        deduped.insert(part.part_number, part);
    }
    let mut parts = deduped.into_values().collect::<Vec<_>>();
    parts.sort_by_key(|part| part.part_number);
    Ok(parts)
}

async fn put_presigned_part(
    client: &reqwest::Client,
    url: &str,
    chunk: &PartChunk,
    total_size: u64,
    is_drive: bool,
    md5_sum: Option<&str>,
    cancel: &AtomicBool,
) -> Result<UploadedPart, AuthApiError> {
    let PartChunk {
        part_number,
        offset,
        ref bytes,
    } = *chunk;
    let mut attempt = 0u32;
    loop {
        let mut request = client
            .put(url)
            .header("Content-Length", bytes.len())
            .timeout(Duration::from_secs(5 * 60))
            .body(bytes.clone());
        if is_drive || is_google_drive_resumable_url(url) {
            let end = offset.saturating_add(bytes.len() as u64).saturating_sub(1);
            request = request.header(
                "Content-Range",
                format!("bytes {offset}-{end}/{total_size}"),
            );
        }
        if let Some(md5_sum) = md5_sum {
            request = request.header("Content-MD5", md5_sum);
        }
        let response =
            checked_upload_step(cancel, || async { Ok(send_upload_request(request).await) })
                .await?;
        match response {
            Ok(response) => {
                if !upload_status_ok(
                    url,
                    response.status(),
                    offset,
                    bytes.len() as u64,
                    total_size,
                ) {
                    let status = response.status();
                    return Err(AuthApiError::Other(format!(
                        "uploader/part/{part_number}/status/{status}"
                    )));
                }
                let etag = response
                    .headers()
                    .get("ETag")
                    .and_then(|value| value.to_str().ok())
                    .unwrap_or("")
                    .trim_matches('"')
                    .to_string();
                let object_identity = if (is_drive || is_google_drive_resumable_url(url))
                    && response.status().is_success()
                {
                    response.json::<Value>().await.ok().and_then(|value| {
                        cap_recording::upload_verification::completed_drive_object_identity(
                            &value, total_size,
                        )
                    })
                } else {
                    None
                };
                return Ok(UploadedPart {
                    part_number,
                    etag,
                    size: bytes.len(),
                    object_identity,
                });
            }
            Err(error) if is_network_error(&error) && attempt < 4 => {
                attempt += 1;
                let delay = Duration::from_secs(2u64.saturating_pow(attempt).min(30));
                tracing::info!(
                    part_number,
                    attempt,
                    "network error uploading chunk; retrying in {delay:?}: {error}"
                );
                checked_upload_step(cancel, || async {
                    tokio::time::sleep(delay).await;
                    Ok(())
                })
                .await?;
            }
            Err(error) => {
                return Err(AuthApiError::Other(format!(
                    "uploader/part/{part_number}/error: {error}"
                )));
            }
        }
    }
}

const SCREENSHOT_SUBPATH: &str = "screenshot/screen-capture.jpg";

async fn upload_screenshot_with_cancel(
    video_id: &str,
    path: &Path,
    cancel: &AtomicBool,
) -> Result<(), AuthApiError> {
    check_export_cancelled(cancel)?;
    let (bytes, target) = tokio::try_join!(
        compress_screenshot(path),
        presign_put_target(video_id, SCREENSHOT_SUBPATH, Some(cancel)),
    )?;
    upload_signed_bytes_inner(target, SCREENSHOT_SUBPATH, bytes, Some(cancel)).await
}

#[cfg(not(target_os = "linux"))]
async fn upload_screenshot(video_id: &str, path: &Path) -> Result<(), AuthApiError> {
    let (bytes, target) = tokio::try_join!(
        compress_screenshot(path),
        presign_put_target(video_id, SCREENSHOT_SUBPATH, None),
    )?;
    upload_signed_bytes_inner(target, SCREENSHOT_SUBPATH, bytes, None).await
}

async fn compress_screenshot(path: &Path) -> Result<Vec<u8>, AuthApiError> {
    let path = path.to_path_buf();
    tracked_upload_read(move || compress_image(&path))
        .await
        .map_err(|error| AuthApiError::Other(format!("Failed to compress image: {error}")))?
}

/// One presigned single-part PUT under a video's subpath -- `/api/upload/
/// signed` for the URL, then the raw body. The thumbnail upload and the
/// rendered-screenshot upload are both this shape (`singlepart_uploader` +
/// `PresignedS3PutRequest` in the Tauri binary).
async fn presigned_put_bytes(
    video_id: &str,
    subpath: &str,
    bytes: Vec<u8>,
) -> Result<(), AuthApiError> {
    presigned_put_bytes_inner(video_id, subpath, bytes, None).await
}

async fn optional_upload_step<T, F>(
    cancel: Option<&AtomicBool>,
    step: impl FnOnce() -> F,
) -> Result<T, AuthApiError>
where
    F: Future<Output = Result<T, AuthApiError>>,
{
    match cancel {
        Some(cancel) => checked_upload_step(cancel, step).await,
        None => step().await,
    }
}

async fn presigned_put_bytes_inner(
    video_id: &str,
    subpath: &str,
    bytes: Vec<u8>,
    cancel: Option<&AtomicBool>,
) -> Result<(), AuthApiError> {
    let target = presign_put_target(video_id, subpath, cancel).await?;
    upload_signed_bytes_inner(target, subpath, bytes, cancel).await
}

async fn presign_put_target(
    video_id: &str,
    subpath: &str,
    cancel: Option<&AtomicBool>,
) -> Result<SignedUploadTarget, AuthApiError> {
    #[derive(Deserialize)]
    #[serde(rename_all = "camelCase")]
    struct Response {
        presigned_put_data: SignedUploadTarget,
    }

    let response = optional_upload_step(cancel, || {
        auth::authed_request(
            reqwest::Method::POST,
            "/api/upload/signed",
            Some(json!({
                "videoId": video_id,
                "subpath": subpath,
                "method": "put",
            })),
        )
    })
    .await?;
    let status = response.status();
    if !status.is_success() {
        return Err(AuthApiError::Status(
            status,
            format!("api/upload_signed/{}", status.as_u16()),
        ));
    }
    response
        .json::<Response>()
        .await
        .map(|response| response.presigned_put_data)
        .map_err(|error| AuthApiError::Other(format!("api/upload_signed/response: {error}")))
}

async fn upload_signed_bytes_inner(
    target: SignedUploadTarget,
    subpath: &str,
    bytes: Vec<u8>,
    cancel: Option<&AtomicBool>,
) -> Result<(), AuthApiError> {
    static CLIENT: OnceLock<reqwest::Client> = OnceLock::new();

    let length = bytes.len() as u64;
    let mut request = CLIENT
        .get_or_init(upload_client)
        .put(&target.url)
        .header("Content-Length", length)
        .header("Content-Type", upload_content_type(subpath))
        .timeout(Duration::from_secs(5 * 60))
        .body(bytes);
    if is_google_drive_resumable_url(&target.url) && length > 0 {
        request = request.header(
            "Content-Range",
            format!("bytes 0-{}/{}", length.saturating_sub(1), length),
        );
    }
    for (name, value) in target.headers {
        request = request.header(name, value);
    }
    let response = optional_upload_step(cancel, || async {
        send_upload_request(request).await.map_err(|error| {
            if error.is_timeout() {
                AuthApiError::Timeout
            } else {
                AuthApiError::Other(error.to_string())
            }
        })
    })
    .await?;
    let status = response.status();
    if !status.is_success() {
        return Err(AuthApiError::Status(
            status,
            format!("upload failed: {status}"),
        ));
    }
    Ok(())
}

fn upload_client() -> reqwest::Client {
    reqwest::Client::builder()
        .connect_timeout(UPLOAD_CONNECT_TIMEOUT)
        .tcp_keepalive(UPLOAD_TCP_KEEPALIVE)
        .pool_idle_timeout(UPLOAD_POOL_IDLE_TIMEOUT)
        .build()
        .unwrap_or_else(|error| {
            tracing::warn!("Falling back to the default upload client: {error}");
            reqwest::Client::new()
        })
}

async fn send_upload_request(
    request: reqwest::RequestBuilder,
) -> Result<reqwest::Response, reqwest::Error> {
    request.send().await.map_err(reqwest::Error::without_url)
}

fn upload_content_type(subpath: &str) -> &'static str {
    if subpath.ends_with(".json") {
        "application/json"
    } else if subpath.ends_with(".mp4") || subpath.ends_with(".m4s") {
        "video/mp4"
    } else if subpath.ends_with(".png") {
        "image/png"
    } else if subpath.ends_with(".jpg") || subpath.ends_with(".jpeg") {
        "image/jpeg"
    } else {
        "application/octet-stream"
    }
}

// ---------------------------------------------------------------------------
// Screenshot share upload
// ---------------------------------------------------------------------------

/// A created-or-reused server video record, with the share link derived from
/// its id -- `UploadedItem` in the Tauri binary.
pub struct UploadedItem {
    pub link: String,
    pub id: String,
}

/// What the screenshot share flow's upload step resolved to. The two
/// non-success arms carry the exact toasts `shareLinkFromUploadResult` maps
/// them to on the window side.
pub enum ScreenshotShareOutcome {
    Uploaded(UploadedItem),
    NotAuthenticated,
    UpgradeRequired,
}

/// `screenshot_upload_subpath` (`src-tauri/upload.rs:259-265`): the composited
/// image lands under the record's screenshot key, extension by content type.
fn screenshot_upload_subpath(content_type: &str) -> &'static str {
    if content_type.eq_ignore_ascii_case("image/png") {
        "screenshot/screen-capture.png"
    } else {
        "screenshot/screen-capture.jpg"
    }
}

/// `upload_rendered_screenshot` (`src-tauri/lib.rs:3761-3796`), minus the
/// clipboard/meta halves the window owns: gate on auth exactly as the Tauri
/// command does, create-or-get the screenshot video record (re-using the
/// sharing id when the caller has one, so the link survives re-uploads), and
/// presigned-PUT the encoded bytes to the screenshot subpath.
pub async fn upload_rendered_screenshot(
    image_bytes: Vec<u8>,
    content_type: &str,
    video_id: Option<String>,
) -> Result<ScreenshotShareOutcome, String> {
    let auth = crate::store::auth_snapshot();
    if !auth.signed_in() {
        // The Tauri command resets a corrupt/absent auth store on this path.
        let _ = crate::store::set_auth(None);
        return Ok(ScreenshotShareOutcome::NotAuthenticated);
    }
    if !auth.is_upgraded() {
        return Ok(ScreenshotShareOutcome::UpgradeRequired);
    }

    match upload_screenshot_bytes(image_bytes, content_type, video_id).await {
        Ok(item) => Ok(ScreenshotShareOutcome::Uploaded(item)),
        Err(AuthApiError::InvalidAuthentication) => Ok(ScreenshotShareOutcome::NotAuthenticated),
        Err(AuthApiError::UpgradeRequired) => Ok(ScreenshotShareOutcome::UpgradeRequired),
        Err(error) => Err(error.to_string()),
    }
}

/// `upload_screenshot_bytes` (`src-tauri/upload.rs:279-307`).
async fn upload_screenshot_bytes(
    image_bytes: Vec<u8>,
    content_type: &str,
    video_id: Option<String>,
) -> Result<UploadedItem, AuthApiError> {
    let s3_config = create_or_get_video(true, video_id, None, None, None).await?;
    let subpath = screenshot_upload_subpath(content_type);
    presigned_put_bytes(&s3_config.id, subpath, image_bytes).await?;
    Ok(UploadedItem {
        link: format!("{}/s/{}", auth::server_url(), s3_config.id),
        id: s3_config.id,
    })
}

fn compress_image(path: &Path) -> Result<Vec<u8>, AuthApiError> {
    cap_gpui_kernels::codec::compress_image_jpeg(path).map_err(AuthApiError::Other)
}

fn build_video_meta(path: &Path) -> Result<VideoMeta, String> {
    let input = ffmpeg::format::input(path)
        .map_err(|error| format!("Failed to read input file: {error}"))?;
    let video_stream = input
        .streams()
        .best(ffmpeg::media::Type::Video)
        .ok_or_else(|| "Failed to find appropriate video stream in file".to_string())?;
    let video_codec =
        ffmpeg::codec::context::Context::from_parameters(video_stream.parameters())
            .map_err(|error| format!("Unable to read video codec information: {error}"))?;
    let video = video_codec
        .decoder()
        .video()
        .map_err(|error| format!("Unable to get video decoder: {error}"))?;
    Ok(VideoMeta {
        duration_in_secs: input.duration() as f64 / f64::from(ffmpeg::ffi::AV_TIME_BASE),
        width: video.width(),
        height: video.height(),
        fps: video
            .frame_rate()
            .map(|rate| rate.numerator() as f32 / rate.denominator() as f32),
    })
}

fn read_chunk(path: &Path, offset: u64, size: usize) -> Result<Vec<u8>, AuthApiError> {
    let mut file = std::fs::File::open(path)
        .map_err(|error| AuthApiError::Other(format!("Failed to open export: {error}")))?;
    file.seek(SeekFrom::Start(offset))
        .map_err(|error| AuthApiError::Other(format!("Failed to seek export: {error}")))?;
    let mut buffer = vec![0u8; size];
    file.read_exact(&mut buffer)
        .map_err(|error| AuthApiError::Other(format!("Failed to read export chunk: {error}")))?;
    Ok(buffer)
}

fn chunk_size_for(file_size: u64) -> u64 {
    let size = (file_size / 100).clamp(MIN_CHUNK_SIZE, MAX_CHUNK_SIZE);
    size / DRIVE_CHUNK_ALIGNMENT * DRIVE_CHUNK_ALIGNMENT
}

fn md5_base64(bytes: &[u8]) -> String {
    let digest = cap_gpui_kernels::codec::md5(bytes);
    base64::Engine::encode(&base64::engine::general_purpose::STANDARD, digest)
}

fn is_google_drive_resumable_url(url: &str) -> bool {
    let Ok(url) = reqwest::Url::parse(url) else {
        return false;
    };
    url.host_str().is_some_and(|host| {
        (host == "googleapis.com" || host.ends_with(".googleapis.com"))
            && url.path().starts_with("/upload/drive/")
    })
}

fn is_google_drive_upload(provider: Option<&str>, upload_id: &str) -> bool {
    provider == Some("googleDrive") || is_google_drive_resumable_url(upload_id)
}

fn upload_status_ok(
    url: &str,
    status: StatusCode,
    offset: u64,
    size: u64,
    total_size: u64,
) -> bool {
    status.is_success()
        || (is_google_drive_resumable_url(url)
            && status == StatusCode::PERMANENT_REDIRECT
            && offset.saturating_add(size) < total_size)
}

fn is_network_error(error: &reqwest::Error) -> bool {
    error.is_timeout() || error.is_connect() || error.is_request() || error.is_body()
}

fn urlencoding(value: &str) -> String {
    let mut encoded = String::new();
    for byte in value.bytes() {
        match byte {
            b'A'..=b'Z' | b'a'..=b'z' | b'0'..=b'9' | b'-' | b'_' | b'.' | b'~' => {
                encoded.push(byte as char);
            }
            _ => encoded.push_str(&format!("%{byte:02X}")),
        }
    }
    encoded
}

#[cfg(test)]
mod tests {
    use super::*;

    #[tokio::test]
    async fn presigned_transfer_errors_never_expose_secret_urls() {
        let client = reqwest::Client::new();
        for url in [
            "cap-test://upload.invalid/private-object?X-Amz-Signature=fake-s3-secret",
            "cap-test://upload.invalid/private-object?upload_id=fake-drive-secret",
        ] {
            let original = client.put(url).send().await.unwrap_err();
            assert_eq!(original.url().unwrap().as_str(), url);
            assert!(original.to_string().contains("fake-"));

            let error = send_upload_request(client.put(url)).await.unwrap_err();
            assert!(error.is_builder());
            assert!(error.url().is_none());
            let direct = upload_signed_bytes_inner(
                SignedUploadTarget {
                    url: url.into(),
                    headers: HashMap::new(),
                },
                "segments/video/segment_001.m4s",
                vec![1, 2, 3],
                None,
            )
            .await
            .unwrap_err();
            for message in [error.to_string(), format!("{error:?}"), direct.to_string()] {
                assert!(!message.is_empty());
                for secret in [
                    "fake-",
                    "upload.invalid",
                    "private-object",
                    "upload_id",
                    "X-Amz",
                ] {
                    assert!(!message.contains(secret), "Upload error leaked a secret");
                }
            }
        }
    }

    #[test]
    fn abort_segments_waits_until_the_upload_task_has_stopped() {
        struct Dropped(Arc<AtomicBool>);
        impl Drop for Dropped {
            fn drop(&mut self) {
                self.0.store(true, Ordering::Release);
            }
        }

        tokio::runtime::Builder::new_current_thread()
            .build()
            .unwrap()
            .block_on(async {
                let dropped = Arc::new(AtomicBool::new(false));
                let upload_dropped = dropped.clone();
                let (started_tx, started_rx) = tokio::sync::oneshot::channel();
                let task = tokio::spawn(async move {
                    let _dropped = Dropped(upload_dropped);
                    let _ = started_tx.send(());
                    std::future::pending::<()>().await;
                    Ok(())
                });
                started_rx.await.unwrap();
                let mut upload = InstantUpload {
                    video: VideoUploadInfo {
                        id: "test".into(),
                        link: "https://example.invalid/s/test".into(),
                        config: S3UploadMeta { id: "test".into() },
                    },
                    segment_upload: Some(task),
                    cancel: Arc::new(AtomicBool::new(false)),
                    metadata_lock: Arc::new(Mutex::new(())),
                    completion_permit: None,
                    completion_control: None,
                    bridge: None,
                    ownership: None,
                    prior_attempts: 0,
                    request_context: None,
                    reads: Arc::new(UploadReads::default()),
                };

                {
                    let mut finish = Box::pin(upload.finish_segments());
                    assert!(
                        std::future::poll_fn(|context| std::task::Poll::Ready(
                            finish.as_mut().poll(context)
                        ))
                        .await
                        .is_pending()
                    );
                }
                assert!(upload.segment_upload.is_some());
                upload.abort_segments().await;

                assert!(dropped.load(Ordering::Acquire));
                assert!(upload.cancel.load(Ordering::Acquire));
            });
    }

    fn upload_with_task(
        task: tokio::task::JoinHandle<Result<(), String>>,
        control: Option<CompletionControl>,
    ) -> InstantUpload {
        InstantUpload {
            video: VideoUploadInfo {
                id: "owned-upload".into(),
                link: "https://example.invalid/s/owned-upload".into(),
                config: S3UploadMeta {
                    id: "owned-upload".into(),
                },
            },
            segment_upload: Some(task),
            cancel: control
                .as_ref()
                .map(|control| control.cancel.clone())
                .unwrap_or_else(|| Arc::new(AtomicBool::new(false))),
            metadata_lock: Arc::new(Mutex::new(())),
            completion_permit: None,
            completion_control: control,
            bridge: None,
            ownership: None,
            prior_attempts: 0,
            request_context: None,
            reads: Arc::new(UploadReads::default()),
        }
    }

    #[tokio::test]
    async fn denied_segment_finish_waits_until_the_owned_task_has_joined() {
        let authorization = CompletionAuthorization::new();
        let control = authorization.control.clone();
        let finished = Arc::new(AtomicBool::new(false));
        let task_finished = finished.clone();
        let (release, released) = tokio::sync::oneshot::channel();
        let task = tokio::spawn(async move {
            released.await.unwrap();
            task_finished.store(true, Ordering::Release);
            Ok(())
        });
        let mut upload = upload_with_task(task, Some(control.clone()));
        {
            let mut finish = Box::pin(upload.finish_segments());
            assert!(
                std::future::poll_fn(|context| std::task::Poll::Ready(
                    finish.as_mut().poll(context)
                ))
                .await
                .is_pending()
            );
            control.deny();
            assert!(
                std::future::poll_fn(|context| std::task::Poll::Ready(
                    finish.as_mut().poll(context)
                ))
                .await
                .is_pending()
            );
            assert!(!finished.load(Ordering::Acquire));
            release.send(()).unwrap();
            assert!(finish.await.unwrap_err().contains("cancelled"));
        }
        assert!(finished.load(Ordering::Acquire));
        assert!(upload.segment_upload.is_none());
        upload.abort_segments().await;
    }

    #[tokio::test]
    async fn segment_finish_preserves_results_and_removes_only_joined_handles() {
        for result in [Ok(()), Err("segment transfer failed".to_string())] {
            let expected = result.clone();
            let mut upload = upload_with_task(tokio::spawn(async move { result }), None);
            assert_eq!(upload.finish_segments().await, expected);
            assert!(upload.segment_upload.is_none());
            upload.abort_segments().await;
        }

        let task = tokio::spawn(std::future::pending::<Result<(), String>>());
        task.abort();
        let mut upload = upload_with_task(task, None);
        assert!(
            upload
                .finish_segments()
                .await
                .unwrap_err()
                .contains("Instant segment upload task failed")
        );
        assert!(upload.segment_upload.is_none());
        upload.abort_segments().await;

        let task: tokio::task::JoinHandle<Result<(), String>> =
            tokio::spawn(async { panic!("synthetic segment task panic") });
        let mut upload = upload_with_task(task, None);
        assert!(
            upload
                .finish_segments()
                .await
                .unwrap_err()
                .contains("Instant segment upload task failed")
        );
        assert!(upload.segment_upload.is_none());
        upload.abort_segments().await;

        let task = tokio::spawn(std::future::pending::<Result<(), String>>());
        let mut upload = upload_with_task(task, None);
        upload.cancel.store(true, Ordering::Release);
        assert!(
            upload
                .finish_segments()
                .await
                .unwrap_err()
                .contains("cancelled")
        );
        assert!(upload.segment_upload.is_some());
        upload.abort_segments().await;
        assert!(upload.segment_upload.is_none());
    }

    fn segment_event(
        index: u32,
        duration: f64,
        is_init: bool,
        media_type: SegmentMediaType,
    ) -> SegmentCompletedEvent {
        SegmentCompletedEvent {
            path: PathBuf::from("segment.m4s"),
            index,
            duration,
            file_size: 16,
            is_init,
            media_type,
        }
    }

    /// The finished segment manifest this app uploads, checked against the
    /// files the web server's own parser is tested with
    /// (`apps/web/__tests__/unit/desktop-segments-manifest-contract.test.ts`),
    /// so neither side can change the format without the other noticing. Run
    /// with `CAP_UPDATE_CONTRACT_FIXTURES=1` to rewrite the files after an
    /// intended change.
    #[test]
    fn finished_segment_manifests_match_the_server_contract_fixtures() {
        let fixtures = std::path::Path::new(env!("CARGO_MANIFEST_DIR"))
            .join("../web/__tests__/fixtures/desktop-segments");
        for (name, audio) in [("with-audio", 2), ("video-only", 0)] {
            let mut manifest = SegmentUploadManifest::default();
            manifest.record(&segment_event(0, 0.0, true, SegmentMediaType::Video));
            for (index, duration) in [(1, 2.0), (2, 2.0), (3, 1.25)] {
                manifest.record(&segment_event(
                    index,
                    duration,
                    false,
                    SegmentMediaType::Video,
                ));
            }
            if audio > 0 {
                manifest.record(&segment_event(0, 0.0, true, SegmentMediaType::Audio));
                for index in 1..=audio {
                    manifest.record(&segment_event(index, 3.0, false, SegmentMediaType::Audio));
                }
            }
            manifest.is_complete = true;
            let uploaded = serde_json::to_value(&manifest).unwrap();
            let path = fixtures.join(format!("finished-manifest-{name}.json"));
            if std::env::var_os("CAP_UPDATE_CONTRACT_FIXTURES").is_some() {
                std::fs::create_dir_all(&fixtures).unwrap();
                let mut json = Vec::new();
                let formatter = serde_json::ser::PrettyFormatter::with_indent(b"\t");
                let mut serializer = serde_json::Serializer::with_formatter(&mut json, formatter);
                serde::Serialize::serialize(&uploaded, &mut serializer).unwrap();
                json.push(b'\n');
                std::fs::write(&path, json).unwrap();
            }
            let fixture: serde_json::Value = serde_json::from_slice(
                &std::fs::read(&path).unwrap_or_else(|error| panic!("{}: {error}", path.display())),
            )
            .unwrap();
            assert_eq!(
                fixture,
                uploaded,
                "{} no longer matches what the app uploads",
                path.display()
            );
        }
    }

    #[test]
    fn recorded_length_sums_the_complete_local_video_track() {
        let mut manifest = SegmentUploadManifest::default();
        manifest.record(&segment_event(0, 0.0, true, SegmentMediaType::Video));
        manifest.record(&segment_event(2, 2.0, false, SegmentMediaType::Video));
        manifest.record(&segment_event(1, 2.0, false, SegmentMediaType::Video));
        manifest.record(&segment_event(3, 0.5, false, SegmentMediaType::Video));
        manifest.record(&segment_event(1, 2.0, false, SegmentMediaType::Audio));

        let value: Value =
            serde_json::from_slice(&recorded_length_json(&manifest).unwrap()).unwrap();
        assert_eq!(
            value,
            json!({ "version": 1, "duration": 4.5, "video_segments": 3, "audio_segments": 1 })
        );
    }

    #[test]
    fn recorded_length_is_skipped_without_a_usable_video_length() {
        assert!(recorded_length_json(&SegmentUploadManifest::default()).is_none());
        for duration in [0.0, f64::NAN, f64::INFINITY] {
            let mut manifest = SegmentUploadManifest::default();
            manifest.record(&segment_event(1, duration, false, SegmentMediaType::Video));
            assert!(recorded_length_json(&manifest).is_none(), "{duration}");
        }
    }

    #[tokio::test]
    async fn alongside_never_waits_for_its_side_task() {
        let side_ran = Arc::new(AtomicBool::new(false));
        let flag = side_ran.clone();
        let output = alongside(async { 7 }, async move {
            std::future::pending::<()>().await;
            flag.store(true, Ordering::SeqCst);
        })
        .await;
        assert_eq!(output, 7);
        assert!(!side_ran.load(Ordering::SeqCst));
    }

    #[tokio::test]
    async fn alongside_finishes_its_main_task_after_a_quick_side_task() {
        let (sender, receiver) = tokio::sync::oneshot::channel::<u32>();
        let side_ran = Arc::new(AtomicBool::new(false));
        let flag = side_ran.clone();
        let output = alongside(async { receiver.await.unwrap() }, async move {
            flag.store(true, Ordering::SeqCst);
            sender.send(9).unwrap();
        })
        .await;
        assert_eq!(output, 9);
        assert!(side_ran.load(Ordering::SeqCst));
    }

    #[test]
    fn segment_manifest_requires_init_and_orders_video_and_audio() {
        let mut manifest = SegmentUploadManifest::default();
        manifest.record(&segment_event(3, 1.5, false, SegmentMediaType::Video));
        manifest.record(&segment_event(1, 2.0, false, SegmentMediaType::Video));
        manifest.record(&segment_event(2, 2.0, false, SegmentMediaType::Audio));
        manifest.record(&segment_event(1, 1.8, false, SegmentMediaType::Audio));

        assert!(!manifest.has_video_content());
        manifest.record(&segment_event(0, 0.0, true, SegmentMediaType::Video));
        manifest.record(&segment_event(0, 0.0, true, SegmentMediaType::Audio));

        assert!(manifest.has_video_content());
        assert_eq!(
            manifest
                .video_segments
                .iter()
                .map(|segment| segment.index)
                .collect::<Vec<_>>(),
            vec![1, 3]
        );
        assert_eq!(
            manifest
                .audio_segments
                .iter()
                .map(|segment| segment.index)
                .collect::<Vec<_>>(),
            vec![1, 2]
        );
        assert!(manifest.video_init_uploaded);
        assert!(manifest.audio_init_uploaded);
        assert!(!manifest.is_complete);
    }

    #[test]
    fn initial_segment_batch_prefetches_initializers_and_matching_media_pairs() {
        let paths = prefetched_segment_paths(1, 3);

        assert_eq!(paths.len(), 9);
        assert!(paths.contains(&"segments/video/init.mp4".to_string()));
        assert!(paths.contains(&"segments/audio/init.mp4".to_string()));
        assert!(paths.contains(&"segments/manifest.json".to_string()));
        assert!(paths.contains(&"segments/video/segment_001.m4s".to_string()));
        assert!(paths.contains(&"segments/audio/segment_003.m4s".to_string()));
    }

    #[test]
    fn subsequent_segment_batches_do_not_repeat_initializers() {
        assert_eq!(
            prefetched_segment_paths(21, 2),
            vec![
                "segments/video/segment_021.m4s",
                "segments/audio/segment_021.m4s",
                "segments/video/segment_022.m4s",
                "segments/audio/segment_022.m4s",
            ]
        );
    }

    #[test]
    fn segment_manifest_updates_replayed_segments_without_duplicates() {
        let mut manifest = SegmentUploadManifest::default();
        manifest.record(&segment_event(4, 1.0, false, SegmentMediaType::Video));
        manifest.record(&segment_event(4, 2.5, false, SegmentMediaType::Video));

        assert_eq!(
            manifest.video_segments,
            vec![SegmentManifestEntry {
                index: 4,
                duration: 2.5,
            }]
        );
    }

    #[test]
    fn segment_upload_paths_match_tauri_storage_layout() {
        assert_eq!(
            segment_subpath(&segment_event(0, 0.0, true, SegmentMediaType::Video)),
            "segments/video/init.mp4"
        );
        assert_eq!(
            segment_subpath(&segment_event(0, 0.0, true, SegmentMediaType::Audio)),
            "segments/audio/init.mp4"
        );
        assert_eq!(
            segment_subpath(&segment_event(7, 2.0, false, SegmentMediaType::Video)),
            "segments/video/segment_007.m4s"
        );
        assert_eq!(
            segment_subpath(&segment_event(14, 2.0, false, SegmentMediaType::Audio)),
            "segments/audio/segment_014.m4s"
        );
    }

    #[test]
    fn signed_upload_content_types_match_media() {
        assert_eq!(
            upload_content_type("segments/manifest.json"),
            "application/json"
        );
        assert_eq!(upload_content_type("segments/video/init.mp4"), "video/mp4");
        assert_eq!(
            upload_content_type("segments/audio/segment_001.m4s"),
            "video/mp4"
        );
        assert_eq!(
            upload_content_type("screenshot/screen-capture.jpg"),
            "image/jpeg"
        );
        assert_eq!(
            upload_content_type("screenshot/screen-capture.png"),
            "image/png"
        );
    }

    #[test]
    fn chunk_size_clamps() {
        assert_eq!(chunk_size_for(1), MIN_CHUNK_SIZE);
        // A hundredth of the file, clamped: the upper assertion needs a file
        // whose hundredth actually exceeds the cap (1.5 GiB does; the old
        // `MIN_CHUNK_SIZE * 200` = 1000 MiB sat below it and asserted the
        // wrong side of the clamp).
        assert_eq!(chunk_size_for(MAX_CHUNK_SIZE * 200), MAX_CHUNK_SIZE);
        assert_eq!(chunk_size_for(MIN_CHUNK_SIZE * 50), MIN_CHUNK_SIZE);
    }

    #[test]
    fn chunk_sizes_satisfy_drive_resumable_alignment() {
        for file_size in [
            1,
            MIN_CHUNK_SIZE * 100,
            MIN_CHUNK_SIZE * 100 + 100,
            600 * 1024 * 1024,
            1024 * 1024 * 1024,
            MAX_CHUNK_SIZE * 100 - 100,
            MAX_CHUNK_SIZE * 100,
            MAX_CHUNK_SIZE * 200,
        ] {
            let chunk_size = chunk_size_for(file_size);
            assert!((MIN_CHUNK_SIZE..=MAX_CHUNK_SIZE).contains(&chunk_size));
            assert_eq!(
                chunk_size % (256 * 1024),
                0,
                "Drive requires aligned intermediate chunks for a {file_size}-byte export"
            );
        }
    }

    #[test]
    fn drive_url_detection() {
        assert!(is_google_drive_resumable_url(
            "https://www.googleapis.com/upload/drive/v3/files?uploadType=resumable"
        ));
        assert!(!is_google_drive_resumable_url(
            "https://s3.amazonaws.com/bucket/key"
        ));
        assert!(is_google_drive_upload(Some("googleDrive"), "abc"));
    }

    #[test]
    fn reusable_video_id_prefers_sharing_state() {
        let sharing = SharingMeta {
            link: "https://cap.so/s/shared".into(),
            id: "shared".into(),
            content_hash: None,
        };
        let upload = UploadMeta::SinglePartUpload {
            video_id: "pending".into(),
            file_path: PathBuf::from("video.mp4"),
            screenshot_path: PathBuf::from("display.jpg"),
            recording_dir: PathBuf::from("recording.cap"),
        };

        assert_eq!(
            reusable_video_id(Some(&sharing), Some(&upload)).as_deref(),
            Some("shared")
        );
    }

    #[test]
    fn reusable_video_id_resumes_persisted_upload() {
        let upload = UploadMeta::SinglePartUpload {
            video_id: "pending".into(),
            file_path: PathBuf::from("video.mp4"),
            screenshot_path: PathBuf::from("display.jpg"),
            recording_dir: PathBuf::from("recording.cap"),
        };

        assert_eq!(
            reusable_video_id(None, Some(&upload)).as_deref(),
            Some("pending")
        );
        assert_eq!(
            reusable_video_id(
                None,
                Some(&UploadMeta::Failed {
                    error: "network".into(),
                }),
            ),
            None
        );
    }
    #[derive(Default)]
    struct FakeSegmentTransport {
        delay_preparation: AtomicBool,
        preparation_started: tokio::sync::Notify,
        preparation_dropped: AtomicBool,
        manifests: Mutex<Vec<bool>>,
        completed: std::sync::atomic::AtomicUsize,
        uploaded: std::sync::atomic::AtomicUsize,
        fail_segment: AtomicBool,
        fatal_segment: AtomicBool,
        status_failure: Mutex<Option<StatusCode>>,
        retryable_failures: std::sync::atomic::AtomicUsize,
        stall_retries: AtomicBool,
        segment_calls: std::sync::atomic::AtomicUsize,
        segment_call_limit: std::sync::atomic::AtomicUsize,
        segment_failed: tokio::sync::Notify,
        manifest_failures: std::sync::atomic::AtomicUsize,
        manifest_attempts: std::sync::atomic::AtomicUsize,
        last_manifest: Mutex<Option<SegmentUploadManifest>>,
        delay_complete: AtomicBool,
        complete_started: tokio::sync::Notify,
        complete_response: tokio::sync::Notify,
        prefetch_count: std::sync::atomic::AtomicUsize,
        delay_prefetch_at: std::sync::atomic::AtomicUsize,
        prefetch_started: tokio::sync::Notify,
        prefetch_response: tokio::sync::Notify,
    }
    impl SegmentTransport for FakeSegmentTransport {
        async fn prepare(&self, _: &str, _: Vec<Segment>) -> Result<Option<Vec<Segment>>, String> {
            if !self.delay_preparation.load(Ordering::Acquire) {
                return Ok(None);
            }
            struct Finish<'a>(&'a AtomicBool);
            impl Drop for Finish<'_> {
                fn drop(&mut self) {
                    self.0.store(true, Ordering::Release);
                }
            }
            let _finish = Finish(&self.preparation_dropped);
            self.preparation_started.notify_one();
            std::future::pending().await
        }
        async fn prefetch(
            &self,
            _: &str,
            _: u32,
            _: u32,
        ) -> Result<HashMap<String, String>, String> {
            let request = self.prefetch_count.fetch_add(1, Ordering::AcqRel) + 1;
            if request == self.delay_prefetch_at.load(Ordering::Acquire) {
                self.prefetch_started.notify_one();
                self.prefetch_response.notified().await;
            }
            Ok(HashMap::new())
        }
        async fn segment(
            &self,
            _: String,
            event: SegmentCompletedEvent,
            _: Arc<Mutex<HashMap<String, String>>>,
            _: Arc<AtomicBool>,
        ) -> Result<SegmentCompletedEvent, SegmentUploadError> {
            let calls = self.segment_calls.fetch_add(1, Ordering::AcqRel) + 1;
            let limit = self.segment_call_limit.load(Ordering::Acquire);
            if limit > 0 && calls > limit {
                return Err(SegmentUploadError::Fatal(
                    "segment call limit exceeded".into(),
                ));
            }
            if self.fatal_segment.load(Ordering::Acquire) {
                return Err(SegmentUploadError::Fatal(
                    "Authentication expired while uploading the instant recording".into(),
                ));
            }
            let retry = self.fail_segment.load(Ordering::Acquire)
                || self
                    .retryable_failures
                    .fetch_update(Ordering::AcqRel, Ordering::Acquire, |left| {
                        left.checked_sub(1)
                    })
                    .is_ok();
            if let Some(status) = *self.status_failure.lock().unwrap() {
                return Err(exhausted_segment_error(
                    event,
                    AuthApiError::Status(status, format!("upload failed: {status}")),
                ));
            }
            if retry {
                self.segment_failed.notify_one();
                return Err(exhausted_segment_error(
                    event,
                    AuthApiError::Other("segment upload failed".into()),
                ));
            }
            if self.stall_retries.load(Ordering::Acquire) {
                tokio::time::sleep(Duration::from_secs(5 * 60) * SEGMENT_UPLOAD_ATTEMPTS).await;
                return Err(exhausted_segment_error(event, AuthApiError::Timeout));
            }
            self.uploaded.fetch_add(1, Ordering::AcqRel);
            Ok(event)
        }
        async fn manifest(
            &self,
            _: &str,
            manifest: &SegmentUploadManifest,
            _: &Arc<AtomicBool>,
        ) -> Result<(), String> {
            self.manifest_attempts.fetch_add(1, Ordering::AcqRel);
            if !manifest.is_complete
                && self
                    .manifest_failures
                    .fetch_update(Ordering::AcqRel, Ordering::Acquire, |left| {
                        left.checked_sub(1)
                    })
                    .is_ok()
            {
                return Err("manifest upload failed".into());
            }
            self.manifests.lock().unwrap().push(manifest.is_complete);
            *self.last_manifest.lock().unwrap() = Some(manifest.clone());
            Ok(())
        }
        async fn complete(&self, _: &str, _: &Arc<AtomicBool>) -> Result<(), String> {
            self.completed.fetch_add(1, Ordering::AcqRel);
            if self.delay_complete.load(Ordering::Acquire) {
                self.complete_started.notify_one();
                self.complete_response.notified().await;
            }
            Ok(())
        }
    }
    #[tokio::test]
    async fn stopped_upload_drops_optional_preparation_without_waiting_for_it() {
        let transport = FakeSegmentTransport::default();
        transport.delay_preparation.store(true, Ordering::Release);
        let (sender, events) = flume::unbounded();
        sender
            .send(segment_event(0, 0.0, true, SegmentMediaType::Video))
            .unwrap();
        sender
            .send(segment_event(1, 1.0, false, SegmentMediaType::Video))
            .unwrap();
        let upload = upload_segments(
            &transport,
            "preparation",
            events,
            Arc::new(AtomicBool::new(false)),
            None,
        );
        tokio::pin!(upload);
        tokio::select! {
            _ = transport.preparation_started.notified() => {}
            result = &mut upload => panic!("Upload ended before preparation: {result:?}"),
            _ = tokio::time::sleep(Duration::from_secs(35)) => panic!("Preparation did not start"),
        }
        drop(sender);
        tokio::time::timeout(Duration::from_secs(1), upload)
            .await
            .unwrap()
            .unwrap();
        assert!(transport.preparation_dropped.load(Ordering::Acquire));
        assert_eq!(transport.completed.load(Ordering::Acquire), 1);
        assert_eq!(transport.manifests.lock().unwrap().last(), Some(&true));
    }

    fn closed_segment_events() -> flume::Receiver<SegmentCompletedEvent> {
        let (sender, receiver) = flume::unbounded();
        sender
            .send(segment_event(0, 0.0, true, SegmentMediaType::Video))
            .unwrap();
        sender
            .send(segment_event(1, 1.0, false, SegmentMediaType::Video))
            .unwrap();
        drop(sender);
        receiver
    }

    #[tokio::test]
    async fn segmented_complete_response_after_revocation_cannot_publish_delete_or_share() {
        let transport = FakeSegmentTransport::default();
        transport.delay_complete.store(true, Ordering::Release);
        let authorization = CompletionAuthorization::new();
        let cancel = authorization.control.cancel.clone();
        authorization.permit.send(()).unwrap();
        let published = AtomicBool::new(false);
        let deleted = AtomicBool::new(false);
        let shared = AtomicBool::new(false);
        let future = async {
            crate::recording::finish_instant_upload_locally(
                Some(&cancel),
                upload_segments(
                    &transport,
                    "revoked-completion",
                    closed_segment_events(),
                    cancel.clone(),
                    Some(authorization.required),
                ),
                || {
                    published.store(true, Ordering::Release);
                    Ok(())
                },
                async {
                    deleted.store(true, Ordering::Release);
                    Ok(())
                },
            )
            .await?;
            shared.store(true, Ordering::Release);
            Ok::<(), anyhow::Error>(())
        };
        tokio::pin!(future);
        tokio::select! {
            _ = transport.complete_started.notified() => {}
            result = &mut future => panic!("Completion did not wait: {result:?}"),
        }
        authorization.control.deny();
        transport.complete_response.notify_one();
        assert!(future.await.unwrap_err().to_string().contains("cancelled"));
        assert_eq!(transport.completed.load(Ordering::Acquire), 1);
        assert!(!published.load(Ordering::Acquire));
        assert!(!deleted.load(Ordering::Acquire));
        assert!(!shared.load(Ordering::Acquire));
    }

    #[tokio::test]
    async fn segmented_prefetch_response_after_revocation_cannot_start_more_uploads() {
        for pause_at in [1, 2] {
            let transport = FakeSegmentTransport::default();
            transport
                .delay_prefetch_at
                .store(pause_at, Ordering::Release);
            let authorization = CompletionAuthorization::new();
            authorization.permit.send(()).unwrap();
            let (sender, receiver) = flume::unbounded();
            sender
                .send(segment_event(0, 0.0, true, SegmentMediaType::Video))
                .unwrap();
            sender
                .send(segment_event(20, 1.0, false, SegmentMediaType::Video))
                .unwrap();
            drop(sender);
            let future = upload_segments(
                &transport,
                "revoked-prefetch",
                receiver,
                authorization.control.cancel.clone(),
                Some(authorization.required),
            );
            tokio::pin!(future);
            tokio::select! {
                _ = transport.prefetch_started.notified() => {}
                result = &mut future => panic!("Prefetch did not wait: {result:?}"),
            }
            let uploaded = transport.uploaded.load(Ordering::Acquire);
            authorization.control.deny();
            transport.prefetch_response.notify_one();
            assert!(future.await.unwrap_err().contains("cancelled"));
            assert_eq!(transport.uploaded.load(Ordering::Acquire), uploaded);
            assert_eq!(transport.prefetch_count.load(Ordering::Acquire), pause_at);
            assert_eq!(transport.completed.load(Ordering::Acquire), 0);
        }
    }

    #[tokio::test]
    async fn segmented_retry_delay_observes_revocation_before_next_request() {
        let cancel = AtomicBool::new(false);
        let requested = AtomicBool::new(false);
        let future = async {
            segment_retry_delay(&cancel, Duration::from_millis(20)).await?;
            checked_segment_step(&cancel, || async {
                requested.store(true, Ordering::Release);
                Ok(())
            })
            .await
        };
        tokio::pin!(future);
        assert!(
            tokio::time::timeout(Duration::from_millis(1), &mut future)
                .await
                .is_err()
        );
        cancel.store(true, Ordering::Release);
        assert!(future.await.unwrap_err().contains("cancelled"));
        assert!(!requested.load(Ordering::Acquire));
    }

    #[cfg(target_os = "linux")]
    #[tokio::test]
    async fn segmented_screenshot_uses_shared_revocation_before_reading_file() {
        let authorization = CompletionAuthorization::new();
        let control = authorization.control.clone();
        let upload = InstantUpload {
            video: VideoUploadInfo {
                id: "cancelled-thumbnail".into(),
                link: "https://example.invalid/s/cancelled-thumbnail".into(),
                config: S3UploadMeta {
                    id: "cancelled-thumbnail".into(),
                },
            },
            segment_upload: None,
            cancel: control.cancel.clone(),
            metadata_lock: Arc::new(Mutex::new(())),
            completion_permit: Some(authorization.permit),
            completion_control: Some(control.clone()),
            bridge: None,
            ownership: None,
            prior_attempts: 0,
            request_context: None,
            reads: Arc::new(UploadReads::default()),
        };
        control.deny();
        assert!(
            upload
                .screenshot_upload(Path::new("/not-a-recording/cancelled.cap"))
                .await
                .unwrap_err()
                .contains("Export cancelled")
        );
    }

    #[tokio::test]
    async fn segmented_presign_response_revocation_prevents_following_put() {
        let cancel = AtomicBool::new(false);
        let put_started = AtomicBool::new(false);
        let (response, received) = tokio::sync::oneshot::channel();
        let future = async {
            optional_upload_step(Some(&cancel), || async {
                received.await.unwrap();
                Ok(())
            })
            .await?;
            optional_upload_step(Some(&cancel), || async {
                put_started.store(true, Ordering::Release);
                Ok(())
            })
            .await
        };
        tokio::pin!(future);
        assert!(
            tokio::time::timeout(Duration::from_millis(1), &mut future)
                .await
                .is_err()
        );
        cancel.store(true, Ordering::Release);
        response.send(()).unwrap();
        assert!(future.await.is_err());
        assert!(!put_started.load(Ordering::Acquire));
    }

    #[tokio::test]
    async fn closed_capture_events_wait_for_successful_stop_permission_before_complete() {
        let transport = FakeSegmentTransport::default();
        let authorization = CompletionAuthorization::new();
        let future = upload_segments(
            &transport,
            "owned-attempt",
            closed_segment_events(),
            Arc::new(AtomicBool::new(false)),
            Some(authorization.required),
        );
        tokio::pin!(future);
        assert!(
            tokio::time::timeout(Duration::from_millis(10), &mut future)
                .await
                .is_err()
        );
        assert_eq!(transport.completed.load(Ordering::Acquire), 0);
        assert!(
            transport
                .manifests
                .lock()
                .unwrap()
                .iter()
                .all(|complete| !complete)
        );
        authorization.permit.send(()).unwrap();
        future.await.unwrap();
        assert_eq!(transport.completed.load(Ordering::Acquire), 1);
        assert_eq!(transport.manifests.lock().unwrap().last(), Some(&true));
    }

    #[tokio::test]
    async fn failed_stop_denies_completion_even_after_all_segments_uploaded() {
        let transport = FakeSegmentTransport::default();
        let authorization = CompletionAuthorization::new();
        let future = upload_segments(
            &transport,
            "failed-attempt",
            closed_segment_events(),
            Arc::new(AtomicBool::new(false)),
            Some(authorization.required),
        );
        tokio::pin!(future);
        assert!(
            tokio::time::timeout(Duration::from_millis(10), &mut future)
                .await
                .is_err()
        );
        assert_eq!(transport.uploaded.load(Ordering::Acquire), 2);
        drop(authorization.permit);
        assert!(future.await.unwrap_err().contains("not authorized"));
        assert_eq!(transport.completed.load(Ordering::Acquire), 0);
        assert!(
            transport
                .manifests
                .lock()
                .unwrap()
                .iter()
                .all(|complete| !complete)
        );
    }

    #[tokio::test(start_paused = true)]
    async fn cancelled_or_failed_upload_cannot_complete_with_a_queued_permission() {
        for fail_segment in [false, true] {
            let transport = FakeSegmentTransport::default();
            transport
                .fail_segment
                .store(fail_segment, Ordering::Release);
            let authorization = CompletionAuthorization::new();
            authorization.permit.send(()).unwrap();
            assert!(
                upload_segments(
                    &transport,
                    "failed-attempt",
                    closed_segment_events(),
                    Arc::new(AtomicBool::new(!fail_segment)),
                    Some(authorization.required)
                )
                .await
                .is_err()
            );
            assert_eq!(transport.completed.load(Ordering::Acquire), 0);
            assert!(
                transport
                    .manifests
                    .lock()
                    .unwrap()
                    .iter()
                    .all(|complete| !complete)
            );
        }
    }

    #[tokio::test]
    async fn permission_from_an_old_attempt_cannot_release_a_new_attempt() {
        let old = CompletionAuthorization::new();
        drop(old.required);
        let current = CompletionAuthorization::new();
        let transport = FakeSegmentTransport::default();
        let future = upload_segments(
            &transport,
            "new-attempt",
            closed_segment_events(),
            Arc::new(AtomicBool::new(false)),
            Some(current.required),
        );
        tokio::pin!(future);
        assert!(old.permit.send(()).is_err());
        assert!(
            tokio::time::timeout(Duration::from_millis(10), &mut future)
                .await
                .is_err()
        );
        assert_eq!(transport.completed.load(Ordering::Acquire), 0);
        current.permit.send(()).unwrap();
        future.await.unwrap();
        assert_eq!(transport.completed.load(Ordering::Acquire), 1);
    }

    #[tokio::test]
    async fn legacy_upload_without_authorization_preserves_channel_close_completion() {
        let transport = FakeSegmentTransport::default();
        upload_segments(
            &transport,
            "legacy-attempt",
            closed_segment_events(),
            Arc::new(AtomicBool::new(false)),
            None,
        )
        .await
        .unwrap();
        assert_eq!(transport.completed.load(Ordering::Acquire), 1);
    }
    #[tokio::test]
    async fn aborting_upload_revokes_its_completion_permission_before_retry() {
        let authorization = CompletionAuthorization::new();
        let mut upload = InstantUpload {
            video: VideoUploadInfo {
                id: "cancelled".into(),
                link: "https://example.invalid/s/cancelled".into(),
                config: S3UploadMeta {
                    id: "cancelled".into(),
                },
            },
            segment_upload: None,
            cancel: Arc::new(AtomicBool::new(false)),
            metadata_lock: Arc::new(Mutex::new(())),
            completion_permit: Some(authorization.permit),
            completion_control: Some(authorization.control),
            bridge: None,
            ownership: None,
            prior_attempts: 0,
            request_context: None,
            reads: Arc::new(UploadReads::default()),
        };
        upload.abort_segments().await;
        assert!(authorization.required.permission.await.is_err());
        assert!(upload.authorize_completion().is_err());
    }
    #[tokio::test]
    async fn revocation_wakes_pending_completion_without_upload_mutex_or_permit_drop() {
        let authorization = CompletionAuthorization::new();
        let transport = FakeSegmentTransport::default();
        let future = upload_segments(
            &transport,
            "revoked-attempt",
            closed_segment_events(),
            authorization.control.cancel.clone(),
            Some(authorization.required),
        );
        tokio::pin!(future);
        assert!(
            tokio::time::timeout(Duration::from_millis(10), &mut future)
                .await
                .is_err()
        );
        authorization.control.deny();
        assert!(
            tokio::time::timeout(Duration::from_secs(1), future)
                .await
                .unwrap()
                .is_err()
        );
        assert_eq!(transport.completed.load(Ordering::Acquire), 0);
        assert!(
            transport
                .manifests
                .lock()
                .unwrap()
                .iter()
                .all(|complete| !complete)
        );
        assert!(authorization.permit.send(()).is_err());
    }
    #[tokio::test]
    async fn finalized_manifest_must_match_all_required_local_segments() {
        for missing_audio in [false, true] {
            let transport = FakeSegmentTransport::default();
            let authorization = CompletionAuthorization::new();
            let mut expected = SegmentUploadManifest::default();
            expected.record(&segment_event(0, 0.0, true, SegmentMediaType::Video));
            expected.record(&segment_event(1, 1.0, false, SegmentMediaType::Video));
            if missing_audio {
                expected.record(&segment_event(0, 0.0, true, SegmentMediaType::Audio));
                expected.record(&segment_event(1, 1.0, false, SegmentMediaType::Audio));
            }
            expected.is_complete = true;
            *authorization.control.expected_manifest.lock().unwrap() = Some(expected);
            authorization.permit.send(()).unwrap();
            let result = upload_segments(
                &transport,
                "same-video",
                closed_segment_events(),
                authorization.control.cancel.clone(),
                Some(authorization.required),
            )
            .await;
            assert_eq!(result.is_err(), missing_audio);
            assert_eq!(transport.completed.load(Ordering::Acquire), 0);
            assert_eq!(
                transport.manifests.lock().unwrap().contains(&true),
                !missing_audio
            );
        }
    }
    fn audio_video_segment_events() -> (
        flume::Receiver<SegmentCompletedEvent>,
        SegmentUploadManifest,
    ) {
        let (sender, receiver) = flume::unbounded();
        let mut expected = SegmentUploadManifest::default();
        for media_type in [SegmentMediaType::Video, SegmentMediaType::Audio] {
            for index in 0..3 {
                let event = segment_event(index, f64::from(index), index == 0, media_type);
                expected.record(&event);
                sender.send(event).unwrap();
            }
        }
        expected.is_complete = true;
        (receiver, expected)
    }

    #[tokio::test(start_paused = true)]
    async fn segment_failing_past_its_attempts_is_retried_into_the_final_manifest() {
        let transport = FakeSegmentTransport::default();
        transport.retryable_failures.store(4, Ordering::Release);
        let authorization = CompletionAuthorization::new();
        let (events, expected) = audio_video_segment_events();
        *authorization.control.expected_manifest.lock().unwrap() = Some(expected.clone());
        authorization.permit.send(()).unwrap();
        let started = tokio::time::Instant::now();
        upload_segments(
            &transport,
            "flaky-network",
            events,
            authorization.control.cancel.clone(),
            Some(authorization.required),
        )
        .await
        .unwrap();
        assert!(started.elapsed() < SEGMENT_RETRY_WINDOW);
        assert_eq!(transport.segment_calls.load(Ordering::Acquire), 10);
        assert_eq!(transport.uploaded.load(Ordering::Acquire), 6);
        assert_eq!(
            transport.last_manifest.lock().unwrap().as_ref(),
            Some(&expected)
        );
    }

    #[tokio::test(start_paused = true)]
    async fn successful_upload_retries_deferred_segments_without_waiting_for_backoff() {
        let transport = FakeSegmentTransport::default();
        transport.retryable_failures.store(1, Ordering::Release);
        let (sender, events) = flume::unbounded();
        sender
            .send(segment_event(0, 0.0, true, SegmentMediaType::Video))
            .unwrap();
        let future = upload_segments(
            &transport,
            "recovered-network",
            events,
            Arc::new(AtomicBool::new(false)),
            None,
        );
        tokio::pin!(future);
        tokio::select! {
            _ = transport.segment_failed.notified() => {}
            result = &mut future => panic!("Upload ended before the init segment failed: {result:?}"),
        }
        let started = tokio::time::Instant::now();
        sender
            .send(segment_event(1, 1.0, false, SegmentMediaType::Video))
            .unwrap();
        drop(sender);
        future.await.unwrap();
        assert_eq!(started.elapsed(), Duration::ZERO);
        assert_eq!(transport.segment_calls.load(Ordering::Acquire), 3);
        assert_eq!(transport.completed.load(Ordering::Acquire), 1);
        let manifest = transport.last_manifest.lock().unwrap().clone().unwrap();
        assert!(manifest.is_complete && manifest.video_init_uploaded);
        assert_eq!(manifest.video_segments.len(), 1);
    }

    #[tokio::test]
    async fn progress_manifest_failure_does_not_end_the_live_upload() {
        let transport = FakeSegmentTransport::default();
        transport
            .manifest_failures
            .store(usize::MAX, Ordering::Release);
        upload_segments(
            &transport,
            "manifest-blip",
            closed_segment_events(),
            Arc::new(AtomicBool::new(false)),
            None,
        )
        .await
        .unwrap();
        assert_eq!(transport.manifest_attempts.load(Ordering::Acquire), 2);
        assert_eq!(*transport.manifests.lock().unwrap(), vec![true]);
        assert_eq!(transport.completed.load(Ordering::Acquire), 1);
    }

    #[tokio::test(start_paused = true)]
    async fn segment_that_never_uploads_fails_the_run_after_the_retry_window() {
        let transport = FakeSegmentTransport::default();
        transport.fail_segment.store(true, Ordering::Release);
        let authorization = CompletionAuthorization::new();
        authorization.permit.send(()).unwrap();
        let started = tokio::time::Instant::now();
        let error = upload_segments(
            &transport,
            "offline",
            closed_segment_events(),
            authorization.control.cancel.clone(),
            Some(authorization.required),
        )
        .await
        .unwrap_err();
        assert!(error.contains("segment upload failed"));
        assert_eq!(started.elapsed(), SEGMENT_RETRY_WINDOW);
        assert_eq!(transport.completed.load(Ordering::Acquire), 0);
        assert!(transport.manifests.lock().unwrap().is_empty());
    }

    #[tokio::test(start_paused = true)]
    async fn stalled_retry_cannot_outlive_the_retry_window() {
        let transport = FakeSegmentTransport::default();
        transport.retryable_failures.store(1, Ordering::Release);
        transport.stall_retries.store(true, Ordering::Release);
        let (sender, events) = flume::unbounded();
        sender
            .send(segment_event(0, 0.0, true, SegmentMediaType::Video))
            .unwrap();
        drop(sender);
        let started = tokio::time::Instant::now();
        let error = upload_segments(
            &transport,
            "stalled-retry",
            events,
            Arc::new(AtomicBool::new(false)),
            None,
        )
        .await
        .unwrap_err();
        assert!(error.contains("segment upload failed"), "{error}");
        assert_eq!(started.elapsed(), SEGMENT_RETRY_WINDOW);
        assert_eq!(transport.segment_calls.load(Ordering::Acquire), 2);
        assert_eq!(transport.completed.load(Ordering::Acquire), 0);
    }

    #[tokio::test(start_paused = true)]
    async fn deferred_segments_beyond_the_upload_limit_still_back_off() {
        let transport = FakeSegmentTransport::default();
        transport.fail_segment.store(true, Ordering::Release);
        let segments = 2 * MAX_SEGMENT_UPLOADS as u32;
        let (sender, events) = flume::unbounded();
        for index in 0..segments {
            sender
                .send(segment_event(
                    index,
                    f64::from(index),
                    index == 0,
                    SegmentMediaType::Video,
                ))
                .unwrap();
        }
        drop(sender);
        let mut rounds = 1;
        let mut elapsed = Duration::ZERO;
        for round in 0.. {
            elapsed += segment_retry_backoff(round);
            if elapsed >= SEGMENT_RETRY_WINDOW {
                break;
            }
            rounds += 1;
        }
        transport
            .segment_call_limit
            .store(segments as usize * rounds, Ordering::Release);
        let error = upload_segments(
            &transport,
            "long-outage",
            events,
            Arc::new(AtomicBool::new(false)),
            None,
        )
        .await
        .unwrap_err();
        assert!(error.contains("segment upload failed"), "{error}");
    }

    #[tokio::test(start_paused = true)]
    async fn revocation_while_a_segment_waits_for_retry_aborts_promptly() {
        let transport = FakeSegmentTransport::default();
        transport.fail_segment.store(true, Ordering::Release);
        let authorization = CompletionAuthorization::new();
        authorization.permit.send(()).unwrap();
        let future = upload_segments(
            &transport,
            "revoked-during-retry",
            closed_segment_events(),
            authorization.control.cancel.clone(),
            Some(authorization.required),
        );
        tokio::pin!(future);
        tokio::select! {
            _ = transport.segment_failed.notified() => {}
            result = &mut future => panic!("Upload ended before a segment failed: {result:?}"),
        }
        let calls = transport.segment_calls.load(Ordering::Acquire);
        authorization.control.deny();
        let result = tokio::time::timeout(Duration::from_millis(1), future)
            .await
            .expect("revocation waited for the segment retry backoff");
        assert!(result.is_err());
        assert_eq!(transport.segment_calls.load(Ordering::Acquire), calls);
        assert_eq!(transport.completed.load(Ordering::Acquire), 0);
        assert!(transport.manifests.lock().unwrap().is_empty());
    }

    #[tokio::test(start_paused = true)]
    async fn authentication_failure_still_ends_the_live_upload_immediately() {
        let transport = FakeSegmentTransport::default();
        transport.fatal_segment.store(true, Ordering::Release);
        let authorization = CompletionAuthorization::new();
        authorization.permit.send(()).unwrap();
        let started = tokio::time::Instant::now();
        let error = upload_segments(
            &transport,
            "signed-out",
            closed_segment_events(),
            authorization.control.cancel.clone(),
            Some(authorization.required),
        )
        .await
        .unwrap_err();
        assert!(error.contains("Authentication expired"));
        assert_eq!(started.elapsed(), Duration::ZERO);
        assert_eq!(transport.segment_calls.load(Ordering::Acquire), 1);
        assert_eq!(transport.completed.load(Ordering::Acquire), 0);
    }

    #[tokio::test(start_paused = true)]
    async fn permanent_http_failure_ends_the_live_upload_without_deferral() {
        for status in [
            StatusCode::NOT_FOUND,
            StatusCode::FORBIDDEN,
            StatusCode::GONE,
        ] {
            let transport = FakeSegmentTransport::default();
            *transport.status_failure.lock().unwrap() = Some(status);
            let authorization = CompletionAuthorization::new();
            authorization.permit.send(()).unwrap();
            let started = tokio::time::Instant::now();
            let error = upload_segments(
                &transport,
                "deleted-video",
                closed_segment_events(),
                authorization.control.cancel.clone(),
                Some(authorization.required),
            )
            .await
            .unwrap_err();
            assert!(error.contains(status.as_str()), "{error}");
            assert_eq!(started.elapsed(), Duration::ZERO);
            assert_eq!(transport.segment_calls.load(Ordering::Acquire), 1);
            assert_eq!(transport.completed.load(Ordering::Acquire), 0);
            assert!(transport.manifests.lock().unwrap().is_empty());
        }
    }

    #[tokio::test(start_paused = true)]
    async fn transient_http_failure_is_deferred_until_it_uploads() {
        let transport = FakeSegmentTransport::default();
        *transport.status_failure.lock().unwrap() = Some(StatusCode::SERVICE_UNAVAILABLE);
        let future = upload_segments(
            &transport,
            "server-blip",
            closed_segment_events(),
            Arc::new(AtomicBool::new(false)),
            None,
        );
        tokio::pin!(future);
        tokio::select! {
            _ = tokio::time::sleep(Duration::from_secs(10)) => {}
            result = &mut future => panic!("A 503 ended the live upload: {result:?}"),
        }
        assert!(transport.segment_calls.load(Ordering::Acquire) > 2);
        *transport.status_failure.lock().unwrap() = None;
        future.await.unwrap();
        assert_eq!(transport.completed.load(Ordering::Acquire), 1);
        assert_eq!(transport.manifests.lock().unwrap().last(), Some(&true));
    }

    #[test]
    fn only_transient_failures_are_deferred_for_retry() {
        let status = |code: u16| {
            segment_error_is_retryable(&AuthApiError::Status(
                StatusCode::from_u16(code).unwrap(),
                format!("upload failed: {code}"),
            ))
        };
        assert!(!segment_error_is_retryable(
            &AuthApiError::InvalidAuthentication
        ));
        assert!(!segment_error_is_retryable(&AuthApiError::UpgradeRequired));
        for permanent in [400, 401, 402, 403, 404, 410, 413, 422] {
            assert!(!status(permanent), "{permanent} must not be deferred");
        }
        for transient in [408, 429, 500, 502, 503, 504] {
            assert!(status(transient), "{transient} must be deferred");
        }
        assert!(segment_error_is_retryable(&AuthApiError::Timeout));
        assert!(segment_error_is_retryable(&AuthApiError::Other(
            "error sending request".into()
        )));
    }

    #[test]
    fn status_failures_keep_their_previous_messages() {
        assert_eq!(
            AuthApiError::Status(StatusCode::NOT_FOUND, "api/upload_signed/404".into()).to_string(),
            "api/upload_signed/404"
        );
    }

    #[test]
    fn deferred_segment_backoff_doubles_up_to_its_cap() {
        let delays: Vec<_> = [0, 1, 2, 3, 4, 40]
            .map(|round| segment_retry_backoff(round).as_secs())
            .into();
        assert_eq!(delays, vec![2, 4, 8, 16, 30, 30]);
    }

    #[tokio::test]
    async fn cancelling_upload_waits_for_its_blocking_file_read() {
        let reads = Arc::new(UploadReads::default());
        let (started, entered) = tokio::sync::oneshot::channel();
        let (release, released) = std::sync::mpsc::channel();
        let task = tokio::spawn(with_upload_context(None, reads.clone(), async move {
            tracked_upload_read(move || {
                started.send(()).unwrap();
                released.recv().unwrap();
            })
            .await
            .unwrap();
        }));
        entered.await.unwrap();
        task.abort();
        assert!(task.await.unwrap_err().is_cancelled());
        let still_reading = tokio::time::timeout(Duration::from_millis(10), reads.join())
            .await
            .is_err();
        release.send(()).unwrap();
        tokio::time::timeout(Duration::from_secs(1), reads.join())
            .await
            .unwrap();
        assert!(still_reading);
        assert_eq!(reads.active.load(Ordering::Acquire), 0);
    }
}

#[cfg(test)]
mod replacement_upload_restart_tests {
    use super::*;
    use std::sync::atomic::AtomicUsize;

    #[test]
    fn only_legacy_replacements_capture_a_restart_source() {
        assert!(is_legacy_replacement_upload(true, "raw-s3-upload"));
        assert!(is_legacy_replacement_upload(
            true,
            "https://googleapis.com/upload/legacy"
        ));
        assert!(!is_legacy_replacement_upload(false, "raw-s3-upload"));
        assert!(!is_legacy_replacement_upload(
            true,
            "cap-reupload.signed-token"
        ));
        assert!(!is_legacy_replacement_upload(true, "cap-reupload."));
    }

    #[test]
    fn only_the_exact_conflict_code_requests_a_restart() {
        let body = json!({ "code": "REPLACEMENT_RESTART_REQUIRED" });
        assert!(replacement_restart_required(StatusCode::CONFLICT, &body));
        for status in [
            StatusCode::OK,
            StatusCode::BAD_REQUEST,
            StatusCode::INTERNAL_SERVER_ERROR,
        ] {
            assert!(!replacement_restart_required(status, &body));
        }
        for body in [
            Value::Null,
            json!({}),
            json!({ "error": "REPLACEMENT_RESTART_REQUIRED" }),
            json!({ "code": "OTHER_CONFLICT" }),
            json!({ "code": "replacement_restart_required" }),
            json!({ "code": ["REPLACEMENT_RESTART_REQUIRED"] }),
            json!({ "code": "REPLACEMENT_RESTART_REQUIRED extra" }),
        ] {
            assert!(!replacement_restart_required(StatusCode::CONFLICT, &body));
        }
    }

    #[tokio::test]
    async fn restarts_the_whole_replacement_once_and_returns_only_the_second_identity() {
        let cancel = AtomicBool::new(false);
        let events = Mutex::new(Vec::new());
        let cancel = &cancel;
        let events = &events;
        let result = retry_replacement_upload(true, cancel, 0usize, |attempt| async move {
            checked_upload_step(cancel, || async {
                events.lock().unwrap().push((attempt, "initiate"));
                Ok(())
            })
            .await?;
            checked_upload_step(cancel, || async {
                events.lock().unwrap().push((attempt, "parts"));
                Ok(())
            })
            .await?;
            checked_upload_step(cancel, || async {
                events.lock().unwrap().push((attempt, "complete"));
                Ok(if attempt == 0 {
                    ReplacementUploadAttempt::RestartRequired(1)
                } else {
                    ReplacementUploadAttempt::Completed("new-object-identity")
                })
            })
            .await
        })
        .await
        .unwrap();
        assert_eq!(result, "new-object-identity");
        assert_eq!(
            *events.lock().unwrap(),
            [
                (0, "initiate"),
                (0, "parts"),
                (0, "complete"),
                (1, "initiate"),
                (1, "parts"),
                (1, "complete"),
            ]
        );
    }

    #[tokio::test]
    async fn restart_requires_a_signed_session_before_any_further_upload_work() {
        for upload_id in ["legacy-again", "cap-reupload.signed"] {
            let uploads = AtomicUsize::new(0);
            let uploads = &uploads;
            let result = retry_replacement_upload(
                true,
                &AtomicBool::new(false),
                false,
                |restarted| async move {
                    validate_replacement_restart_session(
                        restarted,
                        if restarted { upload_id } else { "legacy-first" },
                    )?;
                    uploads.fetch_add(1, Ordering::AcqRel);
                    Ok(if restarted {
                        ReplacementUploadAttempt::Completed(())
                    } else {
                        ReplacementUploadAttempt::RestartRequired(true)
                    })
                },
            )
            .await;
            assert_eq!(result.is_ok(), upload_id.starts_with("cap-reupload."));
            assert_eq!(
                uploads.load(Ordering::Acquire),
                if result.is_ok() { 2 } else { 1 }
            );
        }
    }

    #[tokio::test]
    async fn repeated_restart_requests_fail_after_two_attempts() {
        let attempts = AtomicUsize::new(0);
        let result: Result<(), _> =
            retry_replacement_upload(true, &AtomicBool::new(false), (), |()| async {
                attempts.fetch_add(1, Ordering::AcqRel);
                Ok(ReplacementUploadAttempt::RestartRequired(()))
            })
            .await;
        assert!(
            result
                .unwrap_err()
                .to_string()
                .contains("REPLACEMENT_RESTART_REQUIRED")
        );
        assert_eq!(attempts.load(Ordering::Acquire), 2);
    }

    #[tokio::test]
    async fn first_uploads_and_other_errors_do_not_restart() {
        let attempts = AtomicUsize::new(0);
        let result: Result<(), _> =
            retry_replacement_upload(false, &AtomicBool::new(false), (), |()| async {
                attempts.fetch_add(1, Ordering::AcqRel);
                Ok(ReplacementUploadAttempt::RestartRequired(()))
            })
            .await;
        assert!(result.is_err());
        assert_eq!(attempts.load(Ordering::Acquire), 1);
        for message in [
            "api/upload_multipart_complete/409",
            "api/upload_multipart_complete/500",
            "Failed to read export chunk",
        ] {
            attempts.store(0, Ordering::Release);
            let result: Result<(), _> =
                retry_replacement_upload(true, &AtomicBool::new(false), (), |()| async {
                    attempts.fetch_add(1, Ordering::AcqRel);
                    Err(AuthApiError::Other(message.into()))
                })
                .await;
            assert_eq!(result.unwrap_err().to_string(), message);
            assert_eq!(attempts.load(Ordering::Acquire), 1);
        }
    }

    #[tokio::test]
    async fn cancellation_before_upload_prevents_both_attempts() {
        let result: Result<(), _> =
            retry_replacement_upload(true, &AtomicBool::new(true), (), |()| async {
                panic!("Cancelled upload must not initiate")
            })
            .await;
        assert!(result.unwrap_err().to_string().contains("Export cancelled"));
    }

    #[tokio::test]
    async fn cancellation_during_the_conflict_response_prevents_restart() {
        let cancel = Arc::new(AtomicBool::new(false));
        let attempts = Arc::new(AtomicUsize::new(0));
        let worker_cancel = cancel.clone();
        let worker_attempts = attempts.clone();
        let (entered, entered_rx) = tokio::sync::oneshot::channel();
        let (release, released) = tokio::sync::oneshot::channel();
        let worker = tokio::spawn(async move {
            let mut entered = Some(entered);
            let mut released = Some(released);
            retry_replacement_upload(true, &worker_cancel, (), |()| {
                worker_attempts.fetch_add(1, Ordering::AcqRel);
                let entered = entered.take().unwrap();
                let released = released.take().unwrap();
                async move {
                    entered.send(()).unwrap();
                    released.await.unwrap();
                    Ok(ReplacementUploadAttempt::<(), _>::RestartRequired(()))
                }
            })
            .await
        });
        entered_rx.await.unwrap();
        cancel.store(true, Ordering::Release);
        release.send(()).unwrap();
        assert!(
            worker
                .await
                .unwrap()
                .unwrap_err()
                .to_string()
                .contains("Export cancelled")
        );
        assert_eq!(attempts.load(Ordering::Acquire), 1);
    }

    #[tokio::test]
    async fn cancellation_during_restarted_parts_prevents_completion() {
        let cancel = AtomicBool::new(false);
        let completed = AtomicUsize::new(0);
        let cancel = &cancel;
        let completed = &completed;
        let result: Result<(), _> =
            retry_replacement_upload(true, cancel, 0, |attempt| async move {
                if attempt == 0 {
                    return Ok(ReplacementUploadAttempt::RestartRequired(1));
                }
                checked_upload_step(cancel, || async {
                    cancel.store(true, Ordering::Release);
                    Ok(())
                })
                .await?;
                checked_upload_step(cancel, || async {
                    completed.fetch_add(1, Ordering::AcqRel);
                    Ok(ReplacementUploadAttempt::Completed(()))
                })
                .await
            })
            .await;
        assert!(result.unwrap_err().to_string().contains("Export cancelled"));
        assert_eq!(completed.load(Ordering::Acquire), 0);
    }

    fn source() -> ReplacementUploadSource {
        ReplacementUploadSource {
            file: ReplacementUploadFile {
                path: PathBuf::from("export.mp4"),
                size: 6,
                modified: std::time::SystemTime::UNIX_EPOCH,
            },
            chunks: Vec::new(),
            sealed: false,
        }
    }

    fn parts() -> Vec<UploadedPart> {
        (1..=2)
            .map(|part_number| UploadedPart {
                part_number,
                etag: format!("part-{part_number}"),
                size: 3,
                object_identity: None,
            })
            .collect()
    }

    #[test]
    fn restarted_reads_match_the_original_bytes_offsets_and_total() {
        let mut source = source();
        source.check_chunk(1, 0, b"abc", 6).unwrap();
        source.check_chunk(2, 3, b"def", 6).unwrap();
        source.seal_parts(&parts()).unwrap();
        source.check_chunk(1, 0, b"abc", 6).unwrap();
        source.check_chunk(2, 3, b"def", 6).unwrap();
        assert!(source.check_chunk(1, 0, b"abd", 6).is_err());
        assert!(source.check_chunk(1, 1, b"abc", 6).is_err());
        assert!(source.check_chunk(1, 0, b"abc", 7).is_err());
        assert!(source.check_chunk(3, 6, b"ghi", 6).is_err());
        assert!(source.check_chunk(0, 0, b"abc", 6).is_err());
        assert!(source.check_chunk(1, 0, b"", 6).is_err());
    }

    #[test]
    fn completion_requires_the_full_contiguous_original_part_inventory() {
        let mut source = source();
        assert!(source.check_chunk(2, 0, b"abc", 6).is_err());
        source.check_chunk(1, 0, b"abc", 6).unwrap();
        assert!(source.seal_parts(&parts()[..1]).is_err());
        assert!(source.check_chunk(2, 4, b"def", 6).is_err());
        source.check_chunk(2, 3, b"def", 6).unwrap();
        let mut wrong_parts = parts();
        wrong_parts[1].part_number = 1;
        assert!(source.seal_parts(&wrong_parts).is_err());
        wrong_parts[1].part_number = 2;
        wrong_parts[1].size = 2;
        assert!(source.seal_parts(&wrong_parts).is_err());
        source.seal_parts(&parts()).unwrap();
    }

    #[test]
    fn changed_file_metadata_is_rejected_before_a_fresh_initiation() {
        static NEXT_FILE: AtomicUsize = AtomicUsize::new(0);
        let path = std::env::temp_dir().join(format!(
            "cap-gpui-replacement-{}-{}-{}.mp4",
            std::process::id(),
            std::time::SystemTime::now()
                .duration_since(std::time::UNIX_EPOCH)
                .unwrap()
                .as_nanos(),
            NEXT_FILE.fetch_add(1, Ordering::AcqRel),
        ));
        std::fs::write(&path, b"abcdef").unwrap();
        let source = ReplacementUploadSource::new(&path).unwrap();
        source.validate_file(&path).unwrap();
        std::fs::write(&path, b"changed-file").unwrap();
        let changed = source.validate_file(&path);
        std::fs::remove_file(&path).unwrap();
        assert!(
            changed
                .unwrap_err()
                .to_string()
                .contains("Rendered video changed")
        );
    }
}

#[cfg(test)]
mod exported_upload_cancellation_tests {
    use super::*;
    use std::sync::atomic::AtomicUsize;

    #[tokio::test]
    async fn cancelled_export_returns_before_auth_metadata_or_upload_submission() {
        let result = upload_exported_video(
            PathBuf::from("/not-a-recording/cancelled.cap"),
            None,
            |_| panic!("Cancelled export must not start"),
            Arc::new(AtomicBool::new(true)),
        )
        .await;
        assert!(result.unwrap_err().contains("Export cancelled"));
    }

    #[tokio::test]
    async fn cancellation_during_an_inflight_step_prevents_following_complete_submission() {
        let cancel = Arc::new(AtomicBool::new(false));
        let requested = Arc::new(AtomicUsize::new(0));
        let worker_cancel = cancel.clone();
        let worker_requested = requested.clone();
        let (entered, entered_rx) = tokio::sync::oneshot::channel();
        let (release, released) = tokio::sync::oneshot::channel();
        let worker = tokio::spawn(async move {
            checked_upload_step(&worker_cancel, || async {
                entered.send(()).unwrap();
                released.await.unwrap();
                Ok(())
            })
            .await?;
            checked_upload_step(&worker_cancel, || async {
                worker_requested.fetch_add(1, Ordering::AcqRel);
                Ok(())
            })
            .await
        });
        entered_rx.await.unwrap();
        cancel.store(true, Ordering::Release);
        release.send(()).unwrap();
        assert!(
            worker
                .await
                .unwrap()
                .unwrap_err()
                .to_string()
                .contains("Export cancelled")
        );
        assert_eq!(requested.load(Ordering::Acquire), 0);
    }

    #[tokio::test]
    async fn cancellation_while_retry_waits_prevents_retry_and_complete() {
        let cancel = Arc::new(AtomicBool::new(false));
        let attempts = Arc::new(AtomicUsize::new(0));
        let worker_cancel = cancel.clone();
        let worker_attempts = attempts.clone();
        let (waiting, waiting_rx) = tokio::sync::oneshot::channel();
        let (release, released) = tokio::sync::oneshot::channel();
        let worker = tokio::spawn(async move {
            let first = checked_upload_step(&worker_cancel, || async {
                worker_attempts.fetch_add(1, Ordering::AcqRel);
                Err::<(), _>(AuthApiError::Other("network failure".into()))
            })
            .await;
            assert!(first.is_err());
            checked_upload_step(&worker_cancel, || async {
                waiting.send(()).unwrap();
                released.await.unwrap();
                Ok(())
            })
            .await?;
            checked_upload_step(&worker_cancel, || async {
                worker_attempts.fetch_add(1, Ordering::AcqRel);
                Ok(())
            })
            .await
        });
        waiting_rx.await.unwrap();
        cancel.store(true, Ordering::Release);
        release.send(()).unwrap();
        assert!(worker.await.unwrap().is_err());
        assert_eq!(attempts.load(Ordering::Acquire), 1);
    }

    #[tokio::test]
    async fn instant_camera_only_export_observes_the_same_revocation_token() {
        let authorization = CompletionAuthorization::new();
        let control = authorization.control.clone();
        let upload = InstantUpload {
            video: VideoUploadInfo {
                id: "camera-only".into(),
                link: "https://example.invalid/s/camera-only".into(),
                config: S3UploadMeta {
                    id: "camera-only".into(),
                },
            },
            segment_upload: None,
            cancel: control.cancel.clone(),
            metadata_lock: Arc::new(Mutex::new(())),
            completion_permit: Some(authorization.permit),
            completion_control: Some(authorization.control),
            bridge: None,
            ownership: None,
            prior_attempts: 0,
            request_context: None,
            reads: Arc::new(UploadReads::default()),
        };
        let token = upload.cancellation_token();
        assert!(Arc::ptr_eq(&token, &control.cancel));
        control.deny();
        assert!(
            upload_exported_video(PathBuf::new(), None, |_| {}, token)
                .await
                .unwrap_err()
                .contains("Export cancelled")
        );
    }

    #[tokio::test]
    async fn optional_legacy_step_and_uncancelled_export_step_keep_results() {
        assert_eq!(
            optional_upload_step(None, || async { Ok(7) })
                .await
                .unwrap(),
            7
        );
        assert_eq!(
            checked_upload_step(&AtomicBool::new(false), || async { Ok(9) })
                .await
                .unwrap(),
            9
        );
        let result: Result<(), _> = checked_upload_step(&AtomicBool::new(true), || async {
            panic!("No new request may be submitted")
        })
        .await;
        assert!(result.is_err());
    }
}