Fix : remove categories derived from txt analysis.

docs/FILTERING_PHASE4_I18N_PLAN.md

···
+# Event Filtering System - Phase 4: I18n Integration Plan
+
+## Overview
+
+Phase 4 integrates the existing event filtering system with the i18n infrastructure, enabling locale-aware facet calculation, template rendering with dynamic translation functions, and HTMX-aware language propagation.
+
+**Status**: Ready for Implementation ✅  
+**Prerequisites**: Phase 1-3 Complete, I18n Infrastructure Complete  
+**Estimated Effort**: 2-3 days  
+
+---
+
+## Current State Analysis
+
+### ✅ Infrastructure Ready
+
+#### I18n System
+- **fluent-templates static loader**: Fully implemented and working
+- **Template functions**: `t()`, `tg()`, `current_locale()`, `has_locale()` already available
+- **HTMX middleware**: Language detection with proper priority order implemented
+- **Gender support**: French Canadian gender variants working
+
+#### Filtering System
+- **Phase 1**: Core filtering, query builder, facets, hydration complete
+- **Phase 2**: Facet calculation and event hydration complete
+- **Phase 3**: Redis cache integration complete
+- **Templates**: Language-specific templates exist (`.en-us.html`, `.fr-ca.html`)
+
+#### Translation Keys
+- **Basic filter keys**: Most UI strings already translated in `i18n/*/ui.ftl`
+- **Missing**: Facet-specific translation keys for dynamic content
+
+### 🔧 Implementation Needed
+
+1. **Facet Translation Keys**: Add missing keys for category/date range facets
+2. **Locale-Aware Facet Calculation**: Pass locale context to facet calculators
+3. **Template Migration**: Update templates to use i18n functions instead of pre-rendered text
+4. **Service Integration**: Connect filtering service with locale from middleware
+5. **HTMX Language Headers**: Ensure facet updates propagate language correctly
+
+---
+
+## Implementation Tasks
+
+### Task 1: Add Missing Translation Keys
+
+#### 1.2 Date Range Facet Keys
+Add date range translation keys:
+
+**File**: `/i18n/en-us/ui.ftl`
+```fluent
+# Date range facets
+date_range.today = Today
+date_range.this_week = This Week  
+date_range.this_month = This Month
+date_range.next_week = Next Week
+date_range.next_month = Next Month
+```
+
+**File**: `/i18n/fr-ca/ui.ftl`
+```fluent
+# Facettes de plage de dates
+date_range.today = Aujourd'hui
+date_range.this_week = Cette semaine
+date_range.this_month = Ce mois
+date_range.next_week = La semaine prochaine
+date_range.next_month = Le mois prochain
+```
+
+#### 1.3 Additional Facet UI Keys
+Extend existing filter keys for facet display:
+
+**File**: `/i18n/en-us/ui.ftl`
+```fluent
+# Facet labels and counts
+filter-categories-label = Categories
+filter-creators-label = Event Creators
+filter-date-ranges-label = Date Ranges
+filter-facet-count = { $count ->
+    [one] ({ $count } event)
+   *[other] ({ $count } events)
+}
+filter-clear-facet = Clear { $facet }
+filter-show-more-facets = Show more...
+filter-show-less-facets = Show less
+```
+
+**File**: `/i18n/fr-ca/ui.ftl`
+```fluent
+# Étiquettes et comptes de facettes
+filter-categories-label = Catégories
+filter-creators-label = Créateurs d'événements
+filter-date-ranges-label = Plages de dates
+filter-facet-count = { $count ->
+    [one] ({ $count } événement)
+   *[other] ({ $count } événements)
+}
+filter-clear-facet = Effacer { $facet }
+filter-show-more-facets = Voir plus...
+filter-show-less-facets = Voir moins
+```
+
+### Task 2: Update Facet Calculation Service
+
+#### 2.1 Add Locale Parameter to FacetCalculator
+**File**: `/src/filtering/facets.rs`
+
+```rust
+impl FacetCalculator {
+    /// Calculate all facets for the given filter criteria with locale support
+    #[instrument(skip(self, criteria))]
+    pub async fn calculate_facets_with_locale(
+        &self,
+        criteria: &EventFilterCriteria,
+        locale: &LanguageIdentifier,
+    ) -> Result<EventFacets, FilterError> {
+        let mut facets = EventFacets::default();
+        
+        // Calculate total count
+        facets.total_count = self.calculate_total_count(criteria).await?;
+        
+        // Calculate category facets with i18n support
+        facets.categories = self.calculate_category_facets_with_locale(criteria, locale).await?;
+        
+        // Calculate creator facets
+        facets.creators = self.calculate_creator_facets(criteria).await?;
+        
+        // Calculate date range facets with i18n support
+        facets.date_ranges = self.calculate_date_range_facets_with_locale(criteria, locale).await?;
+        
+        Ok(facets)
+    }
+
+    /// Calculate category facets with locale-aware translations
+    async fn calculate_category_facets_with_locale(
+        &self,
+        criteria: &EventFilterCriteria,
+        locale: &LanguageIdentifier,
+    ) -> Result<Vec<FacetValue>, FilterError> {
+        // ...existing query logic...
+        
+        let mut facets = Vec::new();
+        for row in rows {
+            let category: String = row.try_get("category")?;
+            let count: i64 = row.try_get("count")?;
+            
+            let i18n_key = Self::generate_category_i18n_key(&category);
+            
+            facets.push(FacetValue {
+                i18n_key: Some(i18n_key),
+                value: category,
+                count,
+                // Add locale-specific display name if translation exists
+                display_name: Some(self.get_translated_facet_name(&i18n_key, locale)),
+            });
+        }
+        
+        Ok(facets)
+    }
+
+    /// Get translated facet name with fallback to original value
+    fn get_translated_facet_name(&self, i18n_key: &str, locale: &LanguageIdentifier) -> String {
+        use crate::i18n::fluent_loader::LOCALES;
+        
+        let translated = LOCALES.lookup(locale, i18n_key);
+        
+        // If translation returns the key itself, it means no translation found
+        if translated == i18n_key {
+            // Extract readable name from key: "category.technology_and_innovation" -> "Technology And Innovation"
+            i18n_key
+                .split('.')
+                .last()
+                .unwrap_or(i18n_key)
+                .replace('_', " ")
+                .split_whitespace()
+                .map(|word| {
+                    let mut chars = word.chars();
+                    match chars.next() {
+                        None => String::new(),
+                        Some(first) => first.to_uppercase().collect::<String>() + chars.as_str(),
+                    }
+                })
+                .collect::<Vec<_>>()
+                .join(" ")
+        } else {
+            translated
+        }
+    }
+}
+```
+
+#### 2.2 Update FacetValue Structure
+**File**: `/src/filtering/mod.rs`
+
+```rust
+/// A single facet value with count and optional i18n support
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct FacetValue {
+    /// The actual filter value
+    pub value: String,
+    /// Number of events matching this facet
+    pub count: i64,
+    /// Optional i18n key for translation
+    pub i18n_key: Option<String>,
+    /// Pre-calculated display name (locale-specific)
+    pub display_name: Option<String>,
+}
+```
+
+### Task 3: Update FilteringService Integration
+
+#### 3.1 Pass Locale to Service
+**File**: `/src/filtering/service.rs`
+
+```rust
+impl FilteringService {
+    /// Filter events with locale-aware facets
+    #[instrument(skip(self, criteria))]
+    pub async fn filter_events_with_locale(
+        &self,
+        criteria: &EventFilterCriteria,
+        locale: &LanguageIdentifier,
+        options: FilterOptions,
+    ) -> Result<FilterResults, FilterError> {
+        // Generate cache key including locale
+        let cache_key = format!("filter:{}:{}", criteria.cache_hash(), locale.to_string());
+        
+        // Try cache first (if enabled)
+        if let Some(ref cache) = self.cache {
+            if let Ok(Some(cached_results)) = cache.get::<FilterResults>(&cache_key).await {
+                debug!("Cache hit for filter query with locale {}", locale);
+                return Ok(cached_results);
+            }
+        }
+        
+        // Execute query
+        let events = self.query_builder
+            .filter_events(criteria, &self.pool, &options)
+            .await?;
+        
+        // Calculate locale-aware facets
+        let facets = if options.include_facets {
+            Some(self.facet_calculator.calculate_facets_with_locale(criteria, locale).await?)
+        } else {
+            None
+        };
+        
+        // Hydrate events if requested
+        let hydrated_events = if options.include_hydration {
+            self.hydrator.hydrate_events(events, &options.hydration_options).await?
+        } else {
+            events.into_iter().map(EventView::from_event).collect()
+        };
+        
+        let results = FilterResults {
+            events: hydrated_events,
+            facets,
+            total_count: facets.as_ref().map(|f| f.total_count).unwrap_or(0),
+        };
+        
+        // Cache results (if enabled)
+        if let Some(ref cache) = self.cache {
+            let _ = cache.set(&cache_key, &results, self.config.cache_ttl).await;
+        }
+        
+        Ok(results)
+    }
+}
+```
+
+### Task 4: Update HTTP Handlers
+
+#### 4.1 Extract Locale from Middleware
+**File**: `/src/http/handle_filter_events.rs`
+
+```rust
+use crate::http::middleware_i18n::Language;
+
+/// Main filtering endpoint with i18n support
+#[instrument(skip(ctx, filtering_service))]
+pub async fn handle_filter_events(
+    Extension(ctx): Extension<WebContext>,
+    Extension(filtering_service): Extension<Arc<FilteringService>>,
+    language: Language,
+    filter_params: FilterQueryParams,
+    headers: HeaderMap,
+) -> Result<impl IntoResponse, WebError> {
+    let is_htmx = headers.contains_key("hx-request");
+    let criteria = EventFilterCriteria::from_query_params(&filter_params)?;
+    
+    // Include locale in filtering options
+    let options = FilterOptions {
+        include_facets: true,
+        include_hydration: true,
+        hydration_options: HydrationOptions::default(),
+    };
+    
+    // Use locale-aware filtering
+    let results = filtering_service
+        .filter_events_with_locale(&criteria, &language.0, options)
+        .await?;
+    
+    // Template selection with locale
+    let template_name = if is_htmx {
+        format!("filter_events_results.{}.incl.html", language.0)
+    } else {
+        format!("filter_events.{}.html", language.0)
+    };
+    
+    // Enhanced context for templates
+    let template_context = template_context! {
+        events => results.events,
+        facets => results.facets,
+        filter_criteria => criteria,
+        total_count => results.total_count,
+        current_locale => language.0.to_string(),
+    };
+    
+    Ok(RenderHtml(template_name, ctx.engine, template_context))
+}
+```
+
+### Task 5: Update Templates to Use I18n Functions
+
+#### 5.1 Update Filter Form Template
+**File**: `/templates/filter_events.en-us.common.html` → **Migrate to Single Template**
+
+Create new unified template: `/templates/filter_events.common.html`
+
+```html
+<div class="section">
+    <div class="container">
+        <div class="columns">
+            <!-- Filter Sidebar -->
+            <div class="column is-3">
+                <div class="box">
+                    <h2 class="title is-5">{{ t("filter-title") }}</h2>
+                    
+                    <!-- Search Form -->
+                    <form id="filter-form" 
+                          hx-get="/events" 
+                          hx-target="#events-results" 
+                          hx-trigger="submit, change from:input, keyup[keyCode==13] from:input"
+                          hx-push-url="true"
+                          hx-headers='{"HX-Current-Language": "{{ current_locale() }}"}'>
+                        
+                        <!-- Text Search -->
+                        <div class="field">
+                            <label class="label">{{ t("filter-search-label") }}</label>
+                            <div class="control">
+                                <input class="input" 
+                                       type="text" 
+                                       name="q" 
+                                       value="{{ filter_criteria.text_search | default('') }}"
+                                       placeholder="{{ t('filter-search-placeholder') }}">
+                            </div>
+                        </div>
+                        
+                        <!-- Date Range -->
+                        <div class="field">
+                            <label class="label">{{ t("filter-date-range-label") }}</label>
+                            <div class="field-body">
+                                <div class="field">
+                                    <div class="control">
+                                        <input class="input" 
+                                               type="date" 
+                                               name="start_date" 
+                                               value="{{ filter_criteria.start_date | default('') }}">
+                                    </div>
+                                </div>
+                                <div class="field">
+                                    <div class="control">
+                                        <input class="input" 
+                                               type="date" 
+                                               name="end_date" 
+                                               value="{{ filter_criteria.end_date | default('') }}">
+                                    </div>
+                                </div>
+                            </div>
+                        </div>
+                        
+                        <!-- Sort Options -->
+                        <div class="field">
+                            <label class="label">{{ t("filter-sort-label") }}</label>
+                            <div class="control">
+                                <div class="select is-fullwidth">
+                                    <select name="sort">
+                                        <option value="date_asc" {% if filter_criteria.sort_by == "date_asc" %}selected{% endif %}>
+                                            {{ t("filter-sort-date-asc") }}
+                                        </option>
+                                        <option value="date_desc" {% if filter_criteria.sort_by == "date_desc" %}selected{% endif %}>
+                                            {{ t("filter-sort-date-desc") }}
+                                        </option>
+                                        <option value="created_asc" {% if filter_criteria.sort_by == "created_asc" %}selected{% endif %}>
+                                            {{ t("filter-sort-created-asc") }}
+                                        </option>
+                                        <option value="created_desc" {% if filter_criteria.sort_by == "created_desc" %}selected{% endif %}>
+                                            {{ t("filter-sort-created-desc") }}
+                                        </option>
+                                        <option value="relevance" {% if filter_criteria.sort_by == "relevance" %}selected{% endif %}>
+                                            {{ t("filter-sort-relevance") }}
+                                        </option>
+                                    </select>
+                                </div>
+                            </div>
+                        </div>
+                        
+                        <!-- Clear Button -->
+                        <div class="field">
+                            <div class="control">
+                                <a href="/events" class="button is-light is-fullwidth">
+                                    {{ t("filter-clear-all") }}
+                                </a>
+                            </div>
+                        </div>
+                    </form>
+                </div>
+                
+                <!-- Dynamic Facets -->
+                {% if facets %}
+                <div class="box">
+                    <h3 class="title is-6">{{ t("filter-facets-title") }}</h3>
+                    
+                    <!-- Category Facets -->
+                    {% if facets.categories %}
+                    <div class="field">
+                        <label class="label">{{ t("filter-categories-label") }}</label>
+                        {% for category in facets.categories %}
+                        <div class="control">
+                            <label class="checkbox">
+                                <input type="checkbox"
+                                       name="categories"
+                                       value="{{ category.value }}"
+                                       {% if category.value in filter_criteria.categories %}checked{% endif %}
+                                       hx-get="/events"
+                                       hx-target="#events-results"
+                                       hx-include="closest form"
+                                       hx-headers='{"HX-Current-Language": "{{ current_locale() }}"}'>
+                                
+                                <!-- Use display_name if available, otherwise translate i18n_key -->
+                                {% if category.display_name %}
+                                    {{ category.display_name }}
+                                {% elif category.i18n_key %}
+                                    {{ t(category.i18n_key) }}
+                                {% else %}
+                                    {{ category.value }}
+                                {% endif %}
+                                
+                                {{ t("filter-facet-count", count=category.count) }}
+                            </label>
+                        </div>
+                        {% endfor %}
+                    </div>
+                    {% endif %}
+                    
+                    <!-- Date Range Facets -->
+                    {% if facets.date_ranges %}
+                    <div class="field">
+                        <label class="label">{{ t("filter-date-ranges-label") }}</label>
+                        {% for date_range in facets.date_ranges %}
+                        <div class="control">
+                            <label class="checkbox">
+                                <input type="checkbox"
+                                       name="date_ranges"
+                                       value="{{ date_range.value }}"
+                                       {% if date_range.value in filter_criteria.date_ranges %}checked{% endif %}
+                                       hx-get="/events"
+                                       hx-target="#events-results"
+                                       hx-include="closest form"
+                                       hx-headers='{"HX-Current-Language": "{{ current_locale() }}"}'>
+                                
+                                {% if date_range.i18n_key %}
+                                    {{ t(date_range.i18n_key) }}
+                                {% else %}
+                                    {{ date_range.value }}
+                                {% endif %}
+                                
+                                {{ t("filter-facet-count", count=date_range.count) }}
+                            </label>
+                        </div>
+                        {% endfor %}
+                    </div>
+                    {% endif %}
+                    
+                    <!-- Creator Facets -->
+                    {% if facets.creators %}
+                    <div class="field">
+                        <label class="label">{{ t("filter-creators-label") }}</label>
+                        {% for creator in facets.creators %}
+                        <div class="control">
+                            <label class="checkbox">
+                                <input type="checkbox"
+                                       name="creators"
+                                       value="{{ creator.value }}"
+                                       {% if creator.value in filter_criteria.creators %}checked{% endif %}
+                                       hx-get="/events"
+                                       hx-target="#events-results"
+                                       hx-include="closest form"
+                                       hx-headers='{"HX-Current-Language": "{{ current_locale() }}"}'>
+                                {{ creator.value }} {{ t("filter-facet-count", count=creator.count) }}
+                            </label>
+                        </div>
+                        {% endfor %}
+                    </div>
+                    {% endif %}
+                </div>
+                {% endif %}
+            </div>
+            
+            <!-- Events Results -->
+            <div class="column is-9">
+                <div id="events-results">
+                    {% include 'filter_events_results.incl.html' %}
+                </div>
+            </div>
+        </div>
+    </div>
+</div>
+```
+
+#### 5.2 Update Main Filter Pages
+Update both main filter pages to use the unified common template:
+
+**File**: `/templates/filter_events.en-us.html`
+```html
+{% extends "base." + current_locale() + ".html" %}
+{% block title %}{{ t("filter-events-title") }}{% endblock %}
+{% block head %}
+<meta name="description" content="{{ t("filter-events-description") }}">
+<meta property="og:title" content="{{ t("filter-events-title") }}">
+<meta property="og:description" content="{{ t("filter-events-description") }}">
+<meta property="og:site_name" content="{{ t("site-name") }}" />
+<meta property="og:type" content="website" />
+<meta property="og:url" content="{{ external_base }}/events" />
+<script src="https://unpkg.com/htmx.org@1.9.12"></script>
+{% endblock %}
+{% block content %}
+{% include 'filter_events.common.html' %}
+{% endblock %}
+```
+
+**File**: `/templates/filter_events.fr-ca.html`
+```html
+{% extends "base." + current_locale() + ".html" %}
+{% block title %}{{ t("filter-events-title") }}{% endblock %}
+{% block head %}
+<meta name="description" content="{{ t("filter-events-description") }}">
+<meta property="og:title" content="{{ t("filter-events-title") }}">
+<meta property="og:description" content="{{ t("filter-events-description") }}">
+<meta property="og:site_name" content="{{ t("site-name") }}" />
+<meta property="og:type" content="website" />
+<meta property="og:url" content="{{ external_base }}/events" />
+<script src="https://unpkg.com/htmx.org@1.9.12"></script>
+{% endblock %}
+{% block content %}
+{% include 'filter_events.common.html' %}
+{% endblock %}
+```
+
+#### 5.3 Update HTMX Results Template
+Create unified results template: `/templates/filter_events_results.incl.html`
+
+```html
+<!-- Results Header -->
+<div class="level">
+    <div class="level-left">
+        <div class="level-item">
+            <h1 class="title is-4">
+                {% if filter_criteria.search_term %}
+                    {{ t("filter-search-results-for", term=filter_criteria.search_term) }}
+                {% else %}
+                    {{ t("filter-all-events") }}
+                {% endif %}
+            </h1>
+        </div>
+    </div>
+    <div class="level-right">
+        <div class="level-item">
+            <p class="subtitle is-6">
+                {{ t("filter-results-count", count=total_count) }}
+            </p>
+        </div>
+    </div>
+</div>
+
+<!-- Events List -->
+{% if events %}
+    <div class="columns is-multiline">
+        {% for event in events %}
+        <div class="column is-half">
+            <div class="card">
+                <div class="card-content">
+                    <div class="media">
+                        <div class="media-content">
+                            <p class="title is-5">
+                                <a href="/events/{{ event.rkey }}">{{ event.name }}</a>
+                            </p>
+                            <p class="subtitle is-6">
+                                {% if event.creator_handle %}
+                                    {{ t("event-by-creator", creator=event.creator_handle) }}
+                                {% endif %}
+                            </p>
+                        </div>
+                    </div>
+                    
+                    <div class="content">
+                        {% if event.description %}
+                            <p>{{ event.description | truncate(150) }}</p>
+                        {% endif %}
+                        
+                        <div class="tags">
+                            {% if event.start_time %}
+                                <span class="tag is-info">
+                                    <i class="fas fa-calendar"></i>
+                                    {{ event.start_time | date("Y-m-d H:i") }}
+                                </span>
+                            {% endif %}
+                            
+                            {% if event.location %}
+                                <span class="tag is-success">
+                                    <i class="fas fa-map-marker-alt"></i>
+                                    {{ event.location }}
+                                </span>
+                            {% endif %}
+                            
+                            {% if event.rsvp_count %}
+                                <span class="tag is-warning">
+                                    <i class="fas fa-users"></i>
+                                    {{ t("event-rsvp-count", count=event.rsvp_count) }}
+                                </span>
+                            {% endif %}
+                        </div>
+                    </div>
+                </div>
+            </div>
+        </div>
+        {% endfor %}
+    </div>
+    
+    <!-- Pagination -->
+    {% if has_more_pages %}
+    <nav class="pagination is-centered" role="navigation">
+        <button class="pagination-previous button" 
+                hx-get="/events?page={{ current_page - 1 }}"
+                hx-target="#events-results"
+                hx-include="closest form"
+                hx-headers='{"HX-Current-Language": "{{ current_locale() }}"}'>
+            {{ t("pagination-previous") }}
+        </button>
+        <button class="pagination-next button"
+                hx-get="/events?page={{ current_page + 1 }}"
+                hx-target="#events-results" 
+                hx-include="closest form"
+                hx-headers='{"HX-Current-Language": "{{ current_locale() }}"}'>
+            {{ t("pagination-next") }}
+        </button>
+    </nav>
+    {% endif %}
+{% else %}
+    <div class="notification is-info">
+        <p>{{ t("filter-no-results") }}</p>
+        <p>{{ t("filter-try-different-criteria") }}</p>
+    </div>
+{% endif %}
+```
+
+### Task 6: Update Route Registration
+
+#### 6.1 Ensure I18n Middleware Integration
+**File**: `/src/http/mod.rs` (or main router setup)
+
+```rust
+// Ensure filtering routes have i18n middleware
+pub fn create_filtering_routes() -> Router<WebContext> {
+    Router::new()
+        .route("/events", get(handle_filter_events))
+        .route("/events/facets", get(handle_filter_facets))
+        .route("/events/suggestions", get(handle_filter_suggestions))
+        // Middleware stack includes i18n detection
+        .layer(from_fn(middleware_i18n::detect_language))
+        .layer(from_fn(middleware_filter::extract_filter_params))
+}
+```
+
+### Task 7: Testing Integration
+
+#### 7.1 Update Existing Tests
+**File**: `/src/filtering/facets.rs` - Add i18n tests
+
+```rust
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use unic_langid::langid;
+
+    #[test]
+    fn test_generate_category_i18n_key() {
+        assert_eq!(
+            FacetCalculator::generate_category_i18n_key("Technology & Innovation"),
+            "category.technology_and_innovation"
+        );
+        
+        assert_eq!(
+            FacetCalculator::generate_category_i18n_key("Arts & Culture"),
+            "category.arts_and_culture"
+        );
+    }
+
+    #[test]
+    fn test_get_translated_facet_name() {
+        let calculator = FacetCalculator::new(/* mock pool */);
+        let locale = langid!("en-US");
+        
+        // Test with existing translation key
+        let translated = calculator.get_translated_facet_name(
+            "category.technology_and_innovation", 
+            &locale
+        );
+        
+        // Should return translated text if key exists, otherwise formatted fallback
+        assert!(!translated.is_empty());
+    }
+
+    #[sqlx::test]
+    async fn test_facet_calculation_with_locale() {
+        // Integration test with real database
+        let pool = setup_test_db().await;
+        let calculator = FacetCalculator::new(pool);
+        let criteria = EventFilterCriteria::default();
+        let locale = langid!("en-US");
+        
+        let facets = calculator
+            .calculate_facets_with_locale(&criteria, &locale)
+            .await
+            .unwrap();
+        
+        // Verify facets have proper i18n keys and display names
+        for category in &facets.categories {
+            assert!(category.i18n_key.is_some());
+            assert!(category.display_name.is_some());
+        }
+    }
+}
+```
+
+#### 7.2 Add I18n Template Tests
+**File**: `/tests/integration/filter_i18n_test.rs`
+
+```rust
+#[tokio::test]
+async fn test_filter_page_renders_with_locale() {
+    let app = create_test_app().await;
+    
+    // Test English
+    let response = app
+        .oneshot(
+            Request::builder()
+                .uri("/events")
+                .header("Accept-Language", "en-US,en;q=0.9")
+                .body(Body::empty())
+                .unwrap(),
+        )
+        .await
+        .unwrap();
+    
+    assert_eq!(response.status(), StatusCode::OK);
+    let body = to_bytes(response.into_body(), usize::MAX).await.unwrap();
+    let html = String::from_utf8(body.to_vec()).unwrap();
+    
+    // Verify English translations are used
+    assert!(html.contains("Filter Options"));
+    assert!(html.contains("Categories"));
+    
+    // Test French
+    let response = app
+        .oneshot(
+            Request::builder()
+                .uri("/events")
+                .header("Accept-Language", "fr-CA,fr;q=0.9")
+                .body(Body::empty())
+                .unwrap(),
+        )
+        .await
+        .unwrap();
+    
+    let body = to_bytes(response.into_body(), usize::MAX).await.unwrap();
+    let html = String::from_utf8(body.to_vec()).unwrap();
+    
+    // Verify French translations are used
+    assert!(html.contains("Options de filtrage"));
+    assert!(html.contains("Catégories"));
+}
+
+#[tokio::test]
+async fn test_htmx_facet_updates_preserve_language() {
+    let app = create_test_app().await;
+    
+    let response = app
+        .oneshot(
+            Request::builder()
+                .uri("/events")
+                .method("GET")
+                .header("HX-Request", "true")
+                .header("HX-Current-Language", "fr-ca")
+                .body(Body::empty())
+                .unwrap(),
+        )
+        .await
+        .unwrap();
+    
+    assert_eq!(response.status(), StatusCode::OK);
+    
+    // Verify HTMX response includes proper language context
+    let headers = response.headers();
+    assert!(headers.contains_key("HX-Language"));
+}
+```
+
+---
+
+## Implementation Order
+
+### Phase 4A: Foundation (Day 1)
+1. **Add translation keys** to both language files
+2. **Update FacetValue structure** with display_name field
+3. **Extend FacetCalculator** with locale-aware methods
+
+### Phase 4B: Service Integration (Day 1-2)
+1. **Update FilteringService** to accept locale parameter  
+2. **Modify HTTP handlers** to extract and use locale
+3. **Update cache keys** to include locale for proper separation
+
+### Phase 4C: Template Migration (Day 2)
+1. **Create unified templates** using i18n functions
+2. **Remove language-specific .common.html files**
+3. **Update HTMX result templates** with proper language headers
+
+### Phase 4D: Testing & Validation (Day 2-3)
+1. **Run existing test suite** to ensure no regressions
+2. **Add i18n-specific tests** for facet calculation and template rendering
+3. **Manual testing** of language switching and HTMX updates
+4. **Performance validation** with locale-aware caching
+
+---
+
+## Expected Outcomes
+
+### ✅ Features Delivered
+
+1. **Locale-Aware Facets**: Category and date range facets display in user's language
+2. **Dynamic Template Functions**: All filter templates use `t()` functions instead of hardcoded text
+3. **HTMX Language Propagation**: Partial updates maintain language context
+4. **Intelligent Fallbacks**: Graceful degradation when translations missing
+5. **Cache Efficiency**: Locale-specific caching without excessive memory usage
+
+### 🚀 Performance Benefits
+
+- **Zero Runtime Translation Overhead**: fluent-templates static loading
+- **Intelligent Caching**: Locale-aware cache keys prevent cross-language contamination  
+- **Efficient Facet Calculation**: Pre-computed display names reduce template complexity
+- **HTMX Optimization**: Language headers minimize full page reloads
+
+### 🧪 Quality Assurance
+
+- **Comprehensive Test Coverage**: Unit, integration, and i18n-specific tests
+- **Translation Validation**: Automated checking for missing keys
+- **Manual Testing**: Cross-language functionality validation
+- **Performance Monitoring**: Cache hit rates and response times
+
+---
+
+## Risk Mitigation
+
+### Potential Issues
+
+1. **Cache Key Explosion**: Including locale in cache keys increases memory usage
+   - **Solution**: Implement cache size limits and intelligent eviction
+   
+2. **Translation Key Mismatches**: Category names may not match translation keys
+   - **Solution**: Fallback logic to generate readable names from keys
+   
+3. **Template Complexity**: Unified templates may be harder to debug
+   - **Solution**: Maintain clear separation and good commenting
+
+### Rollback Plan
+
+- **Feature Flag**: Implement `enable_filter_i18n` flag for quick disable
+- **Template Fallback**: Keep original language-specific templates as backup
+- **Cache Compatibility**: Ensure new cache keys don't break existing cache
+
+---
+
+## Conclusion
+
+Phase 4 delivers a fully internationalized filtering system that seamlessly integrates with the existing i18n infrastructure. The implementation maintains backward compatibility while providing significant improvements in user experience for French Canadian users and establishes a solid foundation for additional languages in the future.
+
+The approach emphasizes performance (static loading, intelligent caching), maintainability (unified templates, clear fallbacks), and user experience (HTMX-aware language propagation, locale-specific facets).

