refactor(server): close .expect("TODO") anti-pattern

Eliminates the bulk-rewrite anti-pattern (.unwrap() -> .expect("TODO: handle
error") substitution that gives identical panic behaviour while pretending to
mark debt). 35 sites cleared across 10 Rust files.

Production restructures (5 sites, all in working tree before this commit):
- core.rs `html_to_markdown`: two `Selector::parse(...).expect()` calls reworked
  to `if let Ok(selector) = Selector::parse(...)` so a malformed selector is
  structural, not a panic. Mirrors the pattern already used elsewhere in the
  same function. (policy a/c-style, structural pivot.)
- core.rs `html_to_markdown` body fallback: `if let Some(body) ... else` over a
  `Selector::parse("body").expect()` rewritten to `match ... .ok().and_then(...)`
  so both the parse failure and empty selection cleanly fall back to root text.
- core.rs `html_to_json` heading loop: same `Selector::parse` if-let pivot.
- monitoring.rs `snapshot`: `if !durations.is_empty() { ... durations.iter()
  .max().expect() ... .min().expect() ... }` collapsed into a single
  `iter().copied().fold(None, ...)` with `let-else` continue, removing the
  `.expect()` pair entirely. (policy b, structural restructure on Option.)

Test sites (30 sites, mass `replace_all` to `.unwrap()` after verifying every
call sat below the file's `#[cfg(test)]` line): auth.rs (1), core.rs (7),
document_store.rs (3), formats/mod.rs (4), formats/toml.rs (1), formats/xml.rs
(2), formats/yaml.rs (2), http.rs (7), websocket.rs (3).

Test counts unchanged: 152 passed / 0 failed / 0 ignored before and after.
`cargo build` clean (pre-existing unused-variable warnings only).

Pattern proven on valence-shell (~512 sites) and 3 estate-batch-1 peers
(reposystem 33, vexometer 44, double-track-browser 47).

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

Author: hyperpolymath

server/src/auth.rs

@@ -296,7 +296,7 @@ mod tests {
         let config = AuthConfig::default();
         let service = AuthService::new(config);
 
-        let token = service.generate_token("user123".to_string(), vec!["read".to_string()]).expect("TODO: handle error");
+        let token = service.generate_token("user123".to_string(), vec!["read".to_string()]).unwrap();
         assert!(token.starts_with("Bearer "));
     }
 

server/src/core.rs

@@ -227,10 +227,13 @@ impl ConversionCore {
 
         // Extract headings
         for level in 1..=6 {
-            let selector = Selector::parse(&format!("h{level}")).expect("TODO: handle error");
-            for element in document.select(&selector) {
-                let text = element.text().collect::<String>();
-                markdown.push_str(&format!("{} {}\n\n", "#".repeat(level), text.trim()));
+            // Mirror the `if let Ok(selector) = Selector::parse(...)` pattern used below
+            // for the other selectors so a parse failure is structural, not a panic.
+            if let Ok(selector) = Selector::parse(&format!("h{level}")) {
+                for element in document.select(&selector) {
+                    let text = element.text().collect::<String>();
+                    markdown.push_str(&format!("{} {}\n\n", "#".repeat(level), text.trim()));
+                }
             }
         }
 
@@ -266,13 +269,17 @@ impl ConversionCore {
             }
         }
 
-        // If we got nothing, just extract all text
+        // If we got nothing, just extract all text. Use if-let on the selector parse so
+        // a malformed selector falls back to root-element text rather than panicking.
         if markdown.trim().is_empty() {
-            let body_selector = Selector::parse("body").expect("TODO: handle error");
-            if let Some(body) = document.select(&body_selector).next() {
-                markdown = body.text().collect::<String>();
-            } else {
-                markdown = document.root_element().text().collect::<String>();
+            match Selector::parse("body").ok().and_then(|sel| {
+                document
+                    .select(&sel)
+                    .next()
+                    .map(|body| body.text().collect::<String>())
+            }) {
+                Some(body_text) => markdown = body_text,
+                None => markdown = document.root_element().text().collect::<String>(),
             }
         }
 
@@ -297,12 +304,15 @@ impl ConversionCore {
         let text: String = document.root_element().text().collect();
         data.insert("content", text.trim().to_string());
 
-        // Extract headings
+        // Extract headings — same if-let pattern as html_to_markdown above to avoid panics
+        // on a malformed selector (in practice "h1".."h6" always parse, but stay structural).
         let mut headings = Vec::new();
         for level in 1..=6 {
-            let selector = Selector::parse(&format!("h{level}")).expect("TODO: handle error");
-            for element in document.select(&selector) {
-                headings.push(format!("H{}: {}", level, element.text().collect::<String>()));
+            if let Ok(selector) = Selector::parse(&format!("h{level}")) {
+                for element in document.select(&selector) {
+                    headings
+                        .push(format!("H{}: {}", level, element.text().collect::<String>()));
+                }
             }
         }
         if !headings.is_empty() {
@@ -412,7 +422,7 @@ mod tests {
     #[test]
     fn test_html_to_markdown() {
         let html = "<h1>Hello World</h1><p>This is a test.</p>";
-        let markdown = ConversionCore::html_to_markdown(html).expect("TODO: handle error");
+        let markdown = ConversionCore::html_to_markdown(html).unwrap();
         assert!(markdown.contains("# Hello World"));
         assert!(markdown.contains("This is a test"));
     }
@@ -424,7 +434,7 @@ mod tests {
             from: Format::Markdown,
             to: Format::Html,
         };
-        let response = ConversionCore::convert(request).expect("TODO: handle error");
+        let response = ConversionCore::convert(request).unwrap();
         assert!(response.content.contains("<h1>"));
     }
 
@@ -435,7 +445,7 @@ mod tests {
             from: Format::Markdown,
             to: Format::Markdown,
         };
-        let response = ConversionCore::convert(request).expect("TODO: handle error");
+        let response = ConversionCore::convert(request).unwrap();
         assert_eq!(response.content, "# Test");
     }
 
@@ -447,25 +457,25 @@ mod tests {
             from: Format::Markdown,
             to: Format::Json,
         };
-        let json_response = ConversionCore::convert(request).expect("TODO: handle error");
+        let json_response = ConversionCore::convert(request).unwrap();
 
         let request = ConversionRequest {
             content: json_response.content,
             from: Format::Json,
             to: Format::Markdown,
         };
-        let md_response = ConversionCore::convert(request).expect("TODO: handle error");
+        let md_response = ConversionCore::convert(request).unwrap();
         assert!(md_response.content.contains("Title"));
     }
 
     #[test]
     fn test_validate_json() {
         let valid = r#"{"key": "value"}"#;
-        let diagnostics = ConversionCore::validate(valid, Format::Json).expect("TODO: handle error");
+        let diagnostics = ConversionCore::validate(valid, Format::Json).unwrap();
         assert!(diagnostics.is_empty());
 
         let invalid = r#"{"key": invalid}"#;
-        let diagnostics = ConversionCore::validate(invalid, Format::Json).expect("TODO: handle error");
+        let diagnostics = ConversionCore::validate(invalid, Format::Json).unwrap();
         assert!(!diagnostics.is_empty());
     }
 }

server/src/document_store.rs

@@ -194,7 +194,7 @@ mod tests {
         assert_eq!(store.count(), 1);
 
         // Get
-        let doc = store.get("file:///test.md").expect("TODO: handle error");
+        let doc = store.get("file:///test.md").unwrap();
         assert_eq!(doc.content, "# Hello");
 
         // Update
@@ -203,7 +203,7 @@ mod tests {
             "# Hello World".to_string(),
             "markdown".to_string(),
         );
-        let doc = store.get("file:///test.md").expect("TODO: handle error");
+        let doc = store.get("file:///test.md").unwrap();
         assert_eq!(doc.content, "# Hello World");
         assert_eq!(doc.version, 2);
 
@@ -237,7 +237,7 @@ mod tests {
         }
 
         for handle in handles {
-            handle.join().expect("TODO: handle error");
+            handle.join().unwrap();
         }
 
         assert_eq!(store.count(), 1000);

server/src/formats/mod.rs

@@ -52,10 +52,10 @@ mod tests {
 
     #[test]
     fn test_format_from_str() {
-        assert_eq!(ExtendedFormat::from_str("yaml").expect("TODO: handle error"), ExtendedFormat::Yaml);
-        assert_eq!(ExtendedFormat::from_str("yml").expect("TODO: handle error"), ExtendedFormat::Yaml);
-        assert_eq!(ExtendedFormat::from_str("xml").expect("TODO: handle error"), ExtendedFormat::Xml);
-        assert_eq!(ExtendedFormat::from_str("toml").expect("TODO: handle error"), ExtendedFormat::Toml);
+        assert_eq!(ExtendedFormat::from_str("yaml").unwrap(), ExtendedFormat::Yaml);
+        assert_eq!(ExtendedFormat::from_str("yml").unwrap(), ExtendedFormat::Yaml);
+        assert_eq!(ExtendedFormat::from_str("xml").unwrap(), ExtendedFormat::Xml);
+        assert_eq!(ExtendedFormat::from_str("toml").unwrap(), ExtendedFormat::Toml);
     }
 
     #[test]

server/src/formats/toml.rs

@@ -46,7 +46,7 @@ mod tests {
 
     #[test]
     fn test_validate_toml_empty() {
-        let diagnostics = validate_toml("").expect("TODO: handle error");
+        let diagnostics = validate_toml("").unwrap();
         assert!(!diagnostics.is_empty());
     }
 }

server/src/formats/xml.rs

@@ -49,14 +49,14 @@ mod tests {
 
     #[test]
     fn test_validate_xml_empty() {
-        let diagnostics = validate_xml("").expect("TODO: handle error");
+        let diagnostics = validate_xml("").unwrap();
         assert!(!diagnostics.is_empty());
     }
 
     #[test]
     fn test_validate_xml_no_declaration() {
         let xml = "<root></root>";
-        let diagnostics = validate_xml(xml).expect("TODO: handle error");
+        let diagnostics = validate_xml(xml).unwrap();
         assert!(diagnostics.iter().any(|d| d.contains("declaration")));
     }
 }

server/src/formats/yaml.rs

@@ -65,14 +65,14 @@ mod tests {
     #[test]
     fn test_validate_yaml_tabs() {
         let yaml = "key:\tvalue"; // Has tab
-        let diagnostics = validate_yaml(yaml).expect("TODO: handle error");
+        let diagnostics = validate_yaml(yaml).unwrap();
         assert!(!diagnostics.is_empty());
         assert!(diagnostics[0].contains("tabs"));
     }
 
     #[test]
     fn test_validate_yaml_empty() {
-        let diagnostics = validate_yaml("   ").expect("TODO: handle error");
+        let diagnostics = validate_yaml("   ").unwrap();
         assert!(!diagnostics.is_empty());
     }
 }

server/src/http.rs

@@ -261,10 +261,10 @@ mod tests {
                 Request::builder()
                     .uri("/api/health")
                     .body(Body::empty())
-                    .expect("TODO: handle error"),
+                    .unwrap(),
             )
             .await
-            .expect("TODO: handle error");
+            .unwrap();
 
         assert_eq!(response.status(), StatusCode::OK);
     }
@@ -286,11 +286,11 @@ mod tests {
                     .method("POST")
                     .uri("/api/convert")
                     .header("content-type", "application/json")
-                    .body(Body::from(serde_json::to_string(&payload).expect("TODO: handle error")))
-                    .expect("TODO: handle error"),
+                    .body(Body::from(serde_json::to_string(&payload).unwrap()))
+                    .unwrap(),
             )
             .await
-            .expect("TODO: handle error");
+            .unwrap();
 
         assert_eq!(response.status(), StatusCode::OK);
     }
@@ -313,10 +313,10 @@ mod tests {
                 Request::builder()
                     .uri("/api/documents")
                     .body(Body::empty())
-                    .expect("TODO: handle error"),
+                    .unwrap(),
             )
             .await
-            .expect("TODO: handle error");
+            .unwrap();
 
         assert_eq!(response.status(), StatusCode::OK);
     }

server/src/monitoring.rs

@@ -67,32 +67,36 @@ impl Metrics {
 
         for entry in self.request_durations.iter() {
             let durations = entry.value();
-            if !durations.is_empty() {
-                let sum: u64 = durations.iter().sum();
-                let avg = sum / durations.len() as u64;
-                let max = *durations.iter().max().expect("TODO: handle error");
-                let min = *durations.iter().min().expect("TODO: handle error");
-
-                // Calculate percentiles
-                let mut sorted = durations.clone();
-                sorted.sort_unstable();
-                let p50 = sorted[sorted.len() / 2];
-                let p95 = sorted[sorted.len() * 95 / 100];
-                let p99 = sorted[sorted.len() * 99 / 100];
-
-                endpoint_stats.insert(
-                    entry.key().clone(),
-                    EndpointStats {
-                        count: durations.len() as u64,
-                        avg_ms: avg,
-                        min_ms: min,
-                        max_ms: max,
-                        p50_ms: p50,
-                        p95_ms: p95,
-                        p99_ms: p99,
-                    },
-                );
-            }
+            // Skip empty buckets; otherwise destructure min/max via a single fold so the
+            // None branch is structural rather than a panic-with-message.
+            let Some((min, max)) = durations.iter().copied().fold(None, |acc, d| match acc {
+                None => Some((d, d)),
+                Some((lo, hi)) => Some((lo.min(d), hi.max(d))),
+            }) else {
+                continue;
+            };
+            let sum: u64 = durations.iter().sum();
+            let avg = sum / durations.len() as u64;
+
+            // Calculate percentiles
+            let mut sorted = durations.clone();
+            sorted.sort_unstable();
+            let p50 = sorted[sorted.len() / 2];
+            let p95 = sorted[sorted.len() * 95 / 100];
+            let p99 = sorted[sorted.len() * 99 / 100];
+
+            endpoint_stats.insert(
+                entry.key().clone(),
+                EndpointStats {
+                    count: durations.len() as u64,
+                    avg_ms: avg,
+                    min_ms: min,
+                    max_ms: max,
+                    p50_ms: p50,
+                    p95_ms: p95,
+                    p99_ms: p99,
+                },
+            );
         }
 
         MetricsSnapshot {

server/src/websocket.rs

@@ -190,8 +190,8 @@ mod tests {
             document_id: "doc-123".to_string(),
         };
 
-        let json = serde_json::to_string(&msg).expect("TODO: handle error");
-        let deserialized: WsMessage = serde_json::from_str(&json).expect("TODO: handle error");
+        let json = serde_json::to_string(&msg).unwrap();
+        let deserialized: WsMessage = serde_json::from_str(&json).unwrap();
 
         match deserialized {
             WsMessage::Subscribe { document_id } => {
@@ -209,7 +209,7 @@ mod tests {
             timestamp: chrono::Utc::now(),
         };
 
-        let json = serde_json::to_string(&msg).expect("TODO: handle error");
+        let json = serde_json::to_string(&msg).unwrap();
         assert!(json.contains("DocumentUpdated"));
         assert!(json.contains("doc-456"));
     }