Checkpoint all changes

server-rs/src/routes/features.rs

@@ -5,6 +5,7 @@ use serde::Serialize;
 use tracing::info;
 
 use crate::data::Histogram;
+use crate::features::{ENUM_FEATURE_GROUPS, FEATURE_GROUPS};
 use crate::state::AppState;
 
 #[derive(Serialize)]
@@ -13,75 +14,123 @@ pub enum FeatureInfo {
     #[serde(rename = "numeric")]
     Numeric {
         name: String,
-        label: String,
         min: f64,
         max: f64,
+        step: f64,
         histogram: Histogram,
+        description: &'static str,
+        detail: &'static str,
+        source: &'static str,
     },
     #[serde(rename = "enum")]
     Enum {
         name: String,
-        label: String,
         values: Vec<String>,
+        description: &'static str,
+        detail: &'static str,
+        source: &'static str,
     },
 }
 
 #[derive(Serialize)]
-pub struct FeaturesResponse {
+pub struct FeatureGroupResponse {
+    name: String,
     features: Vec<FeatureInfo>,
 }
 
-fn snake_to_label(name: &str) -> String {
-    // If name contains '/' or uppercase, assume it's already human-readable
-    if name.contains('/') || name.chars().any(|c| c.is_uppercase()) {
-        return name.to_string();
-    }
-    name.split('_')
-        .map(|word| {
-            let mut chars = word.chars();
-            match chars.next() {
-                None => String::new(),
-                Some(c) => {
-                    let mut s = c.to_uppercase().to_string();
-                    s.extend(chars);
-                    s
-                }
-            }
-        })
-        .collect::<Vec<_>>()
-        .join(" ")
+#[derive(Serialize)]
+pub struct FeaturesResponse {
+    groups: Vec<FeatureGroupResponse>,
 }
 
 pub async fn get_features(state: Arc<AppState>) -> Json<FeaturesResponse> {
-    let mut features: Vec<FeatureInfo> = state
-        .data
-        .feature_names
-        .iter()
-        .enumerate()
-        .map(|(i, name): (usize, &String)| {
-            let stats = &state.data.feature_stats[i];
-            FeatureInfo::Numeric {
-                name: name.clone(),
-                label: snake_to_label(name),
-                min: stats.p_low,
-                max: stats.p_high,
-                histogram: stats.histogram.clone(),
-            }
-        })
-        .collect();
-
-    for ef in &state.data.enum_features {
-        features.push(FeatureInfo::Enum {
-            name: ef.name.clone(),
-            label: snake_to_label(&ef.name),
-            values: ef.values.clone(),
-        });
+    // Collect all group names in order, merging numeric and enum groups with the same name
+    let mut group_names: Vec<&str> = Vec::new();
+    for feature_group in FEATURE_GROUPS {
+        if !group_names.contains(&feature_group.name) {
+            group_names.push(feature_group.name);
+        }
+    }
+    for enum_group in ENUM_FEATURE_GROUPS {
+        if !group_names.contains(&enum_group.name) {
+            group_names.push(enum_group.name);
+        }
     }
 
+    let mut groups: Vec<FeatureGroupResponse> = Vec::new();
+
+    for &group_name in &group_names {
+        let mut features: Vec<FeatureInfo> = Vec::new();
+
+        // Add numeric features for this group
+        for feature_group in FEATURE_GROUPS {
+            if feature_group.name == group_name {
+                for feature_config in feature_group.features {
+                    if let Some(feat_idx) =
+                        state.data.feature_names.iter().position(|feat_name| feat_name == feature_config.name)
+                    {
+                        let stats = &state.data.feature_stats[feat_idx];
+                        features.push(FeatureInfo::Numeric {
+                            name: feature_config.name.to_string(),
+                            min: stats.slider_min,
+                            max: stats.slider_max,
+                            step: feature_config.step,
+                            histogram: stats.histogram.clone(),
+                            description: feature_config.description,
+                            detail: feature_config.detail,
+                            source: feature_config.source,
+                        });
+                    }
+                }
+            }
+        }
+
+        // Add enum features for this group
+        for enum_group in ENUM_FEATURE_GROUPS {
+            if enum_group.name == group_name {
+                for enum_config in enum_group.features {
+                    if let Some(enum_feature) = state
+                        .data
+                        .enum_features
+                        .iter()
+                        .find(|enum_feat| enum_feat.name == enum_config.name)
+                    {
+                        features.push(FeatureInfo::Enum {
+                            name: enum_config.name.to_string(),
+                            values: enum_feature.values.clone(),
+                            description: enum_config.description,
+                            detail: enum_config.detail,
+                            source: enum_config.source,
+                        });
+                    }
+                }
+            }
+        }
+
+        if !features.is_empty() {
+            groups.push(FeatureGroupResponse {
+                name: group_name.to_string(),
+                features,
+            });
+        }
+    }
+
+    let num_numeric: usize = groups
+        .iter()
+        .flat_map(|group| &group.features)
+        .filter(|feature| matches!(feature, FeatureInfo::Numeric { .. }))
+        .count();
+    let num_enum: usize = groups
+        .iter()
+        .flat_map(|group| &group.features)
+        .filter(|feature| matches!(feature, FeatureInfo::Enum { .. }))
+        .count();
+
     info!(
-        numeric = features.iter().filter(|f| matches!(f, FeatureInfo::Numeric { .. })).count(),
-        enums = features.iter().filter(|f| matches!(f, FeatureInfo::Enum { .. })).count(),
+        numeric = num_numeric,
+        enums = num_enum,
+        groups = groups.len(),
         "GET /api/features"
     );
-    Json(FeaturesResponse { features })
+    Json(FeaturesResponse { groups })
 }

server-rs/src/routes/hexagon_stats.rs

@@ -0,0 +1,251 @@
+use std::fmt::Write;
+use std::str::FromStr;
+use std::sync::Arc;
+
+use axum::extract::Query;
+use axum::http::StatusCode;
+use axum::response::IntoResponse;
+use serde::Deserialize;
+use tracing::{info, warn};
+
+use crate::consts::{ENUM_NULL, HISTOGRAM_BINS};
+use crate::filter::{parse_filters, row_passes_filters};
+use crate::state::AppState;
+
+use super::parse::h3_cell_bounds;
+
+#[derive(Deserialize)]
+pub struct HexagonStatsParams {
+    pub h3: String,
+    pub resolution: u8,
+    pub filters: Option<String>,
+}
+
+pub async fn get_hexagon_stats(
+    state: Arc<AppState>,
+    Query(params): Query<HexagonStatsParams>,
+) -> Result<impl IntoResponse, (StatusCode, String)> {
+    let cell = h3o::CellIndex::from_str(&params.h3).map_err(|error| {
+        warn!(h3 = %params.h3, error = %error, "Invalid H3 cell index");
+        (StatusCode::BAD_REQUEST, format!("Invalid H3 cell: {}", error))
+    })?;
+    let cell_u64: u64 = cell.into();
+
+    let resolution = params.resolution as usize;
+    if resolution >= state.h3_cells.len() || state.h3_cells[resolution].is_empty() {
+        warn!(
+            resolution,
+            "Invalid or non-precomputed resolution for hexagon-stats"
+        );
+        return Err((
+            StatusCode::BAD_REQUEST,
+            "Invalid or non-precomputed resolution".to_string(),
+        ));
+    }
+
+    let h3_str = params.h3.clone();
+    let filters_str = params.filters.clone();
+    let (parsed_filters, parsed_enum_filters) = parse_filters(
+        params.filters.as_deref(),
+        &state.data.feature_names,
+        &state.data.enum_features,
+    );
+    let num_filters = parsed_filters.len() + parsed_enum_filters.len();
+
+    let result = tokio::task::spawn_blocking(move || {
+        let start_time = std::time::Instant::now();
+        let h3_data = &state.h3_cells[resolution];
+        let num_features = state.data.num_features;
+        let feature_data = &state.data.feature_data;
+        let enum_features = &state.data.enum_features;
+
+        let (min_lat, min_lon, max_lat, max_lon) = h3_cell_bounds(cell, 0.001);
+
+        // Collect matching rows
+        let mut matching_rows: Vec<usize> = Vec::new();
+        state
+            .grid
+            .for_each_in_bounds(min_lat, min_lon, max_lat, max_lon, |row_idx| {
+                let row = row_idx as usize;
+                if h3_data[row] == cell_u64
+                    && row_passes_filters(
+                        row,
+                        &parsed_filters,
+                        &parsed_enum_filters,
+                        feature_data,
+                        num_features,
+                        enum_features,
+                    )
+                {
+                    matching_rows.push(row);
+                }
+            });
+
+        let total_count = matching_rows.len();
+
+        // Build JSON directly via string buffer
+        let mut output = String::with_capacity(4096);
+        output.push_str("{\"count\":");
+        write!(output, "{}", total_count).unwrap();
+
+        // Numeric features: compute count, min, max, sum, histogram using global bin edges
+        output.push_str(",\"numeric_features\":[");
+        let mut first_numeric = true;
+        for (feature_index, feature_name) in state.data.feature_names.iter().enumerate() {
+            let global_stats = &state.data.feature_stats[feature_index];
+            let histogram_min = global_stats.histogram.min;
+            let histogram_max = global_stats.histogram.max;
+            let bin_width = global_stats.histogram.bin_width;
+
+            let mut count = 0usize;
+            let mut min_value = f64::INFINITY;
+            let mut max_value = f64::NEG_INFINITY;
+            let mut sum = 0.0f64;
+            let mut bins = vec![0u64; HISTOGRAM_BINS];
+
+            for &row in &matching_rows {
+                let value = feature_data[row * num_features + feature_index];
+                if value.is_finite() {
+                    count += 1;
+                    if value < min_value {
+                        min_value = value;
+                    }
+                    if value > max_value {
+                        max_value = value;
+                    }
+                    sum += value;
+
+                    // Bin into histogram using global edges
+                    if bin_width > 0.0 {
+                        let bin_index =
+                            ((value - histogram_min) / bin_width).floor() as isize;
+                        let clamped_index = bin_index.max(0).min((HISTOGRAM_BINS - 1) as isize) as usize;
+                        bins[clamped_index] += 1;
+                    }
+                }
+            }
+
+            if count == 0 {
+                continue;
+            }
+
+            if !first_numeric {
+                output.push(',');
+            }
+            first_numeric = false;
+
+            let mean = sum / count as f64;
+            output.push_str("{\"name\":");
+            write_json_string(&mut output, feature_name);
+            write!(output, ",\"count\":{}", count).unwrap();
+            write!(output, ",\"min\":{}", format_f64(min_value)).unwrap();
+            write!(output, ",\"max\":{}", format_f64(max_value)).unwrap();
+            write!(output, ",\"mean\":{}", format_f64(mean)).unwrap();
+            output.push_str(",\"histogram\":{\"min\":");
+            write!(output, "{}", format_f64(histogram_min)).unwrap();
+            output.push_str(",\"max\":");
+            write!(output, "{}", format_f64(histogram_max)).unwrap();
+            output.push_str(",\"bin_width\":");
+            write!(output, "{}", format_f64(bin_width)).unwrap();
+            output.push_str(",\"counts\":[");
+            for (bin_index, &bin_count) in bins.iter().enumerate() {
+                if bin_index > 0 {
+                    output.push(',');
+                }
+                write!(output, "{}", bin_count).unwrap();
+            }
+            output.push_str("]}}")
+        }
+
+        // Enum features: count per value
+        output.push_str("],\"enum_features\":[");
+        let mut first_enum = true;
+        for enum_feature in enum_features {
+            let enum_index = match state.enum_name_to_idx.get(&enum_feature.name) {
+                Some(&index) => index,
+                None => continue,
+            };
+            let enum_data = &state.data.enum_features[enum_index];
+
+            let mut value_counts = vec![0u64; enum_data.values.len()];
+            for &row in &matching_rows {
+                let value = enum_data.data[row];
+                if value != ENUM_NULL && (value as usize) < value_counts.len() {
+                    value_counts[value as usize] += 1;
+                }
+            }
+
+            // Only include if there are any non-zero counts
+            let has_values = value_counts.iter().any(|&count| count > 0);
+            if !has_values {
+                continue;
+            }
+
+            if !first_enum {
+                output.push(',');
+            }
+            first_enum = false;
+
+            output.push_str("{\"name\":");
+            write_json_string(&mut output, &enum_feature.name);
+            output.push_str(",\"counts\":{");
+            let mut first_value = true;
+            for (value_index, &count) in value_counts.iter().enumerate() {
+                if count == 0 {
+                    continue;
+                }
+                if !first_value {
+                    output.push(',');
+                }
+                first_value = false;
+                write_json_string(&mut output, &enum_data.values[value_index]);
+                write!(output, ":{}", count).unwrap();
+            }
+            output.push_str("}}");
+        }
+        output.push_str("]}");
+
+        let elapsed = start_time.elapsed();
+        info!(
+            h3 = %h3_str,
+            resolution,
+            total_count,
+            filters = num_filters,
+            filters_raw = filters_str.as_deref().unwrap_or("-"),
+            ms = format_args!("{:.1}", elapsed.as_secs_f64() * 1000.0),
+            "GET /api/hexagon-stats"
+        );
+
+        output
+    })
+    .await
+    .map_err(|error| (StatusCode::INTERNAL_SERVER_ERROR, error.to_string()))?;
+
+    Ok((
+        [(axum::http::header::CONTENT_TYPE, "application/json")],
+        result,
+    ))
+}
+
+fn write_json_string(output: &mut String, value: &str) {
+    output.push('"');
+    for character in value.chars() {
+        match character {
+            '"' => output.push_str("\\\""),
+            '\\' => output.push_str("\\\\"),
+            '\n' => output.push_str("\\n"),
+            '\r' => output.push_str("\\r"),
+            '\t' => output.push_str("\\t"),
+            other => output.push(other),
+        }
+    }
+    output.push('"');
+}
+
+fn format_f64(value: f64) -> String {
+    if value.fract() == 0.0 && value.abs() < 1e15 {
+        format!("{:.1}", value)
+    } else {
+        format!("{}", value)
+    }
+}

server-rs/src/routes/hexagons.rs

@@ -1,4 +1,4 @@
-use std::fmt::Write;
+use std::fmt::{self, Write};
 use std::sync::Arc;
 
 use axum::extract::Query;
@@ -8,11 +8,29 @@ use rustc_hash::FxHashMap;
 use serde::Deserialize;
 use tracing::{info, warn};
 
-use crate::consts::{H3_PRECOMPUTE_MAX, H3_PRECOMPUTE_MIN};
+use crate::consts::{
+    BOUNDS_BUFFER_PERCENT, BOUNDS_QUANTIZATION, ENUM_NULL, H3_PRECOMPUTE_MAX, H3_PRECOMPUTE_MIN,
+    POSTCODE_MIN_RESOLUTION,
+};
 use crate::filter::parse_filters;
 use crate::state::AppState;
 
-const BOUNDS_BUFFER_PERCENT: f64 = 0.2;
+use super::parse::parse_bounds;
+
+struct HumanBytes(usize);
+
+impl fmt::Display for HumanBytes {
+    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let bytes = self.0;
+        if bytes >= 1_000_000 {
+            write!(formatter, "{:.1} MB", bytes as f64 / 1_000_000.0)
+        } else if bytes >= 1_000 {
+            write!(formatter, "{:.1} KB", bytes as f64 / 1_000.0)
+        } else {
+            write!(formatter, "{} B", bytes)
+        }
+    }
+}
 
 #[derive(Deserialize)]
 pub struct HexagonParams {
@@ -28,14 +46,28 @@ struct CellAgg {
     count: u32,
     mins: Vec<f64>,
     maxs: Vec<f64>,
+    /// Min/max ordinal indices for enum features (255 = no data yet)
+    enum_mins: Vec<u8>,
+    enum_maxs: Vec<u8>,
+    /// Most common postcode in this cell (only tracked at high resolutions)
+    postcode: Option<String>,
+    postcode_count: u32,
+    lat_sum: f64,
+    lon_sum: f64,
 }
 
 impl CellAgg {
-    fn new(num_features: usize) -> Self {
+    fn new(num_features: usize, num_enums: usize) -> Self {
         CellAgg {
             count: 0,
             mins: vec![f64::INFINITY; num_features],
             maxs: vec![f64::NEG_INFINITY; num_features],
+            enum_mins: vec![ENUM_NULL; num_enums],
+            enum_maxs: vec![0; num_enums],
+            postcode: None,
+            postcode_count: 0,
+            lat_sum: 0.0,
+            lon_sum: 0.0,
         }
     }
 
@@ -47,49 +79,129 @@ impl CellAgg {
         self.count += 1;
         let base = row * num_features;
         let row_slice = &feature_data[base..base + num_features];
-        for (i, &v) in row_slice.iter().enumerate() {
-            if v.is_finite() {
-                if v < self.mins[i] {
-                    self.mins[i] = v;
+        for (feat_index, &value) in row_slice.iter().enumerate() {
+            if value.is_finite() {
+                if value < self.mins[feat_index] {
+                    self.mins[feat_index] = value;
                 }
-                if v > self.maxs[i] {
-                    self.maxs[i] = v;
+                if value > self.maxs[feat_index] {
+                    self.maxs[feat_index] = value;
                 }
             }
         }
     }
+
+    /// Track min/max ordinal index for each enum feature in this cell.
+    #[inline]
+    fn add_enums(&mut self, enum_features: &[crate::data::EnumFeatureData], row: usize) {
+        for (enum_index, enum_feature) in enum_features.iter().enumerate() {
+            let value = enum_feature.data[row];
+            if value != ENUM_NULL {
+                if self.enum_mins[enum_index] == ENUM_NULL || value < self.enum_mins[enum_index] {
+                    self.enum_mins[enum_index] = value;
+                }
+                if value > self.enum_maxs[enum_index] {
+                    self.enum_maxs[enum_index] = value;
+                }
+            }
+        }
+    }
+
+    /// Track postcode and centroid for high-resolution cells.
+    /// Uses simple "first seen" approach — at res 11/12, most rows in a cell share a postcode.
+    #[inline]
+    fn add_postcode(&mut self, postcode: &str, lat: f64, lon: f64) {
+        self.lat_sum += lat;
+        self.lon_sum += lon;
+        if postcode.is_empty() {
+            return;
+        }
+        if self.postcode.is_none() {
+            self.postcode = Some(postcode.to_string());
+            self.postcode_count = 1;
+        } else if self.postcode.as_deref() == Some(postcode) {
+            self.postcode_count += 1;
+        }
+    }
+}
+
+/// Escape a string for inclusion in a JSON string literal.
+pub(crate) fn write_json_escaped(buf: &mut String, text: &str) {
+    for character in text.chars() {
+        match character {
+            '"' => buf.push_str("\\\""),
+            '\\' => buf.push_str("\\\\"),
+            '\n' => buf.push_str("\\n"),
+            '\r' => buf.push_str("\\r"),
+            '\t' => buf.push_str("\\t"),
+            ctrl if ctrl < '\x20' => { let _ = write!(buf, "\\u{:04x}", ctrl as u32); }
+            other => buf.push(other),
+        }
+    }
 }
 
 /// Write the hexagons JSON response directly to a String buffer,
 /// avoiding serde_json::Value allocations entirely.
+#[allow(clippy::too_many_arguments)]
 fn write_hexagons_json(
     buf: &mut String,
     groups: &FxHashMap<u64, CellAgg>,
     min_keys: &[String],
     max_keys: &[String],
     num_features: usize,
+    enum_min_keys: &[String],
+    enum_max_keys: &[String],
+    num_enums: usize,
+    include_postcode: bool,
 ) {
     buf.push_str("{\"features\":[");
     let mut first = true;
-    for (&cell_id, agg) in groups {
+    for (&cell_id, aggregation) in groups {
+        let Some(cell) = h3o::CellIndex::try_from(cell_id).ok() else {
+            continue;
+        };
+
         if !first {
             buf.push(',');
         }
         first = false;
 
-        let cell = h3o::CellIndex::try_from(cell_id).unwrap();
-        write!(buf, "{{\"h3\":\"{}\",\"count\":{}", cell, agg.count).unwrap();
+        let _ = write!(buf, "{{\"h3\":\"{}\",\"count\":{}", cell, aggregation.count);
 
-        for i in 0..num_features {
-            if agg.mins[i] != f64::INFINITY {
-                write!(
+        for feat_index in 0..num_features {
+            if aggregation.mins[feat_index].is_finite() && aggregation.maxs[feat_index].is_finite() {
+                let _ = write!(
                     buf,
                     ",\"{}\":{},\"{}\":{}",
-                    min_keys[i], agg.mins[i], max_keys[i], agg.maxs[i]
-                )
-                .unwrap();
+                    min_keys[feat_index], aggregation.mins[feat_index], max_keys[feat_index], aggregation.maxs[feat_index]
+                );
             }
         }
+
+        for enum_index in 0..num_enums {
+            if aggregation.enum_mins[enum_index] != ENUM_NULL {
+                let _ = write!(
+                    buf,
+                    ",\"{}\":{},\"{}\":{}",
+                    enum_min_keys[enum_index], aggregation.enum_mins[enum_index],
+                    enum_max_keys[enum_index], aggregation.enum_maxs[enum_index]
+                );
+            }
+        }
+
+        if include_postcode {
+            if let Some(ref postcode) = aggregation.postcode {
+                let total = aggregation.count as f64;
+                let centroid_lat = aggregation.lat_sum / total;
+                let centroid_lon = aggregation.lon_sum / total;
+                if centroid_lat.is_finite() && centroid_lon.is_finite() {
+                    buf.push_str(",\"postcode\":\"");
+                    write_json_escaped(buf, postcode);
+                    let _ = write!(buf, "\",\"lat\":{},\"lon\":{}", centroid_lat, centroid_lon);
+                }
+            }
+        }
+
         buf.push('}');
     }
     buf.push_str("]}");
@@ -101,7 +213,10 @@ pub async fn get_hexagons(
 ) -> Result<impl IntoResponse, (StatusCode, String)> {
     let resolution = params.resolution;
     if resolution < H3_PRECOMPUTE_MIN || resolution > H3_PRECOMPUTE_MAX {
-        warn!(resolution, "Resolution out of range [{}, {}]", H3_PRECOMPUTE_MIN, H3_PRECOMPUTE_MAX);
+        warn!(
+            resolution,
+            "Resolution out of range [{}, {}]", H3_PRECOMPUTE_MIN, H3_PRECOMPUTE_MAX
+        );
         return Err((
             StatusCode::BAD_REQUEST,
             format!(
@@ -116,25 +231,7 @@ pub async fn get_hexagons(
         "bounds parameter is required".into(),
     ))?;
 
-    let parts: Vec<f64> = bounds_str
-        .split(',')
-        .map(|s| s.trim().parse::<f64>())
-        .collect::<Result<Vec<_>, _>>()
-        .map_err(|_| {
-            (
-                StatusCode::BAD_REQUEST,
-                "Invalid bounds format. Use: south,west,north,east".into(),
-            )
-        })?;
-
-    if parts.len() != 4 {
-        return Err((
-            StatusCode::BAD_REQUEST,
-            "Invalid bounds format. Use: south,west,north,east".into(),
-        ));
-    }
-
-    let (mut south, mut west, mut north, mut east) = (parts[0], parts[1], parts[2], parts[3]);
+    let (mut south, mut west, mut north, mut east) = parse_bounds(&bounds_str)?;
 
     let lat_range = north - south;
     let lng_range = east - west;
@@ -143,11 +240,10 @@ pub async fn get_hexagons(
     west -= lng_range * BOUNDS_BUFFER_PERCENT;
     east += lng_range * BOUNDS_BUFFER_PERCENT;
 
-    let precision = 0.01;
-    south = (south / precision).floor() * precision;
-    west = (west / precision).floor() * precision;
-    north = (north / precision).ceil() * precision;
-    east = (east / precision).ceil() * precision;
+    south = (south / BOUNDS_QUANTIZATION).floor() * BOUNDS_QUANTIZATION;
+    west = (west / BOUNDS_QUANTIZATION).floor() * BOUNDS_QUANTIZATION;
+    north = (north / BOUNDS_QUANTIZATION).ceil() * BOUNDS_QUANTIZATION;
+    east = (east / BOUNDS_QUANTIZATION).ceil() * BOUNDS_QUANTIZATION;
 
     let filters_str = params.filters.clone();
     let (parsed_filters, parsed_enum_filters) = parse_filters(
@@ -157,44 +253,38 @@ pub async fn get_hexagons(
     );
     let num_filters = parsed_filters.len() + parsed_enum_filters.len();
 
-    let json_body = tokio::task::spawn_blocking(move || {
+    let json_body = tokio::task::spawn_blocking(move || -> Result<String, String> {
         let t0 = std::time::Instant::now();
 
         let num_features = state.data.num_features;
+        let num_enums = state.data.enum_features.len();
         let feature_data = &state.data.feature_data;
 
-        let min_keys: Vec<String> = state
-            .data
-            .feature_names
-            .iter()
-            .map(|n| format!("min_{}", n))
-            .collect();
-        let max_keys: Vec<String> = state
-            .data
-            .feature_names
-            .iter()
-            .map(|n| format!("max_{}", n))
-            .collect();
+        let min_keys = &state.min_keys;
+        let max_keys = &state.max_keys;
+        let enum_min_keys = &state.enum_min_keys;
+        let enum_max_keys = &state.enum_max_keys;
 
         let h3_cells_for_res: Option<&[u64]> = state
             .h3_cells
             .get(resolution as usize)
-            .filter(|v| !v.is_empty())
-            .map(|v| v.as_slice());
+            .filter(|cells| !cells.is_empty())
+            .map(|cells| cells.as_slice());
 
         let mut groups: FxHashMap<u64, CellAgg> = FxHashMap::default();
 
         let enum_features = &state.data.enum_features;
+        let include_postcode = resolution >= POSTCODE_MIN_RESOLUTION;
 
         // Row-level filter check: numeric must be non-NaN and within [min, max],
         // enum must have value index in the allowed set
         let row_passes = |row: usize| -> bool {
-            parsed_filters.iter().all(|f| {
-                let v = feature_data[row * num_features + f.feat_idx];
-                v.is_finite() && v >= f.min && v <= f.max
-            }) && parsed_enum_filters.iter().all(|ef| {
-                let v = enum_features[ef.enum_idx].data[row];
-                v != 255 && ef.allowed.contains(&v)
+            parsed_filters.iter().all(|filter| {
+                let value = feature_data[row * num_features + filter.feat_idx];
+                value.is_finite() && value >= filter.min && value <= filter.max
+            }) && parsed_enum_filters.iter().all(|enum_filter| {
+                let value = enum_features[enum_filter.enum_idx].data[row];
+                value != ENUM_NULL && enum_filter.allowed.contains(&value)
             })
         };
 
@@ -207,13 +297,22 @@ pub async fn get_hexagons(
                         return;
                     }
                     let cell_id = precomputed[row];
-                    groups
+                    let aggregation = groups
                         .entry(cell_id)
-                        .or_insert_with(|| CellAgg::new(num_features))
-                        .add_row(feature_data, row, num_features);
+                        .or_insert_with(|| CellAgg::new(num_features, num_enums));
+                    aggregation.add_row(feature_data, row, num_features);
+                    aggregation.add_enums(enum_features, row);
+                    if include_postcode {
+                        aggregation.add_postcode(
+                            &state.data.postcode[row],
+                            state.data.lat[row],
+                            state.data.lon[row],
+                        );
+                    }
                 });
         } else {
-            let h3_res = h3o::Resolution::try_from(resolution).unwrap();
+            let h3_res = h3o::Resolution::try_from(resolution)
+                .map_err(|error| format!("Invalid H3 resolution {}: {}", resolution, error))?;
             state
                 .grid
                 .for_each_in_bounds(south, west, north, east, |row_idx| {
@@ -222,19 +321,37 @@ pub async fn get_hexagons(
                         return;
                     }
                     let cell_id = h3o::LatLng::new(state.data.lat[row], state.data.lon[row])
-                        .map(|c| u64::from(c.to_cell(h3_res)))
+                        .map(|coord| u64::from(coord.to_cell(h3_res)))
                         .unwrap_or(0);
-                    groups
+                    let aggregation = groups
                         .entry(cell_id)
-                        .or_insert_with(|| CellAgg::new(num_features))
-                        .add_row(feature_data, row, num_features);
+                        .or_insert_with(|| CellAgg::new(num_features, num_enums));
+                    aggregation.add_row(feature_data, row, num_features);
+                    aggregation.add_enums(enum_features, row);
+                    if include_postcode {
+                        aggregation.add_postcode(
+                            &state.data.postcode[row],
+                            state.data.lat[row],
+                            state.data.lon[row],
+                        );
+                    }
                 });
         }
 
         let t_agg = t0.elapsed();
 
         let mut json_buf = String::with_capacity(groups.len() * 128);
-        write_hexagons_json(&mut json_buf, &groups, &min_keys, &max_keys, num_features);
+        write_hexagons_json(
+            &mut json_buf,
+            &groups,
+            min_keys,
+            max_keys,
+            num_features,
+            enum_min_keys,
+            enum_max_keys,
+            num_enums,
+            include_postcode,
+        );
 
         let t_total = t0.elapsed();
         info!(
@@ -244,14 +361,15 @@ pub async fn get_hexagons(
             filters_raw = filters_str.as_deref().unwrap_or("-"),
             agg_ms = format_args!("{:.1}", t_agg.as_secs_f64() * 1000.0),
             total_ms = format_args!("{:.1}", t_total.as_secs_f64() * 1000.0),
-            bytes = json_buf.len(),
+            size = format_args!("{}", HumanBytes(json_buf.len())),
             "GET /api/hexagons"
         );
 
-        json_buf
+        Ok(json_buf)
     })
     .await
-    .unwrap();
+    .map_err(|error| (StatusCode::INTERNAL_SERVER_ERROR, error.to_string()))?
+    .map_err(|error| (StatusCode::INTERNAL_SERVER_ERROR, error))?;
 
     Ok(([("content-type", "application/json")], json_body))
 }

server-rs/src/routes/mod.rs

@@ -1,9 +1,12 @@
 mod features;
-mod hexagons;
+pub(crate) mod hexagons;
+mod hexagon_stats;
+pub(crate) mod parse;
 mod pois;
-mod properties;
+pub(crate) mod properties;
 
 pub use features::get_features;
+pub use hexagon_stats::get_hexagon_stats;
 pub use hexagons::get_hexagons;
 pub use pois::{get_poi_categories, get_pois};
 pub use properties::get_hexagon_properties;

server-rs/src/routes/parse.rs

@@ -1,9 +1,38 @@
 use axum::http::StatusCode;
 
+/// Compute the lat/lon bounding box of an H3 cell, with a configurable buffer in degrees.
+pub fn h3_cell_bounds(cell: h3o::CellIndex, buffer: f64) -> (f64, f64, f64, f64) {
+    let boundary = cell.boundary();
+    let (mut min_lat, mut max_lat) = (f64::INFINITY, f64::NEG_INFINITY);
+    let (mut min_lon, mut max_lon) = (f64::INFINITY, f64::NEG_INFINITY);
+    for vertex in boundary.iter() {
+        let lat = vertex.lat();
+        let lon = vertex.lng();
+        if lat < min_lat {
+            min_lat = lat;
+        }
+        if lat > max_lat {
+            max_lat = lat;
+        }
+        if lon < min_lon {
+            min_lon = lon;
+        }
+        if lon > max_lon {
+            max_lon = lon;
+        }
+    }
+    (
+        min_lat - buffer,
+        min_lon - buffer,
+        max_lat + buffer,
+        max_lon + buffer,
+    )
+}
+
 pub fn parse_bounds(bounds_str: &str) -> Result<(f64, f64, f64, f64), (StatusCode, String)> {
     let parts: Vec<f64> = bounds_str
         .split(',')
-        .map(|s| s.trim().parse::<f64>())
+        .map(|part| part.trim().parse::<f64>())
         .collect::<Result<Vec<_>, _>>()
         .map_err(|_| {
             (

server-rs/src/routes/pois.rs

@@ -39,37 +39,56 @@ pub async fn get_pois(
     let category_filter: Option<rustc_hash::FxHashSet<String>> = params
         .categories
         .as_deref()
-        .filter(|s| !s.is_empty())
-        .map(|s| s.split(',').map(|c| c.trim().to_string()).collect());
+        .filter(|text| !text.is_empty())
+        .map(|text| text.split(',').map(|part| part.trim().to_string()).collect());
 
-    let num_categories = category_filter.as_ref().map(|c| c.len()).unwrap_or(0);
+    let num_categories = category_filter.as_ref().map(|cats| cats.len()).unwrap_or(0);
 
     let result = tokio::task::spawn_blocking(move || {
         let t0 = std::time::Instant::now();
         let row_indices = state.poi_grid.query(south, west, north, east);
 
-        let pois: Vec<POI> = row_indices
+        // Collect matching row indices first, then sample randomly so the
+        // subset covers the viewport uniformly instead of clustering in one area.
+        let mut matching_rows: Vec<usize> = row_indices
             .iter()
             .filter_map(|&row_idx| {
                 let row = row_idx as usize;
-
                 if let Some(ref categories) = category_filter {
                     if !categories.contains(&state.poi_data.category[row]) {
                         return None;
                     }
                 }
-
-                Some(POI {
-                    id: state.poi_data.id[row].clone(),
-                    name: state.poi_data.name[row].clone(),
-                    category: state.poi_data.category[row].clone(),
-                    group: state.poi_data.group[row].clone(),
-                    lat: state.poi_data.lat[row],
-                    lng: state.poi_data.lng[row],
-                    emoji: state.poi_data.emoji[row].clone(),
-                })
+                Some(row)
+            })
+            .collect();
+
+        if matching_rows.len() > MAX_POIS_PER_REQUEST {
+            // Use a power-of-2 sampling step so each POI's inclusion depends
+            // only on its own priority hash, not on what other POIs are in
+            // the viewport. This prevents visible reshuffling when panning.
+            let ratio = (matching_rows.len() / MAX_POIS_PER_REQUEST) as u32;
+            let step = ratio.next_power_of_two();
+            let mask = step - 1;
+            matching_rows.retain(|&row| state.poi_data.priority[row] & mask == 0);
+            // Statistical noise may leave us slightly over the limit
+            if matching_rows.len() > MAX_POIS_PER_REQUEST {
+                matching_rows.sort_unstable_by_key(|&row| state.poi_data.priority[row]);
+                matching_rows.truncate(MAX_POIS_PER_REQUEST);
+            }
+        }
+
+        let pois: Vec<POI> = matching_rows
+            .iter()
+            .map(|&row| POI {
+                id: state.poi_data.id[row].clone(),
+                name: state.poi_data.name[row].clone(),
+                category: state.poi_data.category[row].clone(),
+                group: state.poi_data.group[row].clone(),
+                lat: state.poi_data.lat[row],
+                lng: state.poi_data.lng[row],
+                emoji: state.poi_data.emoji[row].clone(),
             })
-            .take(MAX_POIS_PER_REQUEST)
             .collect();
 
         let elapsed = t0.elapsed();
@@ -85,7 +104,7 @@ pub async fn get_pois(
         POIsResponse { pois }
     })
     .await
-    .map_err(|e| (StatusCode::INTERNAL_SERVER_ERROR, e.to_string()))?;
+    .map_err(|error| (StatusCode::INTERNAL_SERVER_ERROR, error.to_string()))?;
 
     Ok(Json(result))
 }
@@ -98,7 +117,7 @@ pub struct POICategoriesResponse {
 pub async fn get_poi_categories(state: Arc<AppState>) -> Json<POICategoriesResponse> {
     let groups: Vec<POICategoryGroup> = state.poi_category_groups.clone();
 
-    let total: usize = groups.iter().map(|g| g.categories.len()).sum();
+    let total: usize = groups.iter().map(|group| group.categories.len()).sum();
     info!(
         count = total,
         groups = groups.len(),

server-rs/src/routes/properties.rs

@@ -8,9 +8,13 @@ use rustc_hash::FxHashMap;
 use serde::{Deserialize, Serialize};
 use tracing::{info, warn};
 
+use crate::consts::{DEFAULT_PROPERTIES_LIMIT, ENUM_NULL, MAX_PROPERTIES_LIMIT};
+use crate::data::EnumFeatureData;
 use crate::filter::{parse_filters, row_passes_filters};
 use crate::state::AppState;
 
+use super::parse::h3_cell_bounds;
+
 #[derive(Deserialize)]
 pub struct HexagonPropertiesParams {
     pub h3: String,
@@ -35,6 +39,8 @@ pub struct Property {
     pub lat: f64,
     pub lon: f64,
 
+    pub is_construction_date_approximate: Option<bool>,
+
     #[serde(flatten)]
     pub features: FxHashMap<String, f64>,
 }
@@ -48,20 +54,51 @@ pub struct HexagonPropertiesResponse {
     pub truncated: bool,
 }
 
+fn non_empty_string(text: &str) -> Option<String> {
+    let trimmed = text.trim();
+    if trimmed.is_empty() {
+        None
+    } else {
+        Some(trimmed.to_string())
+    }
+}
+
+fn lookup_enum_value(
+    enum_features: &[EnumFeatureData],
+    enum_idx: &FxHashMap<String, usize>,
+    row: usize,
+    names: &[&str],
+) -> Option<String> {
+    for name in names {
+        if let Some(&feature_index) = enum_idx.get(*name) {
+            let enum_feature = &enum_features[feature_index];
+            let data_index = enum_feature.data[row];
+            if data_index != ENUM_NULL {
+                if let Some(value) = enum_feature.values.get(data_index as usize) {
+                    return Some(value.clone());
+                }
+            }
+        }
+    }
+    None
+}
+
 pub async fn get_hexagon_properties(
     state: Arc<AppState>,
     Query(params): Query<HexagonPropertiesParams>,
 ) -> Result<Json<HexagonPropertiesResponse>, (StatusCode, String)> {
-    let cell = h3o::CellIndex::from_str(&params.h3)
-        .map_err(|e| {
-            warn!(h3 = %params.h3, error = %e, "Invalid H3 cell index");
-            (StatusCode::BAD_REQUEST, format!("Invalid H3 cell: {}", e))
-        })?;
+    let cell = h3o::CellIndex::from_str(&params.h3).map_err(|error| {
+        warn!(h3 = %params.h3, error = %error, "Invalid H3 cell index");
+        (StatusCode::BAD_REQUEST, format!("Invalid H3 cell: {}", error))
+    })?;
     let cell_u64: u64 = cell.into();
 
     let resolution = params.resolution as usize;
     if resolution >= state.h3_cells.len() || state.h3_cells[resolution].is_empty() {
-        warn!(resolution, "Invalid or non-precomputed resolution for hexagon-properties");
+        warn!(
+            resolution,
+            "Invalid or non-precomputed resolution for hexagon-properties"
+        );
         return Err((
             StatusCode::BAD_REQUEST,
             "Invalid or non-precomputed resolution".to_string(),
@@ -84,31 +121,29 @@ pub async fn get_hexagon_properties(
         let feature_data = &state.data.feature_data;
         let enum_features = &state.data.enum_features;
 
-        let matching_rows: Vec<usize> = h3_data
-            .iter()
-            .enumerate()
-            .filter_map(|(idx, &h3_cell)| {
-                if h3_cell == cell_u64 {
-                    if row_passes_filters(
-                        idx,
+        let (min_lat, min_lon, max_lat, max_lon) = h3_cell_bounds(cell, 0.001);
+
+        let mut matching_rows: Vec<usize> = Vec::new();
+        state
+            .grid
+            .for_each_in_bounds(min_lat, min_lon, max_lat, max_lon, |row_idx| {
+                let row = row_idx as usize;
+                if h3_data[row] == cell_u64
+                    && row_passes_filters(
+                        row,
                         &parsed_filters,
                         &parsed_enum_filters,
                         feature_data,
                         num_features,
                         enum_features,
-                    ) {
-                        Some(idx)
-                    } else {
-                        None
-                    }
-                } else {
-                    None
+                    )
+                {
+                    matching_rows.push(row);
                 }
-            })
-            .collect();
+            });
 
         let total = matching_rows.len();
-        let limit = params.limit.unwrap_or(100).min(500);
+        let limit = params.limit.unwrap_or(DEFAULT_PROPERTIES_LIMIT).min(MAX_PROPERTIES_LIMIT);
         let offset = params.offset.unwrap_or(0);
         let truncated = total > offset + limit;
 
@@ -120,49 +155,46 @@ pub async fn get_hexagon_properties(
                 let mut features = FxHashMap::default();
                 let base = row * num_features;
                 for (feat_idx, feat_name) in state.data.feature_names.iter().enumerate() {
-                    let v = feature_data[base + feat_idx];
-                    if v.is_finite() {
-                        features.insert(feat_name.clone(), v);
+                    let value = feature_data[base + feat_idx];
+                    if value.is_finite() {
+                        features.insert(feat_name.clone(), value);
                     }
                 }
 
-                let get_string = |s: &str| -> Option<String> {
-                    let trimmed = s.trim();
-                    if trimmed.is_empty() {
-                        None
-                    } else {
-                        Some(trimmed.to_string())
-                    }
-                };
-
-                let get_enum_value = |names: &[&str]| -> Option<String> {
-                    for name in names {
-                        if let Some(val) = enum_features.iter().find_map(|ef| {
-                            if ef.name == *name {
-                                let idx = ef.data[row];
-                                if idx == 255 {
-                                    None
-                                } else {
-                                    ef.values.get(idx as usize).cloned()
-                                }
-                            } else {
-                                None
-                            }
-                        }) {
-                            return Some(val);
-                        }
-                    }
-                    None
-                };
-
                 Property {
-                    address: get_string(&state.data.address[row]),
-                    postcode: get_string(&state.data.postcode[row]),
-                    property_type: get_enum_value(&["Property type", "epc_property_type", "pp_property_type"]),
-                    built_form: get_enum_value(&["Property type/built form", "built_form"]),
-                    duration: get_enum_value(&["Leashold/Freehold", "duration"]),
-                    current_energy_rating: get_enum_value(&["Current energy rating", "current_energy_rating"]),
-                    potential_energy_rating: get_enum_value(&["Potential energy rating", "potential_energy_rating"]),
+                    address: non_empty_string(&state.data.address[row]),
+                    postcode: non_empty_string(&state.data.postcode[row]),
+                    is_construction_date_approximate: Some(state.data.is_approx_build_date[row]),
+                    property_type: lookup_enum_value(
+                        enum_features,
+                        &state.enum_name_to_idx,
+                        row,
+                        &["Property type", "epc_property_type", "pp_property_type"],
+                    ),
+                    built_form: lookup_enum_value(
+                        enum_features,
+                        &state.enum_name_to_idx,
+                        row,
+                        &["Property type/built form", "built_form"],
+                    ),
+                    duration: lookup_enum_value(
+                        enum_features,
+                        &state.enum_name_to_idx,
+                        row,
+                        &["Leashold/Freehold", "duration"],
+                    ),
+                    current_energy_rating: lookup_enum_value(
+                        enum_features,
+                        &state.enum_name_to_idx,
+                        row,
+                        &["Current energy rating", "current_energy_rating"],
+                    ),
+                    potential_energy_rating: lookup_enum_value(
+                        enum_features,
+                        &state.enum_name_to_idx,
+                        row,
+                        &["Potential energy rating", "potential_energy_rating"],
+                    ),
                     lat: state.data.lat[row],
                     lon: state.data.lon[row],
                     features,
@@ -192,7 +224,7 @@ pub async fn get_hexagon_properties(
         }
     })
     .await
-    .unwrap();
+    .map_err(|error| (StatusCode::INTERNAL_SERVER_ERROR, error.to_string()))?;
 
     Ok(Json(result))
 }