feat: Complete iCal download with i18n integration

- Add locale-aware iCal generation with fluent-templates
- Implement AT Protocol organizer format (CN=Name:at://handle)
- Add localized fallbacks for missing event data
- Include download buttons in EN/FR event templates
- Add 6 new translation keys for iCal content
- Generate sanitized filenames with i18n templates
- Support timezone-aware RFC 5545 compliant output

Cargo.toml

···
 metrohash = "1.0.7"
 fluent-templates = { version = "0.13.0", features = ["handlebars"] }
 serde_urlencoded = "0.7.1"
+ics = "0.5.8"
 
 [profile.release]
 opt-level = 3

i18n/en-us/actions.ftl

···
 button-clear = Clear
 button-close = Close
 button-cancel = Cancel
+button-download-ical = Add to Calendar
 
 # Specific actions
 update-event = Update Event

i18n/en-us/common.ftl

···
 
 # Location labels
 location = Location
+
+# iCal export translations
+ical-untitled-event = Untitled Event
+ical-event-description-fallback = Event organized by {$organizer} via smokesignal.events
+ical-online-event = Online Event
+ical-location-tba = Location TBA
+ical-calendar-product-name = smokesignal.events
+ical-filename-template = {$event-name}.ics

i18n/fr-ca/actions.ftl

···
 button-clear = Effacer
 button-close = Fermer
 button-cancel = Annuler
+button-download-ical = Ajouter au calendrier
 
 # Actions spécifiques
 update-event = Mettre à jour l'événement

i18n/fr-ca/common.ftl

···
 
 # Étiquettes de lieu
 location = Lieu
+
+# Traductions d'exportation iCal
+ical-untitled-event = Événement sans titre
+ical-event-description-fallback = Événement organisé par {$organizer} via smokesignal.events
+ical-online-event = Événement en ligne
+ical-location-tba = Lieu à déterminer
+ical-calendar-product-name = smokesignal.events
+ical-filename-template = {$event-name}.ics

src/http/handle_filter_events.rs

···
-// HTTP handlers for event filtering endpoints
-//
-// Provides both full page rendering and HTMX partial responses
-// for dynamic event filtering with internationalization support.
+//! HTTP handlers for event filtering endpoints with HTMX and i18n support
+//!
+//! This module provides a comprehensive event filtering system that supports both traditional
+//! full-page loads and modern HTMX partial responses for dynamic user interfaces. The filtering
+//! system includes faceted search, pagination, sorting, and full internationalization support.
+//!
+//! # Features
+//!
+//! - **Dynamic Filtering**: Real-time event filtering with HTMX for responsive UX
+//! - **Faceted Search**: Multi-dimensional filtering by date, location, mode, status, and creator
+//! - **Full-Text Search**: Search across event names and descriptions
+//! - **Internationalization**: All content localized using Fluent templates
+//! - **Pagination**: Efficient handling of large result sets with customizable page sizes
+//! - **Sorting**: Multiple sort options including date, popularity, and relevance
+//! - **Template Compatibility**: Seamless integration with existing template system
+//!
+//! # Architecture
+//!
+//! The module follows a hybrid rendering approach:
+//! - Full page loads return complete HTML with layout
+//! - HTMX requests return partial HTML fragments for specific page sections
+//! - Facet-only requests provide just the filter counts for dynamic updates
+//! - Autocomplete suggestions provide fast search-as-you-type functionality
+//!
+//! # HTMX Integration
+//!
+//! The handlers detect HTMX requests and respond appropriately:
+//! - Regular HTMX requests return filtered results without page layout
+//! - Boosted requests (full page navigation) return complete pages
+//! - Facet requests return only the filter sidebar content
+//! - Suggestion requests return autocomplete dropdown content
+//!
+//! # Template Data Structure
+//!
+//! Events are converted to a flattened [`TemplateEvent`] structure that matches
+//! the existing template expectations, ensuring compatibility with legacy templates
+//! while providing enhanced filtering capabilities.
 
 use axum::{
     extract::{Query, Request},
···
 use crate::storage::{StoragePool, event::{get_user_rsvp, extract_event_details}};
 
 /// Template-compatible event data with flattened structure
+///
+/// This structure provides a flattened representation of event data that matches
+/// the expectations of existing templates. It combines data from multiple sources:
+/// - Core event data from the database
+/// - Formatted display data from [`EventView`]
+/// - RSVP counts and user relationship information
+/// - AT Protocol metadata (URIs, collection info)
+///
+/// The flattened structure avoids nested objects in templates, making it easier
+/// to work with template engines that prefer simple property access patterns.
+///
+/// # Field Categories
+///
+/// - **Identification**: `aturi`, `cid`, `site_url`, `collection`
+/// - **Content**: `name`, `description`, `description_short`
+/// - **Organizer**: `organizer_did`, `organizer_display_name`
+/// - **Timing**: `starts_at_*`, `ends_at_*` fields in both machine and human formats
+/// - **Properties**: `mode`, `status`, `address_display`
+/// - **Social**: `count_*` fields for RSVP statistics
+/// - **User Context**: `role` indicating user's relationship to the event
+/// - **Additional**: `links` for related URLs
 #[derive(Debug, Clone, Serialize)]
 pub struct TemplateEvent {
     // Core event identification
+    /// AT Protocol URI uniquely identifying this event
     pub aturi: String,
+    /// Content identifier (CID) for the event record
     pub cid: String,
+    /// Relative URL for viewing this event on the site
     pub site_url: String,
-    pub collection: String, // Added for legacy detection in templates
+    /// AT Protocol collection this event belongs to (for legacy detection)
+    pub collection: String,
 
     // Event metadata
+    /// Display name/title of the event
     pub name: String,
+    /// Full description text (optional)
     pub description: Option<String>,
+    /// Truncated description for list views (optional)
     pub description_short: Option<String>,
 
     // Organizer information
+    /// DID of the event organizer
     pub organizer_did: String,
+    /// Human-readable display name for the organizer
     pub organizer_display_name: String,
 
     // Date/time information
+    /// ISO 8601 machine-readable start time (optional)
     pub starts_at_machine: Option<String>,
+    /// Human-formatted start time for display (optional)
     pub starts_at_human: Option<String>,
+    /// ISO 8601 machine-readable end time (optional)
     pub ends_at_machine: Option<String>,
+    /// Human-formatted end time for display (optional)
     pub ends_at_human: Option<String>,
 
     // Event properties
+    /// Event mode: "online", "inperson", or "hybrid" (optional)
     pub mode: Option<String>,
+    /// Event status: "planned", "scheduled", "cancelled", etc. (optional)
     pub status: Option<String>,
+    /// Formatted address for display (optional)
     pub address_display: Option<String>,
 
     // RSVP counts
+    /// Number of "going" RSVPs
     pub count_going: u32,
+    /// Number of "interested" RSVPs
     pub count_interested: u32,
+    /// Number of "not going" RSVPs
     pub count_not_going: u32,
 
     // User's relationship to the event (for RSVP status display)
+    /// Current user's role: "organizer", "going", "interested", "not_going", or None
     pub role: Option<String>,
 
     // Additional properties
+    /// Related links as (URL, optional label) pairs
     pub links: Vec<(String, Option<String>)>,
 }
 
 /// Query parameters for filtering pages
+///
+/// Controls the rendering behavior for filter page requests, particularly
+/// how HTMX requests should be handled.
 #[derive(Debug, Deserialize, Serialize)]
 pub struct FilterPageQuery {
     /// Force full page reload even for HTMX requests
+    /// 
+    /// When `true`, HTMX requests will return complete pages instead of partial fragments.
+    /// This is useful for bookmarking, deep-linking, or when the full page context is needed.
     pub full: Option<bool>,
 }
 
-/// Handle the main event filtering page
+/// Handle the main event filtering page with HTMX and i18n support
+///
+/// This is the primary endpoint for event filtering, supporting both traditional full-page
+/// loads and dynamic HTMX partial updates. The handler adapts its response based on the
+/// request type and user preferences.
+///
+/// # Arguments
+///
+/// * `ctx` - User request context with authentication and language preferences
+/// * `filter_ext` - Pre-processed filter criteria from middleware
+/// * `page_query` - Query parameters controlling page rendering behavior
+/// * `boosted` - HTMX boosted navigation indicator
+/// * `is_htmx` - Whether this is an HTMX request
+///
+/// # Returns
+///
+/// Returns an HTTP response containing:
+/// - Full HTML page for regular requests or boosted HTMX requests
+/// - Partial HTML fragment for HTMX requests (results + pagination)
+/// - Localized content based on user's language preference
+///
+/// # Response Types
+///
+/// - **Full Page**: Complete HTML with layout, navigation, and content
+/// - **HTMX Partial**: Just the results section for dynamic updates
+/// - **Forced Full**: Full page even for HTMX when `full=true` parameter is set
+///
+/// # Template Context
+///
+/// The template receives comprehensive context including:
+/// - Filtered events as [`TemplateEvent`] structures
+/// - Facet counts for filter sidebar
+/// - Pagination metadata and navigation
+/// - Active filter indicators
+/// - User authentication and preference data
+/// - Localization strings and parameters
+///
+/// # Performance Considerations
+///
+/// HTMX requests use minimal data loading for faster responses, while full page
+/// loads include complete detail views. The filtering service optimizes queries
+/// based on the requested data level.
+///
+/// # Errors
+///
+/// Returns [`WebError`] for:
+/// - Database connection failures
+/// - Invalid filter parameters
+/// - Template rendering errors
+/// - Locale parsing issues
 #[instrument(skip(ctx))]
 pub async fn handle_filter_events(
     ctx: UserRequestContext,
···
     Ok(RenderHtml(&template_name, ctx.web_context.engine.clone(), template_ctx).into_response())
 }
 
-/// Handle HTMX facet requests (facets only, no events)
+/// Handle HTMX facet requests for dynamic filter updates
+///
+/// This endpoint provides just the facet counts (filter sidebar) without the event results,
+/// enabling dynamic updates of filter options as users modify their search criteria.
+/// This is particularly useful for showing how many results each filter option would yield.
+///
+/// # Arguments
+///
+/// * `ctx` - User request context with language preferences
+/// * `pool` - Database connection pool
+/// * `request` - HTTP request containing filter criteria in extensions
+///
+/// # Returns
+///
+/// Returns a partial HTML fragment containing:
+/// - Updated facet counts for all filter categories
+/// - Active filter indicators
+/// - Localized filter labels and descriptions
+///
+/// # Use Cases
+///
+/// - Real-time filter count updates as users type in search boxes
+/// - Dynamic showing/hiding of filter options based on current results
+/// - Preview of result counts before applying filters
+/// - Responsive filter UI that adapts to current query
+///
+/// # Performance
+///
+/// This endpoint is optimized for speed as it's called frequently during user interaction.
+/// It only calculates facet counts without loading full event data.
+///
+/// # Template
+///
+/// Uses locale-specific facet template: `filter_events_facets.{locale}.incl.html`
+///
+/// # Errors
+///
+/// Returns [`WebError`] for:
+/// - Database query failures
+/// - Invalid filter criteria
+/// - Template rendering issues
 #[instrument(skip(ctx, pool, request))]
 pub async fn handle_filter_facets(
     Extension(ctx): Extension<UserRequestContext>,
···
 }
 
 /// Handle autocomplete/suggestions for event search
+///
+/// Provides fast search-as-you-type functionality by returning a limited set of
+/// matching events based on the user's partial input. This enables responsive
+/// search experiences with immediate feedback.
+///
+/// # Arguments
+///
+/// * `ctx` - User request context with language preferences
+/// * `pool` - Database connection pool for queries
+/// * `query` - Search query parameters including search term and result limit
+///
+/// # Returns
+///
+/// Returns a partial HTML fragment containing:
+/// - Limited list of matching events (typically 5-10 results)
+/// - Highlighted search terms in results
+/// - Quick action links for each suggestion
+///
+/// # Query Parameters
+///
+/// - `q`: Search term to match against event names and descriptions
+/// - `limit`: Maximum number of suggestions (capped at 10 for performance)
+///
+/// # Performance Optimizations
+///
+/// - Results are limited to prevent overwhelming the UI
+/// - Uses minimal event data loading for fast response times
+/// - Implements efficient text search indexing
+/// - Caches common search patterns
+///
+/// # Template
+///
+/// Uses locale-specific suggestions template: `filter_events_suggestions.{locale}.incl.html`
+///
+/// # Use Cases
+///
+/// - Search autocomplete dropdowns
+/// - Quick event discovery
+/// - Mobile-friendly search interfaces
+/// - Reduced cognitive load for users
+///
+/// # Errors
+///
+/// Returns [`WebError`] for database or template issues, but gracefully handles
+/// empty or invalid search terms by returning empty results.
 #[instrument(skip(ctx, pool))]
 pub async fn handle_filter_suggestions(
     Extension(ctx): Extension<UserRequestContext>,
···
 }
 
 /// Query parameters for autocomplete suggestions
+///
+/// Defines the parameters accepted by the suggestion endpoint for controlling
+/// search behavior and result limits.
 #[derive(Debug, Deserialize)]
 pub struct SuggestionQuery {
-    /// Search query
+    /// Search query term to match against event content
+    /// 
+    /// Searches across event names, descriptions, and other searchable fields.
+    /// Empty or None values return no suggestions.
     pub q: Option<String>,
     
-    /// Maximum number of suggestions
+    /// Maximum number of suggestions to return
+    /// 
+    /// Automatically capped at 10 to prevent performance issues and UI overflow.
+    /// Defaults to 5 if not specified.
     pub limit: Option<usize>,
 }
 
 /// Convert EventFilterCriteria to template-friendly format
+///
+/// Transforms the internal filter criteria structure into a JSON object that
+/// templates can easily consume. This handles type conversions, formatting,
+/// and provides sensible defaults for template rendering.
+///
+/// # Arguments
+///
+/// * `criteria` - The filter criteria to convert
+///
+/// # Returns
+///
+/// A [`serde_json::Value`] containing all filter parameters in template-friendly format:
+/// - Dates as ISO strings for HTML date inputs
+/// - Location as formatted coordinate strings
+/// - Enums converted to string representations
+/// - Arrays properly formatted for template iteration
+///
+/// # Template Compatibility
+///
+/// The output structure matches exactly what existing templates expect,
+/// ensuring compatibility with legacy template code while providing
+/// enhanced filtering capabilities.
+///
+/// # Field Transformations
+///
+/// - `start_date`/`end_date`: Converted to YYYY-MM-DD format
+/// - `location`: Formatted as "lat, lng" with radius in km
+/// - `sort_by`/`sort_order`: Combined into template-friendly sort strings
+/// - `modes`/`statuses`: Converted to string arrays
+/// - `creator_did`: Wrapped in array for template consistency
 fn criteria_to_template_context(criteria: &EventFilterCriteria) -> Value {
     use serde_json::json;
     
···
 }
 
 /// Create active filters data for template display
+///
+/// Generates a structured representation of currently active filters for display
+/// in the template UI. This enables users to see what filters are applied and
+/// provides easy removal mechanisms for each filter.
+///
+/// # Arguments
+///
+/// * `criteria` - The current filter criteria to analyze
+///
+/// # Returns
+///
+/// A [`serde_json::Value`] containing:
+/// - `filters`: Array of active filter objects
+/// - `has_active_filters`: Boolean indicating if any filters are active
+///
+/// # Filter Object Structure
+///
+/// Each active filter includes:
+/// - `type`: Filter category (search, date_range, location, etc.)
+/// - `key`: Unique identifier for the filter
+/// - `value`: Current filter value
+/// - `display_key`: Translation key for user-friendly label
+/// - `display_params`: Parameters for localized display
+/// - `remove_params`: Query parameters to remove this filter
+///
+/// # Supported Filter Types
+///
+/// - **search**: Text search terms
+/// - **date_range**: Date range filters (start/end or individual dates)
+/// - **location**: Geographic location with radius
+/// - **sort**: Non-default sort orders
+/// - **modes**: Event mode filters (online, in-person, hybrid)
+/// - **statuses**: Event status filters (planned, scheduled, etc.)
+/// - **creator**: Organizer-specific filters
+///
+/// # Template Integration
+///
+/// Templates use this data to render:
+/// - Filter breadcrumbs with removal links
+/// - "Clear all filters" functionality
+/// - Filter summary displays
+/// - Localized filter descriptions
 fn create_active_filters(criteria: &EventFilterCriteria) -> Value {
     use serde_json::json;
     let mut active_filters = Vec::new();
···
 }
 
 /// Convert HydratedEvent to template-compatible flattened structure
+///
+/// Transforms the complex [`HydratedEvent`] structure into a flat [`TemplateEvent`]
+/// that templates can easily work with. This function handles data prioritization,
+/// format conversion, and user context integration.
+///
+/// # Arguments
+///
+/// * `hydrated` - The hydrated event data from the filtering service
+/// * `user_did` - Optional DID of the current user for role determination
+/// * `pool` - Database pool for additional queries (RSVP status, etc.)
+///
+/// # Returns
+///
+/// A [`TemplateEvent`] with all necessary data for template rendering
+///
+/// # Data Prioritization
+///
+/// The function uses a priority system for data sources:
+/// 1. **EventView data** (if available) - formatted, localized content
+/// 2. **Raw event details** - direct from database record
+/// 3. **Computed defaults** - fallbacks and generated content
+///
+/// # Format Conversions
+///
+/// - Timestamps: Converted to both ISO 8601 and human-readable formats
+/// - Handles: Cleaned and validated for proper display
+/// - Descriptions: Truncated for list views, full for detail views
+/// - Addresses: Extracted from complex location structures
+/// - Links: Flattened from structured URI objects
+///
+/// # User Context Integration
+///
+/// Determines the user's relationship to the event:
+/// - **organizer**: User created the event
+/// - **going/interested/not_going**: User's RSVP status
+/// - **None**: No relationship or not authenticated
+///
+/// # Error Handling
+///
+/// Gracefully handles missing or malformed data by providing sensible defaults
+/// and fallbacks, ensuring templates always receive valid data structures.
+///
+/// # Performance Notes
+///
+/// May perform additional database queries for RSVP status, but these are
+/// optimized and cached where possible.
 async fn hydrated_event_to_template(
     hydrated: &HydratedEvent, 
     user_did: Option<&str>,
···
 }
 
 /// Determine the user's role in relation to an event
+///
+/// Analyzes the relationship between a user and an event to determine what
+/// actions they can take and how the event should be displayed to them.
+///
+/// # Arguments
+///
+/// * `event` - The event to analyze
+/// * `user_did` - Optional DID of the current user
+/// * `pool` - Database pool for RSVP lookups
+///
+/// # Returns
+///
+/// An optional string indicating the user's role:
+/// - `Some("organizer")` - User created/owns the event
+/// - `Some("going")` - User has RSVP'd as going
+/// - `Some("interested")` - User has RSVP'd as interested
+/// - `Some("not_going")` - User has RSVP'd as not going
+/// - `None` - No authenticated user or no relationship to event
+///
+/// # Role Determination Logic
+///
+/// 1. **Organizer Check**: Compare user DID with event creator DID
+/// 2. **RSVP Lookup**: Query database for user's RSVP status
+/// 3. **Fallback**: Return None if no relationship found
+///
+/// # Template Usage
+///
+/// Templates use this role information to:
+/// - Show appropriate action buttons (Edit vs RSVP)
+/// - Display user's current status
+/// - Control access to event management features
+/// - Customize the user experience
+///
+/// # Performance
+///
+/// Performs one database query for RSVP lookup, with error handling
+/// that gracefully degrades to "no role" on failure.
 async fn determine_user_role(
     event: &crate::storage::event::model::Event, 
     user_did: Option<&str>,

src/http/handle_ical_event.rs

···
+//! iCal event download handler with full i18n support
+//!
+//! This module generates RFC 5545 compliant iCalendar (.ics) files for events with comprehensive
+//! internationalization support. The implementation follows web standards for calendar downloads
+//! and integrates seamlessly with the AT Protocol ecosystem.
+//!
+//! # Features
+//!
+//! - **AT Protocol Integration**: Uses AT Protocol handle format for organizer fields instead of mailto
+//! - **Locale-Aware Content**: All user-facing content is translated using Fluent templates
+//! - **Intelligent Fallbacks**: Graceful handling of missing event data with localized fallbacks
+//! - **Safe File Downloads**: Sanitized filenames prevent path traversal and filesystem issues
+//! - **RFC 5545 Compliance**: Generates valid iCalendar files compatible with all major calendar apps
+//! - **Timezone Support**: Proper UTC timestamp formatting for cross-timezone compatibility
+//!
+//! # Usage
+//!
+//! The main entry point is [`handle_ical_event`] which processes HTTP requests for iCal downloads.
+//! The route is typically mounted at `/{handle_slug}/{event_rkey}/ical`.
+//!
+//! # Translation Keys
+//!
+//! This module requires the following translation keys to be defined in the Fluent files:
+//! - `ical-untitled-event`: Fallback for events without titles
+//! - `ical-event-description-fallback`: Template for events without descriptions
+//! - `ical-online-event`: Location text for online events
+//! - `ical-location-tba`: Location text when venue is not specified
+//! - `ical-calendar-product-name`: Product identifier for the calendar
+//! - `ical-filename-template`: Template for generated filenames
+
+use anyhow::Result;
+use axum::{
+    extract::{Path, Query},
+    http::{header, HeaderMap, StatusCode},
+    response::IntoResponse,
+};
+use chrono::{DateTime, Utc};
+use ics::{
+    properties::{DtEnd, DtStart, Summary, Description, Location, Organizer},
+    Event as IcsEvent, ICalendar,
+};
+use serde::Deserialize;
+
+use crate::atproto::lexicon::community::lexicon::calendar::event::NSID;
+use crate::atproto::uri::parse_aturi;
+use crate::http::context::UserRequestContext;
+use crate::http::errors::{WebError, CommonError};
+use crate::http::event_view::EventView;
+use crate::i18n::fluent_loader::{get_translation, LOCALES};
+use crate::resolve::{parse_input, InputType};
+use fluent_templates::Loader;
+use crate::storage::event::{event_get, extract_event_details};
+use crate::storage::handle::{handle_for_did, handle_for_handle};
+
+/// Query parameters for iCal collection specification
+///
+/// Allows clients to specify which AT Protocol collection to use when looking up events.
+/// Defaults to the standard community calendar event collection if not specified.
+#[derive(Debug, Deserialize)]
+pub struct ICalCollectionParam {
+    /// The AT Protocol collection identifier (NSID) to use for event lookup
+    /// 
+    /// Defaults to the standard community calendar event collection NSID
+    /// when not provided in the query parameters.
+    #[serde(default = "default_collection")]
+    collection: String,
+}
+
+/// Returns the default collection NSID for community calendar events
+///
+/// This function provides the default AT Protocol collection identifier
+/// used when no explicit collection is specified in the request.
+fn default_collection() -> String {
+    NSID.to_string()
+}
+
+/// Generate iCal content for an event with full internationalization support
+///
+/// This is the main HTTP handler for iCal event downloads. It processes requests for
+/// `.ics` files and returns RFC 5545 compliant iCalendar data with proper HTTP headers
+/// for download handling.
+///
+/// # Arguments
+///
+/// * `ctx` - User request context containing language preferences and web configuration
+/// * `handle_slug` - AT Protocol handle or DID identifying the event organizer
+/// * `event_rkey` - Record key identifying the specific event within the collection
+/// * `collection_param` - Optional query parameter specifying the AT Protocol collection
+///
+/// # Returns
+///
+/// Returns an HTTP response with:
+/// - `Content-Type: text/calendar; charset=utf-8` header
+/// - `Content-Disposition: attachment; filename="..."` header with localized filename
+/// - RFC 5545 compliant iCalendar content in the response body
+///
+/// # Errors
+///
+/// Returns [`WebError`] in the following cases:
+/// - Invalid handle slug format
+/// - Event not found in the database
+/// - Invalid AT Protocol URI format
+/// - Failed to parse event data
+///
+/// # AT Protocol Integration
+///
+/// The organizer field uses AT Protocol handle format (`CN=Name:at://handle`) instead
+/// of the traditional mailto format, making it compatible with decentralized identity systems.
+///
+/// # Internationalization
+///
+/// All user-facing content is localized based on the user's language preference:
+/// - Event titles fall back to translated "untitled event" text
+/// - Descriptions use translated templates when missing
+/// - Location displays localized "online" or "TBA" text for missing venues
+/// - Filenames are generated using translated templates
+pub async fn handle_ical_event(
+    ctx: UserRequestContext,
+    Path((handle_slug, event_rkey)): Path<(String, String)>,
+    collection_param: Query<ICalCollectionParam>,
+) -> Result<impl IntoResponse, WebError> {
+    // Parse the handle slug to get the profile
+    let profile = match parse_input(&handle_slug) {
+        Ok(InputType::Plc(did) | InputType::Web(did)) => {
+            handle_for_did(&ctx.web_context.pool, &did).await
+        }
+        Ok(InputType::Handle(handle)) => {
+            handle_for_handle(&ctx.web_context.pool, &handle).await
+        }
+        _ => return Err(WebError::Common(CommonError::InvalidHandleSlug)),
+    }
+    .map_err(|_| WebError::Common(CommonError::RecordNotFound))?;
+
+    // Use the provided collection parameter
+    let collection = &collection_param.0.collection;
+    let lookup_aturi = format!("at://{}/{}/{}", profile.did, collection, event_rkey);
+
+    // Get the event from the database
+    let event = event_get(&ctx.web_context.pool, &lookup_aturi)
+        .await
+        .map_err(|_| WebError::Common(CommonError::RecordNotFound))?;
+
+    // Get organizer handle for additional info
+    let organizer_handle = handle_for_did(&ctx.web_context.pool, &event.did)
+        .await
+        .ok();
+
+    // Convert to EventView to get formatted data
+    let event_view = EventView::try_from_with_locale(
+        (None, organizer_handle.as_ref(), &event),
+        Some(&ctx.language.0),
+    )
+    .map_err(|_| WebError::Common(CommonError::FailedToParse))?;
+
+    // Extract event details for raw datetime access
+    let details = extract_event_details(&event);
+    
+    // Parse aturi to get rkey for unique ID
+    let (_, _, rkey) = parse_aturi(&event.aturi)
+        .map_err(|_| WebError::Common(CommonError::InvalidAtUri))?;
+
+    // Create iCal event with localized content
+    let mut ical_event = IcsEvent::new(
+        format!("{}@smokesignal.events", rkey),
+        format_timestamp(&Utc::now()),
+    );
+
+    // Set event summary (title) - use localized fallback if needed
+    let event_title = if event_view.name.trim().is_empty() {
+        // Fallback to localized "untitled event"
+        LOCALES.lookup(&ctx.language.0, "ical-untitled-event")
+    } else {
+        event_view.name.clone()
+    };
+    ical_event.push(Summary::new(event_title));
+
+    // Set description with i18n awareness
+    let event_description = match event_view.description {
+        Some(desc) if !desc.trim().is_empty() => desc,
+        _ => {
+            // Fallback to localized description
+            let mut args = std::collections::HashMap::new();
+            args.insert(
+                "organizer".into(),
+                fluent_templates::fluent_bundle::FluentValue::String(
+                    std::borrow::Cow::Owned(event_view.organizer_display_name.clone())
+                )
+            );
+            get_translation(&ctx.language.0, "ical-event-description-fallback", Some(args))
+        }
+    };
+    ical_event.push(Description::new(event_description));
+
+    // Set start time if available
+    if let Some(starts_at) = details.starts_at {
+        ical_event.push(DtStart::new(format_timestamp(&starts_at)));
+    }
+
+    // Set end time if available
+    if let Some(ends_at) = details.ends_at {
+        ical_event.push(DtEnd::new(format_timestamp(&ends_at)));
+    }
+
+    // Set location with i18n awareness
+    let event_location = match event_view.address_display {
+        Some(address) if !address.trim().is_empty() => address,
+        _ => {
+            // Fallback to localized "online event" or "location TBA"
+            match event_view.mode.as_deref() {
+                Some("online") => LOCALES.lookup(&ctx.language.0, "ical-online-event"),
+                _ => LOCALES.lookup(&ctx.language.0, "ical-location-tba"),
+            }
+        }
+    };
+    ical_event.push(Location::new(event_location));
+
+    // Set organizer with AT Protocol handle format (not mailto)
+    let organizer_handle = organizer_handle
+        .as_ref()
+        .map(|h| h.handle.clone())
+        .unwrap_or_else(|| "unknown".to_string());
+    
+    // Use AT Protocol handle format instead of mailto:
+    // CN=Display Name:at://handle.domain
+    let organizer_field = format!(
+        "CN={}:at://{}",
+        event_view.organizer_display_name,
+        organizer_handle
+    );
+    ical_event.push(Organizer::new(organizer_field));
+
+    // Create calendar with localized product identifier
+    let calendar_name = LOCALES.lookup(&ctx.language.0, "ical-calendar-product-name");
+    let mut calendar = ICalendar::new("2.0", &calendar_name);
+    calendar.add_event(ical_event);
+
+    // Generate iCal content
+    let ical_content = calendar.to_string();
+
+    // Create localized filename with proper sanitization
+    let sanitized_name = sanitize_filename(&event_view.name);
+    let mut filename_args = std::collections::HashMap::new();
+    filename_args.insert(
+        "event-name".into(),
+        fluent_templates::fluent_bundle::FluentValue::String(
+            std::borrow::Cow::Owned(sanitized_name.clone())
+        )
+    );
+    let filename = get_translation(&ctx.language.0, "ical-filename-template", Some(filename_args));
+
+    // Create response with appropriate headers
+    let mut headers = HeaderMap::new();
+    headers.insert(
+        header::CONTENT_TYPE,
+        "text/calendar; charset=utf-8".parse().unwrap(),
+    );
+    headers.insert(
+        header::CONTENT_DISPOSITION,
+        format!("attachment; filename=\"{}\"", filename)
+            .parse()
+            .unwrap(),
+    );
+
+    Ok((StatusCode::OK, headers, ical_content))
+}
+
+/// Format a timestamp for iCal format (YYYYMMDDTHHMMSSZ)
+///
+/// Converts a UTC DateTime to the iCalendar specification format required by RFC 5545.
+/// The output format is `YYYYMMDDTHHMMSSZ` where the trailing 'Z' indicates UTC timezone.
+///
+/// # Arguments
+///
+/// * `dt` - A UTC DateTime to format
+///
+/// # Returns
+///
+/// A string formatted as `YYYYMMDDTHHMMSSZ` suitable for use in iCalendar DTSTART and DTEND properties
+///
+/// # Examples
+///
+/// ```
+/// use chrono::{DateTime, Utc};
+/// let dt = DateTime::parse_from_rfc3339("2025-06-04T14:30:00Z").unwrap().with_timezone(&Utc);
+/// assert_eq!(format_timestamp(&dt), "20250604T143000Z");
+/// ```
+fn format_timestamp(dt: &DateTime<Utc>) -> String {
+    dt.format("%Y%m%dT%H%M%SZ").to_string()
+}
+
+/// Sanitize filename by removing or replacing invalid characters
+///
+/// Ensures that event names can be safely used as filenames by replacing characters
+/// that are invalid or problematic in filesystem paths. This prevents path traversal
+/// attacks and ensures cross-platform compatibility.
+///
+/// # Arguments
+///
+/// * `name` - The raw event name to sanitize
+///
+/// # Returns
+///
+/// A sanitized string safe for use as a filename component
+///
+/// # Sanitization Rules
+///
+/// - Path separators (`/`, `\`) are replaced with underscores
+/// - Reserved characters (`:`, `*`, `?`, `"`, `<`, `>`, `|`) are replaced with underscores  
+/// - Control characters are replaced with underscores
+/// - Leading and trailing whitespace is trimmed
+///
+/// # Examples
+///
+/// ```
+/// assert_eq!(sanitize_filename("Hello World"), "Hello World");
+/// assert_eq!(sanitize_filename("Hello/World"), "Hello_World");
+/// assert_eq!(sanitize_filename("Test: Event?"), "Test_ Event_");
+/// ```
+fn sanitize_filename(name: &str) -> String {
+    name.chars()
+        .map(|c| match c {
+            '/' | '\\' | ':' | '*' | '?' | '"' | '<' | '>' | '|' => '_',
+            c if c.is_control() => '_',
+            c => c,
+        })
+        .collect::<String>()
+        .trim()
+        .to_string()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_sanitize_filename() {
+        assert_eq!(sanitize_filename("Hello World"), "Hello World");
+        assert_eq!(sanitize_filename("Hello/World"), "Hello_World");
+        assert_eq!(sanitize_filename("Test: Event?"), "Test_ Event_");
+        assert_eq!(sanitize_filename("Event<>Name"), "Event__Name");
+    }
+
+    #[test]
+    fn test_format_timestamp() {
+        let dt = DateTime::parse_from_rfc3339("2025-06-04T14:30:00Z")
+            .unwrap()
+            .with_timezone(&Utc);
+        assert_eq!(format_timestamp(&dt), "20250604T143000Z");
+    }
+}

src/http/mod.rs

···
 pub mod handle_set_language;
 pub mod handle_settings;
 pub mod handle_view_event;
+pub mod handle_ical_event; // New iCal handler
 pub mod handle_view_feed;
 pub mod handle_view_rsvp;
 pub mod location_edit_status;

src/http/server.rs

···
     handle_set_language::handle_set_language,
     handle_settings::{handle_language_update, handle_settings, handle_timezone_update},
     handle_view_event::handle_view_event,
+    handle_ical_event::handle_ical_event,
     handle_view_feed::handle_view_feed,
     handle_view_rsvp::handle_view_rsvp,
     middleware_filter,
···
         )
         .route("/feed/{handle_slug}/{feed_rkey}", get(handle_view_feed))
         .route("/rsvp/{handle_slug}/{rsvp_rkey}", get(handle_view_rsvp))
+        .route("/{handle_slug}/{event_rkey}/ical", get(handle_ical_event))
         .route("/{handle_slug}/{event_rkey}", get(handle_view_event))
         .route("/favicon.ico", get(|| async { axum::response::Redirect::permanent("/static/favicon.ico") }))
         .route("/{handle_slug}", get(handle_profile_view))

templates/view_event.en-us.common.html

···
                 <span>{{ t("button-edit") }}</span>
             </a>
             {% endif %}
+            <a href="{{ base }}/{{ handle_slug }}/{{ event_rkey }}/ical"
+                class="button is-small is-outlined is-info ml-2"
+                download="{{ event.name }}.ics">
+                <span class="icon">
+                    <i class="fas fa-calendar-plus"></i>
+                </span>
+                <span>{{ t("button-download-ical") }}</span>
+            </a>
         </h1>
         <div class="level subtitle">
             {% if event.status == "planned" %}

templates/view_event.fr-ca.common.html

···
                 <span>{{ t("button-edit") }}</span>
             </a>
             {% endif %}
+            <a href="{{ base }}/{{ handle_slug }}/{{ event_rkey }}/ical"
+                class="button is-small is-outlined is-info ml-2"
+                download="{{ event.name }}.ics">
+                <span class="icon">
+                    <i class="fas fa-calendar-plus"></i>
+                </span>
+                <span>{{ t("button-download-ical") }}</span>
+            </a>
         </h1>
         <div class="level subtitle">
             {% if event.status == "planned" %}