i18n/en-us/ui.ftl

···
 filter-per-page = per page
 filter-loading = Loading events...
 filter-facets-title = Filter Options
-filter-categories-label = Categories
+filter-modes-label = Event Type
+filter-statuses-label = Event Status
 filter-creators-label = Event Organizers
 filter-results-title = Events Found
 filter-no-results-title = No events found
 filter-no-results-message = Try adjusting your search criteria or location filters.
 
+# Event Mode Labels
+community-lexicon-calendar-event-mode-inperson = In Person
+community-lexicon-calendar-event-mode-virtual = Virtual
+community-lexicon-calendar-event-mode-hybrid = Hybrid
+
+# Event Status Labels
+community-lexicon-calendar-event-status-scheduled = Scheduled
+community-lexicon-calendar-event-status-rescheduled = Rescheduled
+community-lexicon-calendar-event-status-cancelled = Cancelled
+community-lexicon-calendar-event-status-postponed = Postponed
+community-lexicon-calendar-event-status-planned = Planned
+
 # Pagination
 pagination-previous = Previous
 pagination-next = Next
···
 # Event details
 event-starts = Starts
 event-location = Location
+
+# Event Category Facets
+category-arts-and-culture = Arts & Culture
+category-business-and-networking = Business & Networking
+category-community-and-social = Community & Social
+category-education-and-learning = Education & Learning
+category-family-and-kids = Family & Kids
+category-food-and-drink = Food & Drink
+category-health-and-wellness = Health & Wellness
+category-music-and-entertainment = Music & Entertainment
+category-outdoor-and-recreation = Outdoor & Recreation
+category-politics-and-activism = Politics & Activism
+category-religion-and-spirituality = Religion & Spirituality
+category-sports-and-fitness = Sports & Fitness
+category-technology-and-innovation = Technology & Innovation
+category-travel-and-adventure = Travel & Adventure
+category-volunteer-and-charity = Volunteer & Charity
+
+# Date Range Facets
+date-range-today = Today
+date-range-this-week = This Week
+date-range-this-month = This Month
+date-range-next-week = Next Week
+date-range-next-month = Next Month

