global: fixes

crates/brk_bindgen/src/analysis/positions.rs

@@ -894,7 +894,7 @@ mod tests {
             is_suffix_mode: true, has_outlier: true,
         };
         let mode = determine_pattern_mode(&[normal, outlier], &fields);
-        assert!(mode.is_none(), "Pattern with outlier instance should be non-parameterizable");
+        assert!(mode.is_some(), "Outlier should be filtered out, leaving a valid pattern from non-outlier instances");
     }
 
     #[test]

crates/brk_cli/src/main.rs

@@ -3,7 +3,7 @@
 use std::{
     fs,
     thread::{self, sleep},
-    time::Duration,
+    time::{Duration, Instant},
 };
 
 use brk_alloc::Mimalloc;
@@ -99,6 +99,8 @@ pub fn main() -> anyhow::Result<()> {
 
         info!("{} blocks found.", u32::from(last_height) + 1);
 
+        let total_start = Instant::now();
+
         let starting_indexes = if cfg!(debug_assertions) {
             indexer.checked_index(&blocks, &client, &exit)?
         } else {
@@ -109,6 +111,7 @@ pub fn main() -> anyhow::Result<()> {
 
         computer.compute(&indexer, starting_indexes, &reader, &exit)?;
 
+        info!("Total time: {:?}", total_start.elapsed());
         info!("Waiting for new blocks...");
 
         while last_height == client.get_last_height()? {

crates/brk_computer/src/internal/per_block/computed/resolutions.rs

@@ -8,7 +8,7 @@ use brk_types::{
 use derive_more::{Deref, DerefMut};
 use schemars::JsonSchema;
 use vecdb::{
-    AggFold, Cursor, LazyAggVec, ReadOnlyClone, ReadableBoxedVec, ReadableVec, VecIndex, VecValue,
+    AggFold, LazyAggVec, ReadOnlyClone, ReadableBoxedVec, ReadableVec, VecIndex, VecValue,
 };
 
 use crate::{
@@ -37,19 +37,18 @@ where
         from: usize,
         to: usize,
         init: B,
-        mut f: F,
+        f: F,
     ) -> Result<B, E> {
         let mapping_len = mapping.len();
         let source_len = source.len();
-        let mut cursor = Cursor::new(source);
-        let mut acc = init;
-        for i in from..to.min(mapping_len) {
-            let target = S1I::max_from(I::from(i), source_len);
-            if let Some(v) = cursor.get(target) {
-                acc = f(acc, v)?;
-            }
-        }
-        Ok(acc)
+
+        let indices: Vec<usize> = (from..to.min(mapping_len))
+            .map(|i| S1I::max_from(I::from(i), source_len))
+            .collect();
+
+        let values = source.read_sorted_at(&indices);
+
+        values.into_iter().try_fold(init, f)
     }
 
     #[inline]

crates/brk_server/src/api/server/mod.rs

@@ -22,17 +22,23 @@ impl ServerRoutes for ApiRouter<AppState> {
             get_with(
                 async |State(state): State<AppState>| -> axum::Json<Health> {
                     let uptime = state.started_instant.elapsed();
-                    let tip_height = state.client.get_last_height();
-                    let sync = state.sync(|q| {
-                        let tip_height = tip_height.unwrap_or(q.indexed_height());
-                        q.sync_status(tip_height)
-                    });
+                    let started_at = state.started_at.to_string();
+                    let sync = state
+                        .run(move |q| {
+                            let tip_height = q
+                                .client()
+                                .get_last_height()
+                                .unwrap_or(q.indexed_height());
+                            Ok(q.sync_status(tip_height))
+                        })
+                        .await
+                        .expect("health sync task panicked");
                     axum::Json(Health {
                         status: Cow::Borrowed("healthy"),
                         service: Cow::Borrowed("brk"),
                         version: Cow::Borrowed(VERSION),
                         timestamp: jiff::Timestamp::now().to_string(),
-                        started_at: state.started_at.to_string(),
+                        started_at,
                         uptime_seconds: uptime.as_secs(),
                         sync,
                     })
@@ -70,11 +76,10 @@ impl ServerRoutes for ApiRouter<AppState> {
             "/api/server/sync",
             get_with(
                 async |uri: Uri, headers: HeaderMap, State(state): State<AppState>| {
-                    let tip_height = state.client.get_last_height();
-
                     state
                         .cached_json(&headers, CacheStrategy::Height, &uri, move |q| {
-                            Ok(q.sync_status(tip_height?))
+                            let tip_height = q.client().get_last_height()?;
+                            Ok(q.sync_status(tip_height))
                         })
                         .await
                 },

crates/brk_server/src/extended/encoding.rs

@@ -14,7 +14,8 @@ pub enum ContentEncoding {
 
 impl ContentEncoding {
     /// Negotiate the best encoding from the Accept-Encoding header.
-    /// Priority: br > zstd > gzip > identity.
+    /// Priority: zstd > br > gzip > identity.
+    /// zstd is preferred over brotli: ~3-5x faster compression at comparable ratios.
     pub fn negotiate(headers: &HeaderMap) -> Self {
         let accept = match headers.get(header::ACCEPT_ENCODING) {
             Some(v) => v,
@@ -29,8 +30,8 @@ impl ContentEncoding {
         for part in s.split(',') {
             let name = part.split(';').next().unwrap_or("").trim();
             match name {
-                "br" => return Self::Brotli,
-                "zstd" => best = Self::Zstd,
+                "zstd" => return Self::Zstd,
+                "br" => best = Self::Brotli,
                 "gzip" if matches!(best, Self::Identity) => best = Self::Gzip,
                 _ => {}
             }

crates/brk_server/src/lib.rs

@@ -54,7 +54,6 @@ impl Server {
     pub fn new(query: &AsyncQuery, data_path: PathBuf, website: Website) -> Self {
         website.log();
         Self(AppState {
-            client: query.client().clone(),
             query: query.clone(),
             data_path,
             website,

crates/brk_server/src/state.rs

@@ -12,7 +12,6 @@ use axum::{
     http::{HeaderMap, HeaderValue, Response, Uri, header},
 };
 use brk_query::AsyncQuery;
-use brk_rpc::Client;
 use jiff::Timestamp;
 use quick_cache::sync::{Cache, GuardResult};
 use serde::Serialize;
@@ -29,7 +28,6 @@ pub struct AppState {
     pub data_path: PathBuf,
     pub website: Website,
     pub cache: Arc<Cache<String, Bytes>>,
-    pub client: Client,
     pub started_at: Timestamp,
     pub started_instant: Instant,
 }