add shareable search results via query parameters

implements GET /api/search endpoint alongside existing POST endpoint,
enabling users to share search results via URL.

backend changes:
- refactor search logic into shared perform_search function
- add search_get handler for GET /api/search?query=...&top_k=...
- implement HTTP caching with ETag and Cache-Control headers
- ETag based on query hash enables 304 Not Modified responses
- 5-minute cache TTL balances freshness vs performance

frontend changes:
- update URL params when search is submitted (?q=...&top_k=...)
- auto-execute search on page load if URL contains query params
- support browser back/forward navigation with popstate
- migrate from POST to GET for all searches

caching strategy:
- browser caches results for 5 minutes using Cache-Control
- ETag validation prevents redundant data transfer
- results may be stale if new bufos ingested, but TTL is short

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <[e-mail]>

src/main.rs

···
                 web::scope("/api")
                     .wrap(Governor::new(&governor_conf))
                     .route("/search", web::post().to(search::search))
+                    .route("/search", web::get().to(search::search_get))
                     .route("/health", web::get().to(|| async { HttpResponse::Ok().body("ok") }))
             )
             .service(fs::Files::new("/static", "./static").show_files_listing())

src/search.rs

···
 use crate::config::Config;
 use crate::embedding::EmbeddingClient;
 use crate::turbopuffer::{QueryRequest, TurbopufferClient};
-use actix_web::{web, HttpResponse, Result as ActixResult};
+use actix_web::{web, HttpRequest, HttpResponse, Result as ActixResult};
 use serde::{Deserialize, Serialize};
+use std::collections::hash_map::DefaultHasher;
+use std::hash::{Hash, Hasher};
 
 #[derive(Debug, Deserialize)]
 pub struct SearchQuery {
···
     pub score: f32, // normalized 0-1 score for display
 }
 
-pub async fn search(
-    query: web::Json<SearchQuery>,
-    config: web::Data<Config>,
-) -> ActixResult<HttpResponse> {
-    let query_text = query.query.clone();
-    let top_k_val = query.top_k;
+/// generate etag for caching based on query parameters
+fn generate_etag(query: &str, top_k: usize) -> String {
+    let mut hasher = DefaultHasher::new();
+    query.hash(&mut hasher);
+    top_k.hash(&mut hasher);
+    format!("\"{}\"", hasher.finish())
+}
+
+/// shared search implementation used by both POST and GET handlers
+async fn perform_search(
+    query_text: String,
+    top_k_val: usize,
+    config: &Config,
+) -> ActixResult<SearchResponse> {
 
     let _search_span = logfire::span!(
         "bufo_search",
···
             serde_json::json!("ANN"),
             serde_json::json!(query_embedding),
         ],
-        top_k: query.top_k,
+        top_k: top_k_val,
         include_attributes: Some(vec!["url".to_string(), "name".to_string(), "filename".to_string()]),
     };
 
···
         avg_score = avg_score_val
     );
 
-    Ok(HttpResponse::Ok().json(SearchResponse { results }))
+    Ok(SearchResponse { results })
+}
+
+/// POST /api/search handler (existing API)
+pub async fn search(
+    query: web::Json<SearchQuery>,
+    config: web::Data<Config>,
+) -> ActixResult<HttpResponse> {
+    let response = perform_search(query.query.clone(), query.top_k, &config).await?;
+    Ok(HttpResponse::Ok().json(response))
+}
+
+/// GET /api/search handler for shareable URLs
+pub async fn search_get(
+    query: web::Query<SearchQuery>,
+    config: web::Data<Config>,
+    req: HttpRequest,
+) -> ActixResult<HttpResponse> {
+    // generate etag for caching
+    let etag = generate_etag(&query.query, query.top_k);
+
+    // check if client has cached version
+    if let Some(if_none_match) = req.headers().get("if-none-match") {
+        if if_none_match.to_str().unwrap_or("") == etag {
+            return Ok(HttpResponse::NotModified()
+                .insert_header(("etag", etag))
+                .finish());
+        }
+    }
+
+    let response = perform_search(query.query.clone(), query.top_k, &config).await?;
+
+    Ok(HttpResponse::Ok()
+        .insert_header(("etag", etag.clone()))
+        .insert_header(("cache-control", "public, max-age=300")) // cache for 5 minutes
+        .json(response))
 }

static/index.html

···
 
         let hasSearched = false;
 
-        async function search() {
+        async function search(updateUrl = true) {
             const query = searchInput.value.trim();
             if (!query) return;
 
···
             if (!hasSearched) {
                 peekingBufo.classList.add('hidden');
                 hasSearched = true;
+            }
+
+            // update url with query parameters for sharing
+            if (updateUrl) {
+                const params = new URLSearchParams();
+                params.set('q', query);
+                params.set('top_k', '20');
+                const newUrl = `${window.location.pathname}?${params.toString()}`;
+                window.history.pushState({ query }, '', newUrl);
             }
 
             searchButton.disabled = true;
···
             errorDiv.style.display = 'none';
 
             try {
-                const response = await fetch('/api/search', {
-                    method: 'POST',
+                const params = new URLSearchParams();
+                params.set('query', query);
+                params.set('top_k', '20');
+
+                const response = await fetch(`/api/search?${params.toString()}`, {
+                    method: 'GET',
                     headers: {
-                        'Content-Type': 'application/json',
+                        'Accept': 'application/json',
                     },
-                    body: JSON.stringify({ query, top_k: 20 }),
                 });
 
                 if (!response.ok) {
···
             });
         }
 
-        searchButton.addEventListener('click', search);
+        searchButton.addEventListener('click', () => search(true));
         searchInput.addEventListener('keypress', (e) => {
-            if (e.key === 'Enter') search();
+            if (e.key === 'Enter') search(true);
+        });
+
+        // handle browser back/forward
+        window.addEventListener('popstate', (e) => {
+            if (e.state && e.state.query) {
+                searchInput.value = e.state.query;
+                search(false);
+            }
+        });
+
+        // auto-execute search if url has query params (for shared links)
+        window.addEventListener('DOMContentLoaded', () => {
+            const params = new URLSearchParams(window.location.search);
+            const query = params.get('q');
+            if (query) {
+                searchInput.value = query;
+                search(false); // don't update URL since we're already loading from it
+            }
         });
     </script>
 </body>