i18n/fr-ca/ui.ftl

···
 filter-per-page = par page
 filter-loading = Chargement des événements...
 filter-facets-title = Options de filtrage
-filter-categories-label = Catégories
+filter-modes-label = Type d'événement
+filter-statuses-label = Statut de l'événement
 filter-creators-label = Organisateurs d'événements
 filter-results-title = Événements trouvés
 filter-no-results-title = Aucun événement trouvé
 filter-no-results-message = Essayez d'ajuster vos critères de recherche ou filtres de lieu.
 
+# Étiquettes de mode d'événement
+community-lexicon-calendar-event-mode-inperson = En personne
+community-lexicon-calendar-event-mode-virtual = Virtuel
+community-lexicon-calendar-event-mode-hybrid = Hybride
+
+# Étiquettes de statut d'événement
+community-lexicon-calendar-event-status-scheduled = Programmé
+community-lexicon-calendar-event-status-rescheduled = Reprogrammé
+community-lexicon-calendar-event-status-cancelled = Annulé
+community-lexicon-calendar-event-status-postponed = Reporté
+community-lexicon-calendar-event-status-planned = Planifié
+
 # Pagination
 pagination-previous = Précédent
 pagination-next = Suivant
···
 # Détails de l'événement
 event-starts = Commence
 event-location = Lieu
