feat: streaming ecash payments + media playback overhaul

Cashu ecash protocol (BDHKE blind signatures, cashuA token format,
mint HTTP client) replacing the stub wallet. TollGate-inspired streaming
data payment system with step-based pricing (bytes/time/requests),
session management with incremental top-ups, usage metering, and
Nostr kind 10021 service advertisements.

13 new streaming.* RPC endpoints. Content server now verifies real
Cashu tokens. Profits tracking includes streaming revenue.

Frontend: GlobalAudioPlayer (persistent bottom bar across all pages),
video lightbox with full controls, audio in MediaLightbox, free file
previews (no blur), paid 10% audio/video previews, separated play
vs download buttons in PeerFiles.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

core/archipelago/src/content_server.rs

@@ -309,23 +309,99 @@ pub async fn serve_content(
     Ok(ServeResult::Ok(bytes, item.mime_type.clone()))
 }
 
-/// Verify a payment token covers the required amount.
-/// Tokens are ecash strings that we validate and mark as spent.
-async fn verify_payment_token(data_dir: &Path, token: &str, required_sats: u64) -> bool {
-    // Parse cashu token format to verify amount
-    if token.starts_with("cashuSend_") {
-        let amount = token
-            .split('_')
-            .nth(1)
-            .and_then(|s| s.parse::<u64>().ok())
-            .unwrap_or(0);
-        if amount >= required_sats {
-            // Record the payment (receive the token into our wallet)
-            if let Ok(wallet_mod) = crate::wallet::ecash::receive_token(data_dir, token).await {
-                debug!("Payment verified: {} sats for {} required", wallet_mod, required_sats);
-                return true;
+/// Result of attempting to serve a preview.
+pub enum PreviewResult {
+    /// Full content (free/peers-only items — redirect to normal serve).
+    FullContent(Vec<u8>, String),
+    /// Blurred preview for paid image (full bytes, frontend applies blur).
+    BlurPreview(Vec<u8>, String),
+    /// Truncated preview for paid video (first ~2% of bytes).
+    TruncatedPreview(Vec<u8>, String, u64),
+    /// Content not found.
+    NotFound,
+}
+
+/// Serve a preview of content by ID. For paid content, returns degraded previews:
+/// - Images: full file with X-Content-Preview: blur (frontend applies CSS blur)
+/// - Videos: first 2% of file bytes (minimum 512KB for codec headers)
+/// - Other: not available
+/// For free/peers-only content, returns the full file.
+pub async fn serve_content_preview(
+    data_dir: &Path,
+    id: &str,
+) -> Result<PreviewResult> {
+    let catalog = load_catalog(data_dir).await?;
+    let item = match catalog.items.iter().find(|i| i.id == id) {
+        Some(i) => i,
+        None => return Ok(PreviewResult::NotFound),
+    };
+
+    // Check availability — don't preview hidden items
+    if matches!(item.availability, Availability::Nobody) {
+        return Ok(PreviewResult::NotFound);
+    }
+
+    let file_path = content_file_path(data_dir, item);
+    if !file_path.exists() {
+        return Ok(PreviewResult::NotFound);
+    }
+
+    match &item.access {
+        AccessControl::Paid { .. } => {
+            let mime = &item.mime_type;
+            if mime.starts_with("image/") {
+                // Serve full image — frontend applies CSS blur
+                let bytes = fs::read(&file_path).await.context("Failed to read preview file")?;
+                debug!("Serving blur preview for paid image '{}' ({} bytes)", id, bytes.len());
+                Ok(PreviewResult::BlurPreview(bytes, item.mime_type.clone()))
+            } else if mime.starts_with("video/") || mime.starts_with("audio/") {
+                // Serve first 10% of video/audio, minimum 512KB for codec headers
+                let metadata = fs::metadata(&file_path).await.context("Failed to read file metadata")?;
+                let total_size = metadata.len();
+                let preview_bytes = ((total_size * 10) / 100).max(512 * 1024).min(total_size);
+
+                use tokio::io::AsyncReadExt;
+                let mut file = tokio::fs::File::open(&file_path).await.context("Failed to open file")?;
+                let mut buf = vec![0u8; preview_bytes as usize];
+                file.read_exact(&mut buf).await.context("Failed to read preview bytes")?;
+
+                let kind = if mime.starts_with("video/") { "video" } else { "audio" };
+                debug!("Serving truncated preview for paid {} '{}' ({}/{} bytes)", kind, id, preview_bytes, total_size);
+                Ok(PreviewResult::TruncatedPreview(buf, item.mime_type.clone(), total_size))
+            } else {
+                // Non-media paid content — no preview available
+                Ok(PreviewResult::NotFound)
             }
         }
+        _ => {
+            // Free or peers-only — serve full content as preview
+            let bytes = fs::read(&file_path).await.context("Failed to read content file")?;
+            Ok(PreviewResult::FullContent(bytes, item.mime_type.clone()))
+        }
+    }
+}
+
+/// Verify a payment token covers the required amount.
+/// Accepts both cashuA tokens (real Cashu) and legacy cashuSend_ format.
+/// Swaps proofs at the mint to verify they're unspent before accepting.
+async fn verify_payment_token(data_dir: &Path, token: &str, required_sats: u64) -> bool {
+    match crate::wallet::ecash::verify_and_receive_payment(data_dir, token, required_sats).await {
+        Ok(received) => {
+            debug!(
+                "Payment verified: {} sats received for {} required",
+                received, required_sats
+            );
+            // Record the content sale for profit tracking
+            if let Err(e) =
+                crate::wallet::profits::record_content_sale(data_dir, received, "Content download payment").await
+            {
+                debug!("Failed to record content sale profit (non-fatal): {}", e);
+            }
+            true
+        }
+        Err(e) => {
+            debug!("Payment verification failed: {}", e);
+            false
+        }
     }
-    false
 }