+
+# Facettes de catégories d'événements
+category-arts-and-culture = Arts et culture
+category-business-and-networking = Affaires et réseautage
+category-community-and-social = Communauté et social
+category-education-and-learning = Éducation et apprentissage
+category-family-and-kids = Famille et enfants
+category-food-and-drink = Nourriture et boissons
+category-health-and-wellness = Santé et bien-être
+category-music-and-entertainment = Musique et divertissement
+category-outdoor-and-recreation = Plein air et loisirs
+category-politics-and-activism = Politique et activisme
+category-religion-and-spirituality = Religion et spiritualité
+category-sports-and-fitness = Sports et conditionnement physique
+category-technology-and-innovation = Technologie et innovation
+category-travel-and-adventure = Voyage et aventure
+category-volunteer-and-charity = Bénévolat et charité
+
+# Facettes de plages de dates
+date-range-today = Aujourd'hui
+date-range-this-week = Cette semaine
+date-range-this-month = Ce mois-ci
+date-range-next-week = La semaine prochaine
+date-range-next-month = Le mois prochain

src/atproto/lexicon/community_lexicon_calendar_event.rs

···
 
 pub const NSID: &str = "community.lexicon.calendar.event";
 
-#[derive(Debug, Serialize, Deserialize, PartialEq, Clone, Default)]
+#[derive(Debug, Serialize, Deserialize, PartialEq, Clone, Default, Hash)]
 pub enum Status {
     #[default]
     #[serde(rename = "community.lexicon.calendar.event#scheduled")]
···
     Planned,
 }
 
-#[derive(Debug, Serialize, Deserialize, PartialEq, Clone, Default)]
+#[derive(Debug, Serialize, Deserialize, PartialEq, Clone, Default, Hash)]
 pub enum Mode {
     #[default]
     #[serde(rename = "community.lexicon.calendar.event#inperson")]

src/filtering/cache_integration_test.rs

···
 
     #[test]
     fn test_cache_key_generation() {
+        use crate::atproto::lexicon::community::lexicon::calendar::event::{Mode, Status};
+        
         // Test that cache keys are generated consistently
         let criteria = EventFilterCriteria {
             search_term: Some("test".to_string()),
-            categories: vec!["Technology".to_string()],
+            modes: vec![Mode::InPerson],
+            statuses: vec![Status::Scheduled],
             ..Default::default()
         };
         
···
         // Different criteria should generate different hash
         let criteria2 = EventFilterCriteria {
             search_term: Some("different".to_string()),
-            categories: vec!["Technology".to_string()],
+            modes: vec![Mode::InPerson],
+            statuses: vec![Status::Scheduled],
             ..Default::default()
         };
         

src/filtering/criteria.rs

···
 use std::collections::hash_map::DefaultHasher;
 use std::hash::{Hash, Hasher};
 
+use crate::atproto::lexicon::community::lexicon::calendar::event::{Mode, Status};
+
 /// Main filter criteria structure containing all possible filter options
 #[derive(Debug, Clone, Serialize, Deserialize, Default, Hash)]
 pub struct EventFilterCriteria {
···
     /// Location-based filtering
     pub location: Option<LocationFilter>,
     
-    /// Categories to filter by
-    pub categories: Vec<String>,
+    /// Filter by event mode (InPerson, Virtual, Hybrid)
+    pub modes: Vec<Mode>,
+    
+    /// Filter by event status (Scheduled, Cancelled, etc.)
+    pub statuses: Vec<Status>,
     
     /// Sorting configuration
     pub sort_by: EventSortField,
···
         self
     }
     
-    /// Add category filter
-    pub fn with_category(mut self, category: impl Into<String>) -> Self {
-        self.categories.push(category.into());
+    /// Add mode filter
+    pub fn with_mode(mut self, mode: Mode) -> Self {
+        self.modes.push(mode);
+        self
+    }
+    
+    /// Add status filter
+    pub fn with_status(mut self, status: Status) -> Self {
+        self.statuses.push(status);
         self
     }
     
···
             || self.end_date.is_some()
             || self.creator_did.is_some()
             || self.location.is_some()
-            || !self.categories.is_empty()
+            || !self.modes.is_empty()
+            || !self.statuses.is_empty()
     }
     
     /// Generate a cache hash for this criteria

src/filtering/facets.rs

···
 use chrono::Datelike;
 
 use super::{EventFilterCriteria, FilterError};
+use crate::atproto::lexicon::community::lexicon::calendar::event::{Mode, Status};
 
 /// Represents a single facet value with its count
 #[derive(Debug, Clone, Serialize, Deserialize)]
···
 /// Collection of facets for different dimensions
 #[derive(Debug, Clone, Serialize, Deserialize, Default)]
 pub struct EventFacets {
-    pub categories: Vec<FacetValue>,
+    pub modes: Vec<FacetValue>,
+    pub statuses: Vec<FacetValue>,
     pub creators: Vec<FacetValue>,
     pub date_ranges: Vec<FacetValue>,
     pub total_count: i64,
···
         // Calculate total count
         facets.total_count = self.calculate_total_count(criteria).await?;
         
-        // Calculate category facets
-        facets.categories = self.calculate_category_facets(criteria).await?;
+        // Calculate mode facets
+        facets.modes = self.calculate_mode_facets(criteria).await?;
+        
+        // Calculate status facets
+        facets.statuses = self.calculate_status_facets(criteria).await?;
         
         // Calculate creator facets
         facets.creators = self.calculate_creator_facets(criteria).await?;
···
         Ok(count.0)
     }
     
-    /// Calculate category facets
-    async fn calculate_category_facets(
+    /// Calculate mode facets
+    async fn calculate_mode_facets(
         &self,
         criteria: &EventFilterCriteria,
     ) -> Result<Vec<FacetValue>, FilterError> {
         let mut query = QueryBuilder::new(
-            "SELECT jsonb_array_elements_text(record->'categories') as category, COUNT(*) as count 
-             FROM events"
+            "SELECT record->>'mode' as mode, COUNT(*) as count FROM events"
         );
         
-        // Apply filters excluding categories to show all available categories
-        let criteria_without_categories = EventFilterCriteria {
-            categories: vec![], // Exclude category filters for facet calculation
+        // Apply filters excluding modes to show all available modes
+        let criteria_without_modes = EventFilterCriteria {
+            modes: vec![], // Exclude mode filters for facet calculation
             ..criteria.clone()
         };
-        self.apply_base_filters(&mut query, &criteria_without_categories);
+        self.apply_base_filters(&mut query, &criteria_without_modes);
         
-        query.push(" AND record->'categories' IS NOT NULL");
-        query.push(" GROUP BY category");
-        query.push(" ORDER BY count DESC, category ASC");
-        query.push(" LIMIT 50"); // Limit facet results
+        query.push(" AND record->>'mode' IS NOT NULL");
+        query.push(" GROUP BY mode");
+        query.push(" ORDER BY count DESC, mode ASC");
         
         let rows = query
             .build()
···
         
         let mut facets = Vec::new();
         for row in rows {
-            let category: String = row.try_get("category")?;
+            let mode_str: Option<String> = row.try_get("mode")?;
             let count: i64 = row.try_get("count")?;
             
-            facets.push(FacetValue {
-                i18n_key: Some(Self::generate_category_i18n_key(&category)),
-                value: category,
-                count,
-            });
+            if let Some(mode_str) = mode_str {
+                facets.push(FacetValue {
+                    value: mode_str.clone(),
+                    count,
+                    i18n_key: Some(Self::generate_mode_i18n_key(&mode_str)),
+                });
+            }
+        }
+        
+        Ok(facets)
+    }
+    
+    /// Calculate status facets
+    async fn calculate_status_facets(
+        &self,
+        criteria: &EventFilterCriteria,
+    ) -> Result<Vec<FacetValue>, FilterError> {
+        let mut query = QueryBuilder::new(
+            "SELECT record->>'status' as status, COUNT(*) as count FROM events"
+        );
+        
+        // Apply filters excluding statuses to show all available statuses
+        let criteria_without_statuses = EventFilterCriteria {
+            statuses: vec![], // Exclude status filters for facet calculation
+            ..criteria.clone()
+        };
+        self.apply_base_filters(&mut query, &criteria_without_statuses);
+        
+        query.push(" AND record->>'status' IS NOT NULL");
+        query.push(" GROUP BY status");
+        query.push(" ORDER BY count DESC, status ASC");
+        
+        let rows = query
+            .build()
+            .fetch_all(&self.pool)
+            .await?;
+        
+        let mut facets = Vec::new();
+        for row in rows {
+            let status_str: Option<String> = row.try_get("status")?;
+            let count: i64 = row.try_get("count")?;
+            
+            if let Some(status_str) = status_str {
+                facets.push(FacetValue {
+                    value: status_str.clone(),
+                    count,
+                    i18n_key: Some(Self::generate_status_i18n_key(&status_str)),
+                });
+            }
         }
         
         Ok(facets)
···
                 facets.push(FacetValue {
                     value: key.to_string(),
                     count,
-                    i18n_key: Some(format!("date_range.{}", key)),
+                    i18n_key: Some(format!("date-range-{}", key)),
                 });
             }
         }
···
             has_where = true;
         }
         
-        // Category filtering
-        if !criteria.categories.is_empty() {
+        // Mode filtering
+        if !criteria.modes.is_empty() {
             query.push(if has_where { " AND " } else { " WHERE " });
             query.push("(");
-            for (i, category) in criteria.categories.iter().enumerate() {
+            for (i, mode) in criteria.modes.iter().enumerate() {
                 if i > 0 {
                     query.push(" OR ");
                 }
-                query.push("record->'categories' ? ");
-                query.push_bind(category);
+                // Convert Mode enum to its string representation
+                let mode_str = match mode {
+                    Mode::InPerson => "community.lexicon.calendar.event#inperson",
+                    Mode::Virtual => "community.lexicon.calendar.event#virtual",
+                    Mode::Hybrid => "community.lexicon.calendar.event#hybrid",
+                };
+                query.push("record->>'mode' = ");
+                query.push_bind(mode_str);
+            }
+            query.push(")");
+            has_where = true;
+        }
+        
+        // Status filtering
+        if !criteria.statuses.is_empty() {
+            query.push(if has_where { " AND " } else { " WHERE " });
+            query.push("(");
+            for (i, status) in criteria.statuses.iter().enumerate() {
+                if i > 0 {
+                    query.push(" OR ");
+                }
+                // Convert Status enum to its string representation
+                let status_str = match status {
+                    Status::Scheduled => "community.lexicon.calendar.event#scheduled",
+                    Status::Rescheduled => "community.lexicon.calendar.event#rescheduled",
+                    Status::Cancelled => "community.lexicon.calendar.event#cancelled",
+                    Status::Postponed => "community.lexicon.calendar.event#postponed",
+                    Status::Planned => "community.lexicon.calendar.event#planned",
+                };
+                query.push("record->>'status' = ");
+                query.push_bind(status_str);
             }
             query.push(")");
             has_where = true;
···
         }
     }
     
-    /// Generate i18n key for category facets
-    fn generate_category_i18n_key(category: &str) -> String {
-        format!("category.{}", 
-            category.to_lowercase()
-                .replace(" ", "_")
-                .replace("&", "and")
-                .chars()
-                .filter(|c| c.is_alphanumeric() || *c == '_')
-                .collect::<String>()
-        )
+    /// Generate i18n key for mode facets
+    fn generate_mode_i18n_key(mode: &str) -> String {
+        match mode {
+            "community.lexicon.calendar.event#inperson" => "mode-inperson".to_string(),
+            "community.lexicon.calendar.event#virtual" => "mode-virtual".to_string(),
+            "community.lexicon.calendar.event#hybrid" => "mode-hybrid".to_string(),
+            _ => format!("mode-{}", mode.to_lowercase().replace('#', "-").replace('.', "-")),
+        }
+    }
+    
+    /// Generate i18n key for status facets
+    fn generate_status_i18n_key(status: &str) -> String {
+        match status {
+            "community.lexicon.calendar.event#scheduled" => "status-scheduled".to_string(),
+            "community.lexicon.calendar.event#rescheduled" => "status-rescheduled".to_string(),
+            "community.lexicon.calendar.event#cancelled" => "status-cancelled".to_string(),
+            "community.lexicon.calendar.event#postponed" => "status-postponed".to_string(),
+            "community.lexicon.calendar.event#planned" => "status-planned".to_string(),
+            _ => format!("status-{}", status.to_lowercase().replace('#', "-").replace('.', "-")),
+        }
     }
 }
 
···
     use super::*;
 
     #[test]
-    fn test_generate_category_i18n_key() {
+    fn test_generate_mode_i18n_key() {
         assert_eq!(
-            FacetCalculator::generate_category_i18n_key("Technology & Innovation"),
-            "category.technology_and_innovation"
+            FacetCalculator::generate_mode_i18n_key("community.lexicon.calendar.event#inperson"),
+            "mode-inperson"
         );
         
         assert_eq!(
-            FacetCalculator::generate_category_i18n_key("Arts & Culture"),
-            "category.arts_and_culture"
+            FacetCalculator::generate_mode_i18n_key("community.lexicon.calendar.event#virtual"),
+            "mode-virtual"
+        );
+    }
+
+    #[test]
+    fn test_generate_status_i18n_key() {
+        assert_eq!(
+            FacetCalculator::generate_status_i18n_key("community.lexicon.calendar.event#scheduled"),
+            "status-scheduled"
+        );
+        
+        assert_eq!(
+            FacetCalculator::generate_status_i18n_key("community.lexicon.calendar.event#cancelled"),
+            "status-cancelled"
         );
     }
 }

src/filtering/mod.rs

···
 #[cfg(test)]
 mod cache_integration_test;
 
+#[cfg(test)]
+mod mode_status_integration_test;
+
 pub use criteria::*;
 pub use errors::*;
 pub use facets::*;

src/filtering/mode_status_integration_test.rs

···
+// Integration test for mode and status filtering
+//
+// Tests the complete filtering pipeline from HTTP parameters to SQL queries
+
+#[cfg(test)]
+mod tests {
+    use crate::filtering::{EventFilterCriteria, EventFacets, FacetValue};
+    use crate::atproto::lexicon::community::lexicon::calendar::event::{Mode, Status};
+
+    #[test]
+    fn test_mode_status_filtering_pipeline() {
+        // Test direct criteria building with modes and statuses
+        let criteria = EventFilterCriteria::new()
+            .with_mode(Mode::InPerson)
+            .with_mode(Mode::Virtual)
+            .with_status(Status::Scheduled)
+            .with_status(Status::Cancelled);
+        
+        assert_eq!(criteria.modes.len(), 2);
+        assert!(criteria.modes.contains(&Mode::InPerson));
+        assert!(criteria.modes.contains(&Mode::Virtual));
+        
+        assert_eq!(criteria.statuses.len(), 2);
+        assert!(criteria.statuses.contains(&Status::Scheduled));
+        assert!(criteria.statuses.contains(&Status::Cancelled));
+    }
+
+    #[test]
+    fn test_mode_status_facet_generation() {
+        // Test that facets can be generated for modes and statuses
+        let modes = vec![
+            FacetValue { 
+                value: "inperson".to_string(), 
+                count: 5, 
+                i18n_key: Some("community-lexicon-calendar-event-mode-inperson".to_string()) 
+            },
+            FacetValue { 
+                value: "virtual".to_string(), 
+                count: 3, 
+                i18n_key: Some("community-lexicon-calendar-event-mode-virtual".to_string()) 
+            },
+        ];
+        
+        let statuses = vec![
+            FacetValue { 
+                value: "scheduled".to_string(), 
+                count: 8, 
+                i18n_key: Some("community-lexicon-calendar-event-status-scheduled".to_string()) 
+            },
+        ];
+
+        let facets = EventFacets {
+            modes,
+            statuses,
+            ..Default::default()
+        };
+
+        assert_eq!(facets.modes.len(), 2);
+        assert_eq!(facets.statuses.len(), 1);
+        assert_eq!(facets.modes[0].count, 5);
+        assert_eq!(facets.statuses[0].count, 8);
+    }
+
+    #[test]
+    fn test_criteria_has_filters() {
+        // Test that criteria correctly reports when filters are active
+        let empty_criteria = EventFilterCriteria::new();
+        assert!(!empty_criteria.has_filters());
+
+        let mode_criteria = EventFilterCriteria::new().with_mode(Mode::InPerson);
+        assert!(mode_criteria.has_filters());
+
+        let status_criteria = EventFilterCriteria::new().with_status(Status::Scheduled);
+        assert!(status_criteria.has_filters());
+    }
+
+    #[test]
+    fn test_cache_key_includes_modes_and_statuses() {
+        // Test that cache keys include mode and status information
+        let criteria1 = EventFilterCriteria::new()
+            .with_mode(Mode::InPerson)
+            .with_status(Status::Scheduled);
+
+        let criteria2 = EventFilterCriteria::new()
+            .with_mode(Mode::Virtual)
+            .with_status(Status::Scheduled);
+
+        // Different modes should result in different cache keys
+        assert_ne!(criteria1.cache_hash(), criteria2.cache_hash());
+    }
+}

src/filtering/query_builder.rs

···
 
 use super::{EventFilterCriteria, EventSortField, FilterError, LocationFilter, SortOrder};
 use crate::storage::event::model::Event;
+use crate::atproto::lexicon::community::lexicon::calendar::event::{Mode, Status};
 
 /// SQL query builder for event filtering
 #[derive(Debug, Clone)]
···
             has_where = true;
         }
         
-        // Category filtering
-        if !criteria.categories.is_empty() {
+        // Mode filtering
+        if !criteria.modes.is_empty() {
+            query.push(if has_where { " AND " } else { " WHERE " });
+            query.push("(");
+            for (i, mode) in criteria.modes.iter().enumerate() {
+                if i > 0 {
+                    query.push(" OR ");
+                }
+                // Convert enum to its serde representation for database comparison
+                let mode_str = match mode {
+                    Mode::InPerson => 
+                        "community.lexicon.calendar.event#inperson",
+                    Mode::Virtual => 
+                        "community.lexicon.calendar.event#virtual",
+                    Mode::Hybrid => 
+                        "community.lexicon.calendar.event#hybrid",
+                };
+                query.push("record->>'mode' = ");
+                query.push_bind(mode_str);
+            }
+            query.push(")");
+            has_where = true;
+        }
+        
+        // Status filtering
+        if !criteria.statuses.is_empty() {
             query.push(if has_where { " AND " } else { " WHERE " });
             query.push("(");
-            for (i, category) in criteria.categories.iter().enumerate() {
+            for (i, status) in criteria.statuses.iter().enumerate() {
                 if i > 0 {
                     query.push(" OR ");
                 }
-                query.push("record->'categories' ? ");
-                query.push_bind(category);
+                // Convert enum to its serde representation for database comparison
+                let status_str = match status {
+                    Status::Scheduled => 
+                        "community.lexicon.calendar.event#scheduled",
+                    Status::Rescheduled => 
+                        "community.lexicon.calendar.event#rescheduled",
+                    Status::Cancelled => 
+                        "community.lexicon.calendar.event#cancelled",
+                    Status::Postponed => 
+                        "community.lexicon.calendar.event#postponed",
+                    Status::Planned => 
+                        "community.lexicon.calendar.event#planned",
+                };
+                query.push("record->>'status' = ");
+                query.push_bind(status_str);
             }
             query.push(")");
             has_where = true;

src/filtering/service.rs

···
             }
         }
         
-        // Validate categories
-        if criteria.categories.len() > 20 {
-            return Err(FilterError::invalid_criteria("Too many categories (max 20)"));
+        // Validate modes
+        if criteria.modes.len() > 10 {
+            return Err(FilterError::invalid_criteria("Too many modes (max 10)"));
+        }
+        
+        // Validate statuses
+        if criteria.statuses.len() > 10 {
+            return Err(FilterError::invalid_criteria("Too many statuses (max 10)"));
         }
         
         Ok(())

src/http/middleware_filter.rs

···
 use tracing::{instrument, warn};
 
 use crate::filtering::{EventFilterCriteria, EventSortField, LocationFilter, SortOrder};
+use crate::atproto::lexicon::community::lexicon::calendar::event::{Mode, Status};
 
 /// Query parameters for event filtering
 #[derive(Debug, Clone, Deserialize, Serialize)]
···
     /// Creator DID
     pub creator: Option<String>,
     
-    /// Categories (comma-separated or multiple params)
-    pub categories: Option<String>,
+    /// Event modes (comma-separated or multiple params)
+    pub modes: Option<String>,
+    
+    /// Event statuses (comma-separated or multiple params)
+    pub statuses: Option<String>,
     
     /// Location latitude
     pub lat: Option<f64>,
···
         }
     }
     
-    // Categories
-    if let Some(ref categories_str) = params.categories {
-        criteria.categories = parse_categories(categories_str);
+    // Modes
+    if let Some(ref modes_str) = params.modes {
+        criteria.modes = parse_modes(modes_str);
+    }
+    
+    // Statuses
+    if let Some(ref statuses_str) = params.statuses {
+        criteria.statuses = parse_statuses(statuses_str);
     }
     
     // Location
···
     }
 }
 
-/// Parse categories from comma-separated string
-fn parse_categories(categories_str: &str) -> Vec<String> {
-    categories_str
+/// Parse modes from comma-separated string
+fn parse_modes(modes_str: &str) -> Vec<Mode> {
+    modes_str
         .split(',')
-        .map(|s| s.trim().to_string())
+        .map(|s| s.trim().to_lowercase())
         .filter(|s| !s.is_empty())
+        .filter_map(|s| match s.as_str() {
+            "inperson" | "in-person" | "in_person" => Some(Mode::InPerson),
+            "virtual" => Some(Mode::Virtual),
+            "hybrid" => Some(Mode::Hybrid),
+            _ => None,
+        })
+        .collect()
+}
+
+/// Parse statuses from comma-separated string
+fn parse_statuses(statuses_str: &str) -> Vec<Status> {
+    statuses_str
+        .split(',')
+        .map(|s| s.trim().to_lowercase())
+        .filter(|s| !s.is_empty())
+        .filter_map(|s| match s.as_str() {
+            "scheduled" => Some(Status::Scheduled),
+            "rescheduled" => Some(Status::Rescheduled),
+            "cancelled" | "canceled" => Some(Status::Cancelled),
+            "postponed" => Some(Status::Postponed),
+            "planned" => Some(Status::Planned),
+            _ => None,
+        })
         .collect()
 }
 
···
             start_date: None,
             end_date: None,
             creator: None,
-            categories: None,
+            modes: None,
+            statuses: None,
             lat: None,
             lng: None,
             radius: None,
···
     }
 
     #[test]
-    fn test_parse_categories() {
-        let categories = parse_categories("tech,music, arts");
-        assert_eq!(categories, vec!["tech", "music", "arts"]);
+    fn test_parse_modes() {
+        let modes = parse_modes("inperson,virtual,hybrid");
+        assert_eq!(modes, vec![Mode::InPerson, Mode::Virtual, Mode::Hybrid]);
         
-        let empty = parse_categories("");
+        let with_variations = parse_modes("in-person, virtual, hybrid");
+        assert_eq!(with_variations, vec![Mode::InPerson, Mode::Virtual, Mode::Hybrid]);
+        
+        let empty = parse_modes("");
+        assert!(empty.is_empty());
+    }
+
+    #[test]
+    fn test_parse_statuses() {
+        let statuses = parse_statuses("scheduled,cancelled,planned");
+        assert_eq!(statuses, vec![Status::Scheduled, Status::Cancelled, Status::Planned]);
+        
+        let with_variations = parse_statuses("canceled, postponed");
+        assert_eq!(with_variations, vec![Status::Cancelled, Status::Postponed]);
+        
+        let empty = parse_statuses("");
         assert!(empty.is_empty());
     }
 

templates/filter_events.en-us.common.html

···
                 <div class="box">
                     <h3 class="title is-6">{{ tr("filter-facets-title") }}</h3>
                     
-                    <!-- Category Facets -->
-                    {% if facets.categories %}
+                    <!-- Mode Facets -->
+                    {% if facets.modes %}
+                    <div class="field">
+                        <label class="label">{{ tr("filter-modes-label") }}</label>
+                        {% for mode in facets.modes %}
+                        <div class="control">
+                            <label class="checkbox">
+                                <input type="checkbox" 
+                                       name="modes" 
+                                       value="{{ mode.name }}"
+                                       {% if mode.name in filter_criteria.modes %}checked{% endif %}
+                                       hx-get="/events" 
+                                       hx-target="#events-results"
+                                       hx-include="closest form">
+                                {{ tr(mode.i18n_key) }} ({{ mode.count }})
+                            </label>
+                        </div>
+                        {% endfor %}
+                    </div>
+                    {% endif %}
+                    
+                    <!-- Status Facets -->
+                    {% if facets.statuses %}
                     <div class="field">
-                        <label class="label">{{ tr("filter-categories-label") }}</label>
-                        {% for category in facets.categories %}
+                        <label class="label">{{ tr("filter-statuses-label") }}</label>
+                        {% for status in facets.statuses %}
                         <div class="control">
                             <label class="checkbox">
                                 <input type="checkbox" 
-                                       name="categories" 
-                                       value="{{ category.name }}"
-                                       {% if category.name in filter_criteria.categories %}checked{% endif %}
+                                       name="statuses" 
+                                       value="{{ status.name }}"
+                                       {% if status.name in filter_criteria.statuses %}checked{% endif %}
                                        hx-get="/events" 
                                        hx-target="#events-results"
                                        hx-include="closest form">
-                                {{ category.name }} ({{ category.count }})
+                                {{ tr(status.i18n_key) }} ({{ status.count }})
                             </label>
                         </div>
                         {% endfor %}

templates/filter_events.fr-ca.common.html

···
                 <div class="box">
                     <h3 class="title is-6">{{ tr("filter-facets-title") }}</h3>
                     
-                    <!-- Category Facets -->
-                    {% if facets.categories %}
+                    <!-- Mode Facets -->
+                    {% if facets.modes %}
+                    <div class="field">
+                        <label class="label">{{ tr("filter-modes-label") }}</label>
+                        {% for mode in facets.modes %}
+                        <div class="control">
+                            <label class="checkbox">
+                                <input type="checkbox" 
+                                       name="modes" 
+                                       value="{{ mode.name }}"
+                                       {% if mode.name in filter_criteria.modes %}checked{% endif %}
+                                       hx-get="/events" 
+                                       hx-target="#events-results"
+                                       hx-include="closest form">
+                                {{ tr(mode.i18n_key) }} ({{ mode.count }})
+                            </label>
+                        </div>
+                        {% endfor %}
+                    </div>
+                    {% endif %}
+                    
+                    <!-- Status Facets -->
+                    {% if facets.statuses %}
                     <div class="field">
-                        <label class="label">{{ tr("filter-categories-label") }}</label>
-                        {% for category in facets.categories %}
+                        <label class="label">{{ tr("filter-statuses-label") }}</label>
+                        {% for status in facets.statuses %}
                         <div class="control">
                             <label class="checkbox">
                                 <input type="checkbox" 
-                                       name="categories" 
-                                       value="{{ category.name }}"
-                                       {% if category.name in filter_criteria.categories %}checked{% endif %}
+                                       name="statuses" 
+                                       value="{{ status.name }}"
+                                       {% if status.name in filter_criteria.statuses %}checked{% endif %}
                                        hx-get="/events" 
                                        hx-target="#events-results"
                                        hx-include="closest form">
-                                {{ category.name }} ({{ category.count }})
+                                {{ tr(status.i18n_key) }} ({{ status.count }})
                             </label>
                         </div>
                         {% endfor %}