First pass : bookmarks plan execution

GHCP first pass at implementing bookmarks
compiles but not fully tested.

backup/handle_bookmark_calendars_old.rs

···
+use axum::{
+    extract::{Path, Query, State},
+    http::StatusCode,
+    response::{Html, IntoResponse},
+    Json,
+};
+use serde::{Deserialize, Serialize};
+use std::sync::Arc;
+use tracing::{debug, error, info, warn};
+
+use crate::http::{AppContext, HttpError, get_session_or_redirect};
+use crate::i18n::I18nService;
+use crate::storage::bookmark_calendars;
+use crate::storage::bookmark_calendars::BookmarkCalendar;
+
+#[derive(Deserialize)]
+pub struct CreateBookmarkCalendarParams {
+    name: String,
+    description: Option<String>,
+    tags: Vec<String>,
+    tag_operator: Option<String>, // 'AND' or 'OR'
+    is_public: Option<bool>,
+}
+
+#[derive(Deserialize)]
+pub struct UpdateBookmarkCalendarParams {
+    name: String,
+    description: Option<String>,
+    tags: Vec<String>,
+    tag_operator: Option<String>,
+    is_public: Option<bool>,
+}
+
+#[derive(Deserialize)]
+pub struct AddEventToCalendarParams {
+    event_aturi: String,
+    tags: Vec<String>,
+}
+
+#[derive(Deserialize)]
+pub struct CalendarListParams {
+    limit: Option<i32>,
+    offset: Option<i32>,
+}
+
+#[derive(Serialize)]
+pub struct CalendarResponse {
+    success: bool,
+    message: String,
+    calendar_id: Option<String>,
+}
+
+/// Handle creating a new bookmark calendar
+pub async fn handle_create_bookmark_calendar(
+    State(ctx): State<Arc<AppContext>>,
+    Json(payload): Json<CreateBookmarkCalendarParams>,
+) -> Result<Html<String>, HttpError> {
+    let session = get_session_or_redirect(&ctx, &axum::http::HeaderMap::new()).await?;
+
+    // Validate input
+    if payload.name.trim().is_empty() {
+        return Err(HttpError::BadRequest("Calendar name is required".to_string()));
+    }
+
+    if payload.name.len() > 256 {
+        return Err(HttpError::BadRequest("Calendar name too long (maximum 256 characters)".to_string()));
+    }
+
+    if payload.tags.is_empty() {
+        return Err(HttpError::BadRequest("At least one tag is required".to_string()));
+    }
+
+    if payload.tags.len() > 10 {
+        return Err(HttpError::BadRequest("Maximum 10 tags allowed per calendar".to_string()));
+    }
+
+    for tag in &payload.tags {
+        if tag.trim().is_empty() {
+            return Err(HttpError::BadRequest("Empty tags are not allowed".to_string()));
+        }
+        if tag.len() > 50 {
+            return Err(HttpError::BadRequest("Tag too long (maximum 50 characters)".to_string()));
+        }
+    }
+
+    let calendar_id = bookmark_calendars::generate_calendar_id();
+    let tag_operator = payload.tag_operator.unwrap_or_else(|| "OR".to_string());
+
+    if !["AND", "OR"].contains(&tag_operator.as_str()) {
+        return Err(HttpError::BadRequest("Tag operator must be 'AND' or 'OR'".to_string()));
+    }
+
+    let calendar = BookmarkCalendar {
+        id: 0, // Will be set by database
+        calendar_id: calendar_id.clone(),
+        did: session.did.clone(),
+        name: payload.name.trim().to_string(),
+        description: payload.description.map(|d| d.trim().to_string()).filter(|d| !d.is_empty()),
+        tags: payload.tags.iter().map(|t| t.trim().to_string()).collect(),
+        tag_operator,
+        is_public: payload.is_public.unwrap_or(false),
+        event_count: 0,
+        created_at: chrono::Utc::now(),
+        updated_at: chrono::Utc::now(),
+    };
+
+    match bookmark_calendars::insert(&ctx.storage, &calendar).await {
+        Ok(created_calendar) => {
+            info!("Successfully created calendar {} for user {}", calendar_id, session.did);
+            
+            let i18n = I18nService::new(&session.language);
+            let message = i18n.t("calendar-created", &[("count", &created_calendar.tags.len().to_string())]);
+            
+            let mut template_context = axum_template::TemplateContext::new();
+            template_context.insert("calendar", &created_calendar);
+            template_context.insert("message", &message);
+            
+            let html = ctx.templates
+                .render("bookmark_calendar_item", &template_context)
+                .map_err(|e| HttpError::TemplateError(e.to_string()))?;
+            
+            Ok(Html(html))
+        }
+        Err(e) => {
+            error!("Failed to create calendar for user {}: {}", session.did, e);
+            Err(HttpError::InternalServerError("Failed to create calendar".to_string()))
+        }
+    }
+}
+
+/// Handle viewing a specific bookmark calendar
+pub async fn handle_view_bookmark_calendar(
+    State(ctx): State<Arc<AppContext>>,
+    Path(calendar_id): Path<String>,
+    Query(params): Query<ViewCalendarParams>,
+) -> Result<Html<String>, HttpError> {
+    let session = get_session_or_redirect(&ctx, &axum::http::HeaderMap::new()).await?;
+
+    let calendar = match bookmark_calendars::get_by_calendar_id(&ctx.storage, &calendar_id).await? {
+        Some(calendar) => calendar,
+        None => return Err(HttpError::NotFound("Calendar not found".to_string())),
+    };
+
+    // Check if user has access to this calendar
+    if calendar.did != session.did && !calendar.is_public {
+        return Err(HttpError::Forbidden("Access denied".to_string()));
+    }
+
+    let view_mode = params.view.as_deref().unwrap_or("timeline");
+    let limit = params.limit.unwrap_or(20);
+    let offset = params.offset.unwrap_or(0);
+
+    // Get events for this calendar using its tag filtering rules
+    let bookmark_service = crate::services::event_bookmarks::EventBookmarkService::new(
+        ctx.storage.clone(),
+        ctx.atproto_client.clone(),
+    );
+
+    match bookmark_service
+        .get_bookmarked_events(
+            &calendar.did,
+            Some(&calendar.tags),
+            None,
+            limit,
+            offset,
+            false,
+        )
+        .await
+    {
+        Ok(paginated_events) => {
+            let i18n = I18nService::new(&session.language);
+            
+            let template_name = match view_mode {
+                "calendar" => "bookmark_calendar_grid",
+                _ => "bookmark_calendar_timeline",
+            };
+
+            let mut template_context = axum_template::TemplateContext::new();
+            template_context.insert("calendar", &calendar);
+            template_context.insert("events", &paginated_events.events);
+            template_context.insert("total_count", &paginated_events.total_count);
+            template_context.insert("has_more", &paginated_events.has_more);
+            template_context.insert("current_offset", &offset);
+            template_context.insert("view_mode", view_mode);
+            template_context.insert("is_owner", &(calendar.did == session.did));
+            
+            let html = ctx.templates
+                .render(template_name, &template_context)
+                .map_err(|e| HttpError::TemplateError(e.to_string()))?;
+            
+            Ok(Html(html))
+        }
+        Err(e) => {
+            error!("Failed to get calendar events for calendar {}: {}", calendar_id, e);
+            Err(HttpError::InternalServerError("Failed to load calendar".to_string()))
+        }
+    }
+}
+
+/// Handle deleting a bookmark calendar
+pub async fn handle_delete_bookmark_calendar(
+    State(ctx): State<Arc<AppContext>>,
+    Path(calendar_id): Path<String>,
+) -> Result<Html<String>, HttpError> {
+    let session = get_session_or_redirect(&ctx, &axum::http::HeaderMap::new()).await?;
+
+    let calendar = match bookmark_calendars::get_by_calendar_id(&ctx.storage, &calendar_id).await? {
+        Some(calendar) => calendar,
+        None => return Err(HttpError::NotFound("Calendar not found".to_string())),
+    };
+
+    // Check if user owns this calendar
+    if calendar.did != session.did {
+        return Err(HttpError::Forbidden("You can only delete your own calendars".to_string()));
+    }
+
+    match bookmark_calendars::delete(&ctx.storage, &calendar_id, &session.did).await {
+        Ok(()) => {
+            info!("Successfully deleted calendar {} for user {}", calendar_id, session.did);
+            
+            // Return empty HTML for HTMX to remove the element
+            Ok(Html(String::new()))
+        }
+        Err(e) => {
+            error!("Failed to delete calendar {}: {}", calendar_id, e);
+            Err(HttpError::InternalServerError("Failed to delete calendar".to_string()))
+        }
+    }
+}
+
+/// Handle listing bookmark calendars (user's own and public)
+pub async fn handle_bookmark_calendars_index(
+    State(ctx): State<Arc<AppContext>>,
+    Query(params): Query<CalendarListParams>,
+) -> Result<Html<String>, HttpError> {
+    let session = get_session_or_redirect(&ctx, &axum::http::HeaderMap::new()).await?;
+
+    let limit = params.limit.unwrap_or(20);
+    let offset = params.offset.unwrap_or(0);
+
+    // Get user's own calendars
+    let user_calendars = bookmark_calendars::get_by_user(&ctx.storage, &session.did, true).await?;
+
+    // Get public calendars
+    let (public_calendars, total_public) = bookmark_calendars::get_public_paginated(&ctx.storage, limit, offset).await?;
+
+    let i18n = I18nService::new(&session.language);
+    
+    let mut template_context = axum_template::TemplateContext::new();
+    template_context.insert("user_calendars", &user_calendars);
+    template_context.insert("public_calendars", &public_calendars);
+    template_context.insert("total_public", &total_public);
+    template_context.insert("current_offset", &offset);
+    template_context.insert("has_more_public", &((offset + limit) < total_public as i32));
+    
+    let html = ctx.templates
+        .render("bookmark_calendars_index", &template_context)
+        .map_err(|e| HttpError::TemplateError(e.to_string()))?;
+    
+    Ok(Html(html))
+}
+
+/// Handle updating a bookmark calendar
+pub async fn handle_update_bookmark_calendar(
+    State(ctx): State<Arc<AppContext>>,
+    Path(calendar_id): Path<String>,
+    Json(payload): Json<UpdateBookmarkCalendarParams>,
+) -> Result<Html<String>, HttpError> {
+    let session = get_session_or_redirect(&ctx, &axum::http::HeaderMap::new()).await?;
+
+    let mut calendar = match bookmark_calendars::get_by_calendar_id(&ctx.storage, &calendar_id).await? {
+        Some(calendar) => calendar,
+        None => return Err(HttpError::NotFound("Calendar not found".to_string())),
+    };
+
+    // Check if user owns this calendar
+    if calendar.did != session.did {
+        return Err(HttpError::Forbidden("You can only update your own calendars".to_string()));
+    }
+
+    // Validate input (same as create)
+    if payload.name.trim().is_empty() {
+        return Err(HttpError::BadRequest("Calendar name is required".to_string()));
+    }
+
+    if payload.name.len() > 256 {
+        return Err(HttpError::BadRequest("Calendar name too long (maximum 256 characters)".to_string()));
+    }
+
+    if payload.tags.is_empty() {
+        return Err(HttpError::BadRequest("At least one tag is required".to_string()));
+    }
+
+    if payload.tags.len() > 10 {
+        return Err(HttpError::BadRequest("Maximum 10 tags allowed per calendar".to_string()));
+    }
+
+    for tag in &payload.tags {
+        if tag.trim().is_empty() {
+            return Err(HttpError::BadRequest("Empty tags are not allowed".to_string()));
+        }
+        if tag.len() > 50 {
+            return Err(HttpError::BadRequest("Tag too long (maximum 50 characters)".to_string()));
+        }
+    }
+
+    let tag_operator = payload.tag_operator.unwrap_or_else(|| "OR".to_string());
+    if !["AND", "OR"].contains(&tag_operator.as_str()) {
+        return Err(HttpError::BadRequest("Tag operator must be 'AND' or 'OR'".to_string()));
+    }
+
+    // Update calendar fields
+    calendar.name = payload.name.trim().to_string();
+    calendar.description = payload.description.map(|d| d.trim().to_string()).filter(|d| !d.is_empty());
+    calendar.tags = payload.tags.iter().map(|t| t.trim().to_string()).collect();
+    calendar.tag_operator = tag_operator;
+    calendar.is_public = payload.is_public.unwrap_or(calendar.is_public);
+
+    match bookmark_calendars::update(&ctx.storage, &calendar).await {
+        Ok(()) => {
+            info!("Successfully updated calendar {} for user {}", calendar_id, session.did);
+            
+            let i18n = I18nService::new(&session.language);
+            let message = i18n.t("calendar-updated", &[("count", &calendar.tags.len().to_string())]);
+            
+            let mut template_context = axum_template::TemplateContext::new();
+            template_context.insert("calendar", &calendar);
+            template_context.insert("message", &message);
+            
+            let html = ctx.templates
+                .render("bookmark_calendar_item", &template_context)
+                .map_err(|e| HttpError::TemplateError(e.to_string()))?;
+            
+            Ok(Html(html))
+        }
+        Err(e) => {
+            error!("Failed to update calendar {}: {}", calendar_id, e);
+            Err(HttpError::InternalServerError("Failed to update calendar".to_string()))
+        }
+    }
+}
+
+/// Handle iCal export of a specific calendar
+pub async fn handle_export_calendar_ical(
+    State(ctx): State<Arc<AppContext>>,
+    Path(calendar_id): Path<String>,
+) -> Result<impl IntoResponse, HttpError> {
+    let session = get_session_or_redirect(&ctx, &axum::http::HeaderMap::new()).await?;
+
+    let calendar = match bookmark_calendars::get_by_calendar_id(&ctx.storage, &calendar_id).await? {
+        Some(calendar) => calendar,
+        None => return Err(HttpError::NotFound("Calendar not found".to_string())),
+    };
+
+    // Check if user has access to this calendar
+    if calendar.did != session.did && !calendar.is_public {
+        return Err(HttpError::Forbidden("Access denied".to_string()));
+    }
+
+    let bookmark_service = crate::services::event_bookmarks::EventBookmarkService::new(
+        ctx.storage.clone(),
+        ctx.atproto_client.clone(),
+    );
+
+    match bookmark_service
+        .get_bookmarked_events(&calendar.did, Some(&calendar.tags), None, 1000, 0, false)
+        .await
+    {
+        Ok(paginated_events) => {
+            let ical_content = generate_ical_content(&paginated_events.events, &calendar)?;
+            
+            let filename = format!("{}.ics", calendar.name.replace(' ', "_"));
+            let headers = [
+                ("Content-Type", "text/calendar; charset=utf-8"),
+                ("Content-Disposition", &format!("attachment; filename=\"{}\"", filename)),
+            ];
+            
+            Ok((StatusCode::OK, headers, ical_content))
+        }
+        Err(e) => {
+            error!("Failed to export calendar {}: {}", calendar_id, e);
+            Err(HttpError::InternalServerError("Failed to export calendar".to_string()))
+        }
+    }
+}
+
+#[derive(Deserialize)]
+pub struct ViewCalendarParams {
+    view: Option<String>, // 'timeline' or 'calendar'
+    limit: Option<i32>,
+    offset: Option<i32>,
+}
+
+/// Generate iCal content for a specific calendar
+fn generate_ical_content(
+    events: &[crate::storage::event_bookmarks::BookmarkedEvent],
+    calendar: &BookmarkCalendar,
+) -> Result<String, HttpError> {
+    let mut ical = String::new();
+    
+    ical.push_str("BEGIN:VCALENDAR\r\n");
+    ical.push_str("VERSION:2.0\r\n");
+    ical.push_str("PRODID:-//smokesignal//bookmark-calendar//EN\r\n");
+    ical.push_str("CALSCALE:GREGORIAN\r\n");
+    ical.push_str(&format!("X-WR-CALNAME:{}\r\n", calendar.name));
+    
+    if let Some(description) = &calendar.description {
+        ical.push_str(&format!("X-WR-CALDESC:{}\r\n", description));
+    }
+    
+    for bookmarked_event in events {
+        // Parse event record to extract event details
+        if let Ok(event_data) = serde_json::from_value::<serde_json::Value>(bookmarked_event.event.record.clone()) {
+            ical.push_str("BEGIN:VEVENT\r\n");
+            
+            // Generate unique ID
+            let uid = format!("{}@smokesignal.events", bookmarked_event.event.aturi);
+            ical.push_str(&format!("UID:{}\r\n", uid));
+            
+            // Add event details
+            ical.push_str(&format!("SUMMARY:{}\r\n", bookmarked_event.event.name));
+            
+            if let Some(description) = event_data.get("description").and_then(|d| d.as_str()) {
+                ical.push_str(&format!("DESCRIPTION:{}\r\n", description));
+            }
+            
+            // Add calendar tags as categories
+            let tags = calendar.tags.join(",");
+            ical.push_str(&format!("CATEGORIES:{}\r\n", tags));
+            
+            // Add timestamps
+            let dtstamp = chrono::Utc::now().format("%Y%m%dT%H%M%SZ");
+            ical.push_str(&format!("DTSTAMP:{}\r\n", dtstamp));
+            
+            ical.push_str("END:VEVENT\r\n");
+        }
+    }
+    
+    ical.push_str("END:VCALENDAR\r\n");
+    
+    Ok(ical)
+}

backup/handle_bookmark_events_old.rs

···
+use anyhow::Result;
+use axum::{
+    extract::{Path, Query, State},
+    http::StatusCode,
+    response::{Html, IntoResponse},
+};
+use chrono::{DateTime, Utc, Datelike, Timelike};
+use minijinja::context as template_context;
+use serde::{Deserialize, Serialize};
+use std::sync::Arc;
+use tracing::{debug, error, info};
+
+use crate::create_renderer;
+use crate::http::context::{UserRequestContext, WebContext};
+use crate::http::errors::WebError;
+use crate::services::event_bookmarks::EventBookmarkService;
+use crate::storage::event_bookmarks::PaginatedBookmarkedEvents;
+
+#[derive(Deserialize)]
+pub struct BookmarkEventParams {
+    event_aturi: String,
+    tags: Option<String>, // Comma-separated tags
+}
+
+#[derive(Deserialize)]
+pub struct CalendarViewParams {
+    tags: Option<String>,
+    start_date: Option<String>,
+    end_date: Option<String>,
+    view: Option<String>, // 'timeline' or 'calendar'
+    limit: Option<i32>,
+    offset: Option<i32>,
+}
+
+#[derive(Serialize)]
+pub struct BookmarkEventResponse {
+    success: bool,
+    message: String,
+    bookmark_id: Option<i32>,
+}
+
+/// Handle bookmarking an event
+pub async fn handle_bookmark_event(
+    Query(params): Query<BookmarkEventParams>,
+    user_request_context: UserRequestContext,
+) -> Result<impl IntoResponse, WebError> {
+    let Some(auth) = user_request_context.auth else {
+        return Ok((StatusCode::UNAUTHORIZED, "Authentication required".to_string()).into_response());
+    };
+
+    let tags: Vec<String> = params
+        .tags
+        .unwrap_or_default()
+        .split(',')
+        .map(|s| s.trim().to_string())
+        .filter(|s| !s.is_empty())
+        .collect();
+
+    // Validate tags
+    if tags.len() > 10 {
+        return Ok((StatusCode::BAD_REQUEST, "Maximum 10 tags allowed".to_string()).into_response());
+    }
+
+    for tag in &tags {
+        if tag.len() > 50 {
+            return Ok((StatusCode::BAD_REQUEST, "Tag too long (maximum 50 characters)".to_string()).into_response());
+        }
+    }
+
+    let bookmark_service = EventBookmarkService::new(
+        Arc::new(user_request_context.web_context.0.pool.clone()),
+        Arc::new(user_request_context.web_context.0.atrium_oauth_manager.clone()),
+    );
+
+    match bookmark_service
+        .bookmark_event(&auth.did, &params.event_aturi, tags)
+        .await
+    {
+        Ok(_bookmark) => {
+            info!("Successfully bookmarked event {} for user {}", params.event_aturi, auth.did);
+            
+            let renderer = create_renderer!(
+                user_request_context.web_context.clone(),
+                user_request_context.language.clone(),
+                user_request_context.hx_boosted,
+                user_request_context.hx_request
+            );
+
+            let html = renderer.render("bookmark_success", template_context! {
+                event_aturi => params.event_aturi,
+            })?;
+            
+            Ok(Html(html).into_response())
+        }
+        Err(e) => {
+            error!("Failed to bookmark event {}: {}", params.event_aturi, e);
+            Ok((StatusCode::INTERNAL_SERVER_ERROR, "Failed to bookmark event".to_string()).into_response())
+        }
+    }
+}
+
+/// Handle viewing bookmark calendar (timeline or grid view)
+pub async fn handle_bookmark_calendar(
+    State(ctx): State<Arc<AppContext>>,
+    Query(params): Query<CalendarViewParams>,
+) -> Result<Html<String>, HttpError> {
+    let session = get_session_or_redirect(&ctx, &axum::http::HeaderMap::new()).await?;
+
+    let view_mode = params.view.as_deref().unwrap_or("timeline");
+    let limit = params.limit.unwrap_or(20);
+    let offset = params.offset.unwrap_or(0);
+
+    let tags: Option<Vec<String>> = params.tags.map(|tag_str| {
+        tag_str
+            .split(',')
+            .map(|s| s.trim().to_string())
+            .filter(|s| !s.is_empty())
+            .collect()
+    });
+
+    // Parse date range if provided
+    let date_range = match (params.start_date.as_ref(), params.end_date.as_ref()) {
+        (Some(start), Some(end)) => {
+            match (start.parse::<DateTime<Utc>>(), end.parse::<DateTime<Utc>>()) {
+                (Ok(start_dt), Ok(end_dt)) => Some((start_dt, end_dt)),
+                _ => {
+                    warn!("Invalid date format in calendar view params");
+                    None
+                }
+            }
+        }
+        _ => None,
+    };
+
+    let bookmark_service = EventBookmarkService::new(
+        ctx.storage.clone(),
+        ctx.atproto_client.clone(),
+    );
+
+    match bookmark_service
+        .get_bookmarked_events(
+            &session.did,
+            tags.as_deref(),
+            date_range,
+            limit,
+            offset,
+            false, // Don't force sync unless specifically requested
+        )
+        .await
+    {
+        Ok(paginated_events) => {
+            let i18n = I18nService::new(&session.language);
+            
+            let template_name = match view_mode {
+                "calendar" => "bookmark_calendar_grid",
+                _ => "bookmark_calendar_timeline",
+            };
+
+            let mut template_context = axum_template::TemplateContext::new();
+            template_context.insert("events", &paginated_events.events);
+            template_context.insert("total_count", &paginated_events.total_count);
+            template_context.insert("has_more", &paginated_events.has_more);
+            template_context.insert("current_offset", &offset);
+            template_context.insert("view_mode", view_mode);
+            template_context.insert("filter_tags", &params.tags.unwrap_or_default());
+            
+            let html = ctx.templates
+                .render(template_name, &template_context)
+                .map_err(|e| HttpError::TemplateError(e.to_string()))?;
+            
+            Ok(Html(html))
+        }
+        Err(e) => {
+            error!("Failed to get bookmarked events for user {}: {}", session.did, e);
+            Err(HttpError::InternalServerError("Failed to load bookmarks".to_string()))
+        }
+    }
+}
+
+/// Handle removing a bookmark
+pub async fn handle_remove_bookmark(
+    State(ctx): State<Arc<AppContext>>,
+    Path(bookmark_aturi): Path<String>,
+) -> Result<Html<String>, HttpError> {
+    let session = get_session_or_redirect(&ctx, &axum::http::HeaderMap::new()).await?;
+
+    // Decode the bookmark AT-URI if URL-encoded
+    let bookmark_aturi = urlencoding::decode(&bookmark_aturi)
+        .map_err(|_| HttpError::BadRequest("Invalid bookmark URI".to_string()))?
+        .to_string();
+
+    let bookmark_service = EventBookmarkService::new(
+        ctx.storage.clone(),
+        ctx.atproto_client.clone(),
+    );
+
+    match bookmark_service
+        .remove_bookmark(&session.did, &bookmark_aturi)
+        .await
+    {
+        Ok(()) => {
+            info!("Successfully removed bookmark {} for user {}", bookmark_aturi, session.did);
+            
+            // Return empty HTML for HTMX to remove the element
+            Ok(Html(String::new()))
+        }
+        Err(e) => {
+            error!("Failed to remove bookmark {}: {}", bookmark_aturi, e);
+            Err(HttpError::InternalServerError("Failed to remove bookmark".to_string()))
+        }
+    }
+}
+
+/// Handle calendar navigation (mini-calendar widget)
+pub async fn handle_calendar_navigation(
+    State(ctx): State<Arc<AppContext>>,
+    Query(params): Query<CalendarNavParams>,
+) -> Result<Html<String>, HttpError> {
+    let session = get_session_or_redirect(&ctx, &axum::http::HeaderMap::new()).await?;
+
+    let year = params.year.unwrap_or_else(|| Utc::now().year());
+    let month = params.month.unwrap_or_else(|| Utc::now().month() as i32);
+
+    // Get events for the requested month to highlight dates
+    let bookmark_service = EventBookmarkService::new(
+        ctx.storage.clone(),
+        ctx.atproto_client.clone(),
+    );
+
+    let start_of_month = chrono::NaiveDate::from_ymd_opt(year, month as u32, 1)
+        .unwrap()
+        .and_hms_opt(0, 0, 0)
+        .unwrap()
+        .and_utc();
+    
+    let end_of_month = if month == 12 {
+        chrono::NaiveDate::from_ymd_opt(year + 1, 1, 1)
+    } else {
+        chrono::NaiveDate::from_ymd_opt(year, month as u32 + 1, 1)
+    }
+    .unwrap()
+    .and_hms_opt(0, 0, 0)
+    .unwrap()
+    .and_utc();
+
+    let date_range = Some((start_of_month, end_of_month));
+
+    match bookmark_service
+        .get_bookmarked_events(&session.did, None, date_range, 1000, 0, false)
+        .await
+    {
+        Ok(paginated_events) => {
+            let mut template_context = axum_template::TemplateContext::new();
+            template_context.insert("year", &year);
+            template_context.insert("month", &month);
+            template_context.insert("events", &paginated_events.events);
+            
+            let html = ctx.templates
+                .render("mini_calendar", &template_context)
+                .map_err(|e| HttpError::TemplateError(e.to_string()))?;
+            
+            Ok(Html(html))
+        }
+        Err(e) => {
+            error!("Failed to get calendar events for user {}: {}", session.did, e);
+            Err(HttpError::InternalServerError("Failed to load calendar".to_string()))
+        }
+    }
+}
+
+/// Handle iCal export of bookmarked events
+pub async fn handle_bookmark_calendar_ical(
+    State(ctx): State<Arc<AppContext>>,
+    Query(params): Query<CalendarViewParams>,
+) -> Result<impl IntoResponse, HttpError> {
+    let session = get_session_or_redirect(&ctx, &axum::http::HeaderMap::new()).await?;
+
+    let tags: Option<Vec<String>> = params.tags.map(|tag_str| {
+        tag_str
+            .split(',')
+            .map(|s| s.trim().to_string())
+            .filter(|s| !s.is_empty())
+            .collect()
+    });
+
+    let bookmark_service = EventBookmarkService::new(
+        ctx.storage.clone(),
+        ctx.atproto_client.clone(),
+    );
+
+    match bookmark_service
+        .get_bookmarked_events(&session.did, tags.as_deref(), None, 1000, 0, false)
+        .await
+    {
+        Ok(paginated_events) => {
+            let ical_content = generate_ical_content(&paginated_events.events)?;
+            
+            let headers = [
+                ("Content-Type", "text/calendar; charset=utf-8"),
+                ("Content-Disposition", "attachment; filename=\"bookmarks.ics\""),
+            ];
+            
+            Ok((StatusCode::OK, headers, ical_content))
+        }
+        Err(e) => {
+            error!("Failed to export bookmarks for user {}: {}", session.did, e);
+            Err(HttpError::InternalServerError("Failed to export calendar".to_string()))
+        }
+    }
+}
+
+#[derive(Deserialize)]
+pub struct CalendarNavParams {
+    year: Option<i32>,
+    month: Option<i32>,
+}
+
+/// Generate iCal content from bookmarked events
+fn generate_ical_content(events: &[BookmarkedEvent]) -> Result<String, HttpError> {
+    let mut ical = String::new();
+    
+    ical.push_str("BEGIN:VCALENDAR\r\n");
+    ical.push_str("VERSION:2.0\r\n");
+    ical.push_str("PRODID:-//smokesignal//bookmarks//EN\r\n");
+    ical.push_str("CALSCALE:GREGORIAN\r\n");
+    
+    for bookmarked_event in events {
+        // Parse event record to extract event details
+        if let Ok(event_data) = serde_json::from_value::<serde_json::Value>(bookmarked_event.event.record.clone()) {
+            ical.push_str("BEGIN:VEVENT\r\n");
+            
+            // Generate unique ID
+            let uid = format!("{}@smokesignal.events", bookmarked_event.event.aturi);
+            ical.push_str(&format!("UID:{}\r\n", uid));
+            
+            // Add event details
+            ical.push_str(&format!("SUMMARY:{}\r\n", bookmarked_event.event.name));
+            
+            if let Some(description) = event_data.get("description").and_then(|d| d.as_str()) {
+                ical.push_str(&format!("DESCRIPTION:{}\r\n", description));
+            }
+            
+            // Add bookmark tags as categories
+            let tags = bookmarked_event.bookmark.tags.join(",");
+            if !tags.is_empty() {
+                ical.push_str(&format!("CATEGORIES:{}\r\n", tags));
+            }
+            
+            // Add timestamps
+            let dtstamp = Utc::now().format("%Y%m%dT%H%M%SZ");
+            ical.push_str(&format!("DTSTAMP:{}\r\n", dtstamp));
+            
+            ical.push_str("END:VEVENT\r\n");
+        }
+    }
+    
+    ical.push_str("END:VCALENDAR\r\n");
+    
+    Ok(ical)
+}

i18n/en-us/bookmarks.ftl

···
+# Event Bookmarks
+bookmark-event = Bookmark Event
+bookmark-calendar = Event Calendar
+bookmarked-events = Bookmarked Events
+timeline-view = Timeline
+calendar-view = Calendar
+filter-by-tags = Filter by Tags
+calendar-navigation = Calendar
+remove-bookmark = Remove Bookmark
+confirm-remove-bookmark = Are you sure you want to remove this bookmark?
+add-to-calendar = Add to Calendar
+create-new-calendar = Create New Calendar
+bookmark-success = Event bookmarked successfully!
+no-bookmarked-events = No bookmarked events found
+bookmark-tags = Tags (comma-separated)
+bookmark-calendar-name = Calendar Name
+bookmark-calendar-description = Description (optional)
+make-calendar-public = Make this calendar public
+bookmarked-on = Bookmarked on {$date}
+ends-at = Ends at {$time}
+
+# Enhanced calendar management
+bookmark-calendars = Custom Calendars
+create-calendar = Create Calendar
+create-bookmark-calendar = Create Custom Calendar
+create-new-calendar = Create New Calendar
+calendar-name = Calendar Name
+calendar-name-placeholder = e.g. Summer Festivals, Work Events
+calendar-name-help = Choose a descriptive name for your calendar
+calendar-tags = Tags
+add-tag-placeholder = Add a tag and press Enter
+calendar-tags-help = Add tags to organize your calendar
+calendar-description-placeholder = What types of events will you collect?
+make-calendar-public = Make this calendar public
+public-calendar-help = Public calendars appear on your profile and can be discovered by others
+atproto-privacy-notice = Privacy Notice
+atproto-privacy-explanation = Your bookmarks and tags are always public on the ATproto network. This setting only controls whether this calendar appears on your smokesignal profile.
+my-calendars = My Calendars
+public-calendars = Public Calendars
+no-public-calendars = No public calendars yet
+export-calendar = Export Calendar
+share-calendar = Share Calendar
+events = events
+created = Created on
+calendar-updated = Calendar updated successfully
+calendar-created = Calendar created successfully
+event-added-to-calendar = Event added to calendar
+
+# Tag management
+calendar-tags-help = Add multiple tags to organize this calendar (press Enter or comma to add)
+tag-suggestions = Suggested tags
+calendar-created-success = Calendar created with {$count} tags
+calendar-updated-success = Calendar updated with {$count} tags
+tag-match-all = Show events with ALL tags
+tag-match-any = Show events with ANY tags
+tag-strategy = Tag matching
+tag-strategy-help = Choose how events are matched to this calendar
+tag-operator = Tag operator
+tag-operator-help = Combine tags with AND (all required) or OR (any required)
+error-creating-calendar = Error creating calendar
+error-max-tags = Maximum 10 tags allowed per calendar
+error-empty-tag = Empty tags are not allowed
+error-tag-too-long = Tag too long (maximum 50 characters)

i18n/fr-ca/bookmarks.ftl

···
+# Signets d'événements
+bookmark-event = Marquer l'événement
+bookmark-calendar = Calendrier des événements
+bookmarked-events = Événements marqués
+timeline-view = Vue chronologique
+calendar-view = Vue calendrier
+filter-by-tags = Filtrer par étiquettes
+calendar-navigation = Navigation
+remove-bookmark = Retirer le marque-page
+confirm-remove-bookmark = Êtes-vous sûr·e de vouloir retirer ce marque-page?
+add-to-calendar = Ajouter au calendrier
+create-new-calendar = Créer un nouveau calendrier
+bookmark-success = Événement marqué avec succès!
+no-bookmarked-events = Aucun événement marqué trouvé
+bookmark-tags = Étiquettes (séparées par des virgules)
+bookmark-calendar-name = Nom du calendrier
+bookmark-calendar-description = Description (optionnelle)
+make-calendar-public = Rendre ce calendrier public
+bookmarked-on = Marqué le {$date}
+ends-at = Se termine à {$time}
+
+# Gestion avancée des calendriers
+bookmark-calendars = Calendriers personnalisés
+create-calendar = Créer un calendrier
+create-bookmark-calendar = Créer un calendrier personnalisé
+create-new-calendar = Créer un nouveau calendrier
+calendar-name = Nom du calendrier
+calendar-name-placeholder = ex. Festivals d'été, Événements de travail
+calendar-name-help = Choisissez un nom descriptif pour votre calendrier
+calendar-tags = Étiquettes
+add-tag-placeholder = Ajouter une étiquette et appuyer sur Entrée
+calendar-tags-help = Ajoutez des étiquettes pour organiser votre calendrier
+calendar-description-placeholder = Quels types d'événements allez-vous collecter ?
+make-calendar-public = Rendre ce calendrier public
+public-calendar-help = Les calendriers publics apparaissent sur votre profil et peuvent être découverts par d'autres
+atproto-privacy-notice = Avis de confidentialité
+atproto-privacy-explanation = Vos signets et étiquettes sont toujours publics sur le réseau ATproto. Ce paramètre contrôle seulement si ce calendrier apparaît sur votre profil smokesignal.
+my-calendars = Mes calendriers
+public-calendars = Calendriers publics
+no-public-calendars = Pas encore de calendriers publics
+export-calendar = Exporter le calendrier
+share-calendar = Partager le calendrier
+events = événements
+created = Créé le
+calendar-updated = Calendrier mis à jour avec succès
+calendar-created = Calendrier créé avec succès
+event-added-to-calendar = Événement ajouté au calendrier
+
+# Gestion des étiquettes
+calendar-tags-help = Ajoutez plusieurs étiquettes pour organiser ce calendrier (appuyez sur Entrée ou virgule pour ajouter)
+tag-suggestions = Étiquettes suggérées
+calendar-created-success = Calendrier créé avec {$count} étiquettes
+calendar-updated-success = Calendrier mis à jour avec {$count} étiquettes
+tag-match-all = Afficher les événements avec TOUTES les étiquettes
+tag-match-any = Afficher les événements avec N'IMPORTE QUELLE étiquette
+tag-strategy = Correspondance d'étiquettes
+tag-strategy-help = Choisissez comment les événements correspondent à ce calendrier
+tag-operator = Opérateur d'étiquettes
+tag-operator-help = Combinez les étiquettes avec ET (toutes requises) ou OU (n'importe laquelle requise)
+error-creating-calendar = Erreur lors de la création du calendrier
+error-max-tags = Maximum 10 étiquettes autorisées par calendrier
+error-empty-tag = Les étiquettes vides ne sont pas autorisées
+error-tag-too-long = Étiquette trop longue (maximum 50 caractères)

migrations/20250618120000_bookmarks.sql

···
+-- Event bookmarks migration
+-- This creates the core tables for the bookmark calendar feature
+
+-- Event bookmarks table (local cache for performance)
+CREATE TABLE event_bookmarks (
+    id SERIAL PRIMARY KEY,
+    did VARCHAR(512) NOT NULL,
+    bookmark_aturi VARCHAR(1024) NOT NULL, -- ATproto bookmark record URI
+    event_aturi VARCHAR(1024) NOT NULL,    -- Event being bookmarked
+    tags TEXT[] NOT NULL DEFAULT '{}',     -- Tags for organization
+    synced_at TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT NOW(),
+    created_at TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT NOW(),
+    UNIQUE(did, event_aturi), -- Prevent duplicate event bookmarks
+    FOREIGN KEY (event_aturi) REFERENCES events(aturi) ON DELETE CASCADE
+);
+
+-- Bookmark calendars table (user-created collections)
+CREATE TABLE bookmark_calendars (
+    id SERIAL PRIMARY KEY,
+    calendar_id VARCHAR(64) NOT NULL, -- Public identifier for sharing
+    did VARCHAR(512) NOT NULL,
+    name VARCHAR(256) NOT NULL,
+    description TEXT DEFAULT NULL,
+    tags TEXT[] NOT NULL,             -- Tags that define this calendar
+    tag_operator VARCHAR(16) NOT NULL DEFAULT 'OR', -- 'AND' or 'OR' for tag matching
+    is_public BOOLEAN NOT NULL DEFAULT FALSE,
+    event_count INTEGER NOT NULL DEFAULT 0,
+    created_at TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT NOW(),
+    updated_at TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT NOW(),
+    UNIQUE(calendar_id),
+    CHECK(array_length(tags, 1) > 0), -- Ensure at least one tag per calendar
+    CHECK(tag_operator IN ('AND', 'OR')),
+    CHECK(array_length(tags, 1) <= 10) -- Maximum 10 tags per calendar
+);
+
+-- Indexes for event_bookmarks
+CREATE INDEX idx_event_bookmarks_did ON event_bookmarks(did);
+CREATE INDEX idx_event_bookmarks_event_aturi ON event_bookmarks(event_aturi);
+CREATE INDEX idx_event_bookmarks_tags ON event_bookmarks USING GIN(tags);
+CREATE INDEX idx_event_bookmarks_synced_at ON event_bookmarks(synced_at);
+
+-- Indexes for bookmark_calendars
+CREATE INDEX idx_bookmark_calendars_did ON bookmark_calendars(did);
+CREATE INDEX idx_bookmark_calendars_public ON bookmark_calendars(is_public) WHERE is_public = true;
+CREATE INDEX idx_bookmark_calendars_tags ON bookmark_calendars USING GIN(tags);
+CREATE INDEX idx_bookmark_calendars_calendar_id ON bookmark_calendars(calendar_id);

src/atproto/lexicon/community_lexicon_bookmarks.rs

···
+use chrono::{DateTime, Utc};
+use serde::{Deserialize, Serialize};
+
+pub const BOOKMARK_NSID: &str = "community.lexicon.bookmarks.bookmark";
+pub const GET_BOOKMARKS_NSID: &str = "community.lexicon.bookmarks.getActorBookmarks";
+
+#[derive(Debug, Serialize, Deserialize, Clone)]
+pub struct Bookmark {
+    pub subject: String,     // Event AT-URI (e.g., at://did:plc:xyz/community.lexicon.calendar.event/abc123)
+    pub tags: Vec<String>,   // Tags are required for organization
+    #[serde(rename = "createdAt")]
+    pub created_at: DateTime<Utc>,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct GetActorBookmarksParams {
+    pub actor: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub cursor: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub limit: Option<u32>,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct GetActorBookmarksResponse {
+    pub bookmarks: Vec<BookmarkRecord>, // Returns full bookmark records with AT-URIs
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub cursor: Option<String>,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct BookmarkRecord {
+    pub uri: String,        // AT-URI of the bookmark record itself
+    pub value: Bookmark,    // The bookmark data
+    #[serde(rename = "indexedAt")]
+    pub indexed_at: DateTime<Utc>,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct CreateBookmarkInput {
+    pub repo: String,       // User's DID
+    pub collection: String, // Should be BOOKMARK_NSID
+    pub record: Bookmark,   // The bookmark record to create
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct CreateBookmarkResponse {
+    pub uri: String,        // AT-URI of the created bookmark record
+    pub cid: String,        // Content identifier
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct DeleteBookmarkInput {
+    pub repo: String,       // User's DID
+    pub collection: String, // Should be BOOKMARK_NSID
+    pub rkey: String,       // Record key from the bookmark URI
+}

src/atproto/lexicon/mod.rs

···
 pub mod com_atproto_repo;
+mod community_lexicon_bookmarks;
 mod community_lexicon_calendar_event;
 mod community_lexicon_calendar_rsvp;
 pub mod community_lexicon_location;
···
 
 pub mod community {
     pub mod lexicon {
+        pub mod bookmarks {
+            pub use crate::atproto::lexicon::community_lexicon_bookmarks::*;
+        }
         pub mod calendar {
             pub mod event {
                 pub use crate::atproto::lexicon::community_lexicon_calendar_event::*;

src/http/handle_bookmark_calendars.rs

···
+use axum::{
+    extract::{Path},
+    response::{Html, IntoResponse},
+    http::StatusCode,
+    Json,
+};
+use axum_htmx::HxBoosted;
+use minijinja::context as template_context;
+use serde::Deserialize;
+use tracing::{error, info};
+
+use crate::create_renderer;
+use crate::http::context::UserRequestContext;
+use crate::http::errors::WebError;
+use crate::storage::bookmark_calendars::{BookmarkCalendar, generate_calendar_id};
+
+#[derive(Deserialize)]
+pub struct CreateBookmarkCalendarParams {
+    name: String,
+    description: Option<String>,
+    tags: Option<String>, // JSON array as string
+    tag_operator: Option<String>, // "AND" or "OR"
+    is_public: Option<bool>,
+}
+
+#[derive(Deserialize)]
+pub struct UpdateBookmarkCalendarParams {
+    name: String,
+    description: Option<String>,
+    tags: Option<String>, // JSON array as string
+    tag_operator: Option<String>, // "AND" or "OR"
+    is_public: Option<bool>,
+}
+
+/// Handle viewing the bookmark calendars index
+pub async fn handle_bookmark_calendars_index(
+    ctx: UserRequestContext,
+    HxBoosted(hx_boosted): HxBoosted,
+) -> Result<impl IntoResponse, WebError> {
+    let current_handle = ctx.auth.require(&ctx.web_context.config.destination_key, "/bookmark-calendars")?;
+
+    // Create the template renderer with enhanced context
+    let language_clone = ctx.language.clone();
+    let renderer = create_renderer!(ctx.web_context.clone(), language_clone, hx_boosted, false);
+
+    // For now, return empty calendars list
+    let template_context = template_context! {
+        calendars => Vec::<BookmarkCalendar>::new(),
+        user_did => current_handle.did,
+    };
+
+    let html = renderer.render_template(
+        "bookmark_calendars_index", 
+        template_context, 
+        ctx.current_handle.as_ref(),
+        "/bookmark-calendars"
+    );
+    Ok(Html(html).into_response())
+}
+
+/// Handle creating a new bookmark calendar
+pub async fn handle_create_bookmark_calendar(
+    ctx: UserRequestContext,
+    Json(payload): Json<CreateBookmarkCalendarParams>,
+) -> Result<impl IntoResponse, WebError> {
+    let current_handle = ctx.auth.require(&ctx.web_context.config.destination_key, "/bookmark-calendars")?;
+
+    // Parse tags from JSON string
+    let tags: Vec<String> = if let Some(tags_str) = payload.tags {
+        serde_json::from_str(&tags_str).unwrap_or_default()
+    } else {
+        Vec::new()
+    };
+
+    // Validate input
+    if payload.name.trim().is_empty() {
+        return Ok((StatusCode::BAD_REQUEST, "Calendar name is required".to_string()).into_response());
+    }
+
+    if tags.len() > 10 {
+        return Ok((StatusCode::BAD_REQUEST, "Maximum 10 tags allowed per calendar".to_string()).into_response());
+    }
+
+    for tag in &tags {
+        if tag.len() > 50 {
+            return Ok((StatusCode::BAD_REQUEST, "Tag too long (maximum 50 characters)".to_string()).into_response());
+        }
+    }
+
+    let calendar = BookmarkCalendar {
+        id: 0, // Will be set by database
+        calendar_id: generate_calendar_id(),
+        did: current_handle.did.clone(),
+        name: payload.name.trim().to_string(),
+        description: payload.description,
+        tags,
+        tag_operator: payload.tag_operator.unwrap_or_else(|| "OR".to_string()),
+        is_public: payload.is_public.unwrap_or(false),
+        event_count: 0,
+        created_at: chrono::Utc::now(),
+        updated_at: chrono::Utc::now(),
+    };
+
+    match crate::storage::bookmark_calendars::insert(&ctx.web_context.pool, &calendar).await {
+        Ok(created_calendar) => {
+            info!("Successfully created calendar {} for user {}", created_calendar.calendar_id, current_handle.did);
+            
+            let html = format!(
+                r#"<div class="notification is-success">
+                    <p>Calendar "{}" created successfully!</p>
+                </div>"#,
+                created_calendar.name
+            );
+            
+            Ok(Html(html).into_response())
+        }
+        Err(e) => {
+            error!("Failed to create calendar: {}", e);
+            Ok((StatusCode::INTERNAL_SERVER_ERROR, "Failed to create calendar".to_string()).into_response())
+        }
+    }
+}
+
+/// Handle viewing a specific bookmark calendar
+pub async fn handle_view_bookmark_calendar(
+    ctx: UserRequestContext,
+    HxBoosted(hx_boosted): HxBoosted,
+    Path(calendar_id): Path<String>,
+) -> Result<impl IntoResponse, WebError> {
+    let current_handle = ctx.auth.require(&ctx.web_context.config.destination_key, "/bookmark-calendars")?;
+
+    // Create the template renderer with enhanced context
+    let language_clone = ctx.language.clone();
+    let renderer = create_renderer!(ctx.web_context.clone(), language_clone, hx_boosted, false);
+
+    match crate::storage::bookmark_calendars::get_by_calendar_id(&ctx.web_context.pool, &calendar_id).await {
+        Ok(Some(calendar)) => {
+            // Check if user owns this calendar or if it's public
+            if calendar.did != current_handle.did && !calendar.is_public {
+                return Ok((StatusCode::FORBIDDEN, "Access denied".to_string()).into_response());
+            }
+
+            let template_context = template_context! {
+                calendar => calendar,
+                is_owner => calendar.did == current_handle.did,
+                events => Vec::<String>::new(), // TODO: Fetch events for this calendar
+            };
+
+            let html = renderer.render_template(
+                "bookmark_calendar_view", 
+                template_context, 
+                ctx.current_handle.as_ref(),
+                &format!("/bookmark-calendars/{}", calendar_id)
+            );
+            Ok(Html(html).into_response())
+        }
+        Ok(None) => {
+            Ok((StatusCode::NOT_FOUND, "Calendar not found".to_string()).into_response())
+        }
+        Err(e) => {
+            error!("Failed to get calendar {}: {}", calendar_id, e);
+            Ok((StatusCode::INTERNAL_SERVER_ERROR, "Failed to load calendar".to_string()).into_response())
+        }
+    }
+}
+
+/// Handle updating a bookmark calendar
+pub async fn handle_update_bookmark_calendar(
+    ctx: UserRequestContext,
+    Path(calendar_id): Path<String>,
+    Json(payload): Json<UpdateBookmarkCalendarParams>,
+) -> Result<impl IntoResponse, WebError> {
+    let current_handle = ctx.auth.require(&ctx.web_context.config.destination_key, "/bookmark-calendars")?;
+
+    // Get existing calendar
+    let calendar = match crate::storage::bookmark_calendars::get_by_calendar_id(&ctx.web_context.pool, &calendar_id).await {
+        Ok(Some(calendar)) => calendar,
+        Ok(None) => {
+            return Ok((StatusCode::NOT_FOUND, "Calendar not found".to_string()).into_response());
+        }
+        Err(e) => {
+            error!("Failed to get calendar {}: {}", calendar_id, e);
+            return Ok((StatusCode::INTERNAL_SERVER_ERROR, "Failed to load calendar".to_string()).into_response());
+        }
+    };
+
+    // Check ownership
+    if calendar.did != current_handle.did {
+        return Ok((StatusCode::FORBIDDEN, "Access denied".to_string()).into_response());
+    }
+
+    // Parse tags from JSON string
+    let tags: Vec<String> = if let Some(tags_str) = payload.tags {
+        serde_json::from_str(&tags_str).unwrap_or_default()
+    } else {
+        calendar.tags.clone()
+    };
+
+    // Validate input
+    if payload.name.trim().is_empty() {
+        return Ok((StatusCode::BAD_REQUEST, "Calendar name is required".to_string()).into_response());
+    }
+
+    if tags.len() > 10 {
+        return Ok((StatusCode::BAD_REQUEST, "Maximum 10 tags allowed per calendar".to_string()).into_response());
+    }
+
+    let mut updated_calendar = calendar;
+    updated_calendar.name = payload.name.trim().to_string();
+    updated_calendar.description = payload.description;
+    updated_calendar.tags = tags;
+    updated_calendar.tag_operator = payload.tag_operator.unwrap_or(updated_calendar.tag_operator);
+    updated_calendar.is_public = payload.is_public.unwrap_or(updated_calendar.is_public);
+    updated_calendar.updated_at = chrono::Utc::now();
+
+    match crate::storage::bookmark_calendars::update(&ctx.web_context.pool, &updated_calendar).await {
+        Ok(()) => {
+            info!("Successfully updated calendar {} for user {}", calendar_id, current_handle.did);
+            
+            let html = format!(
+                r#"<div class="notification is-success">
+                    <p>Calendar "{}" updated successfully!</p>
+                </div>"#,
+                updated_calendar.name
+            );
+            
+            Ok(Html(html).into_response())
+        }
+        Err(e) => {
+            error!("Failed to update calendar {}: {}", calendar_id, e);
+            Ok((StatusCode::INTERNAL_SERVER_ERROR, "Failed to update calendar".to_string()).into_response())
+        }
+    }
+}
+
+/// Handle deleting a bookmark calendar
+pub async fn handle_delete_bookmark_calendar(
+    ctx: UserRequestContext,
+    Path(calendar_id): Path<String>,
+) -> Result<impl IntoResponse, WebError> {
+    let current_handle = ctx.auth.require(&ctx.web_context.config.destination_key, "/bookmark-calendars")?;
+
+    // Get existing calendar to check ownership
+    let calendar = match crate::storage::bookmark_calendars::get_by_calendar_id(&ctx.web_context.pool, &calendar_id).await {
+        Ok(Some(calendar)) => calendar,
+        Ok(None) => {
+            return Ok((StatusCode::NOT_FOUND, "Calendar not found".to_string()).into_response());
+        }
+        Err(e) => {
+            error!("Failed to get calendar {}: {}", calendar_id, e);
+            return Ok((StatusCode::INTERNAL_SERVER_ERROR, "Failed to load calendar".to_string()).into_response());
+        }
+    };
+
+    // Check ownership
+    if calendar.did != current_handle.did {
+        return Ok((StatusCode::FORBIDDEN, "Access denied".to_string()).into_response());
+    }
+
+    match crate::storage::bookmark_calendars::delete(&ctx.web_context.pool, &calendar_id, &current_handle.did).await {
+        Ok(()) => {
+            info!("Successfully deleted calendar {} for user {}", calendar_id, current_handle.did);
+            
+            // Return empty HTML for HTMX to remove the element
+            Ok(Html(String::new()).into_response())
+        }
+        Err(e) => {
+            error!("Failed to delete calendar {}: {}", calendar_id, e);
+            Ok((StatusCode::INTERNAL_SERVER_ERROR, "Failed to delete calendar".to_string()).into_response())
+        }
+    }
+}
+
+/// Handle exporting a calendar as iCal
+pub async fn handle_export_calendar_ical(
+    ctx: UserRequestContext,
+    Path(calendar_id): Path<String>,
+) -> Result<impl IntoResponse, WebError> {
+    let current_handle = ctx.auth.require(&ctx.web_context.config.destination_key, "/bookmark-calendars")?;
+
+    // Get calendar
+    let calendar = match crate::storage::bookmark_calendars::get_by_calendar_id(&ctx.web_context.pool, &calendar_id).await {
+        Ok(Some(calendar)) => calendar,
+        Ok(None) => {
+            return Ok((StatusCode::NOT_FOUND, "Calendar not found".to_string()).into_response());
+        }
+        Err(e) => {
+            error!("Failed to get calendar {}: {}", calendar_id, e);
+            return Ok((StatusCode::INTERNAL_SERVER_ERROR, "Failed to load calendar".to_string()).into_response());
+        }
+    };
+
+    // Check access
+    if calendar.did != current_handle.did && !calendar.is_public {
+        return Ok((StatusCode::FORBIDDEN, "Access denied".to_string()).into_response());
+    }
+
+    // Generate iCal content - simplified for now
+    let ical_content = format!(
+        "BEGIN:VCALENDAR\r\nVERSION:2.0\r\nPRODID:-//smokesignal//EN\r\nX-WR-CALNAME:{}\r\nEND:VCALENDAR\r\n",
+        calendar.name
+    );
+
+    let headers = [
+        ("Content-Type", "text/calendar; charset=utf-8"),
+        ("Content-Disposition", &format!("attachment; filename=\"{}.ics\"", calendar.name.replace(' ', "_"))),
+    ];
+
+    Ok((StatusCode::OK, headers, ical_content).into_response())
+}

src/http/handle_bookmark_events.rs

···
+use axum::{
+    extract::{Path, Query},
+    response::{Html, IntoResponse},
+    http::StatusCode,
+};
+use axum_htmx::HxBoosted;
+use chrono::Datelike;
+use minijinja::context as template_context;
+use serde::{Deserialize, Serialize};
+use std::sync::Arc;
+use tracing::{error, info};
+
+use crate::create_renderer;
+use crate::http::context::UserRequestContext;
+use crate::http::errors::WebError;
+use crate::services::event_bookmarks::EventBookmarkService;
+
+#[derive(Deserialize)]
+pub struct BookmarkEventParams {
+    event_aturi: String,
+    tags: Option<String>, // Comma-separated tags
+}
+
+#[derive(Deserialize)]
+pub struct CalendarViewParams {
+    tags: Option<String>,
+    #[allow(dead_code)]
+    start_date: Option<String>,
+    #[allow(dead_code)]
+    end_date: Option<String>,
+    view: Option<String>, // 'timeline' or 'calendar'
+    limit: Option<i32>,
+    offset: Option<i32>,
+}
+
+#[derive(Serialize)]
+pub struct BookmarkEventResponse {
+    success: bool,
+    message: String,
+    bookmark_id: Option<i32>,
+}
+
+/// Handle bookmarking an event
+pub async fn handle_bookmark_event(
+    ctx: UserRequestContext,
+    Query(params): Query<BookmarkEventParams>,
+) -> Result<impl IntoResponse, WebError> {
+    let current_handle = ctx.auth.require(&ctx.web_context.config.destination_key, "/bookmarks")?;
+
+    let tags: Vec<String> = params
+        .tags
+        .unwrap_or_default()
+        .split(',')
+        .map(|s| s.trim().to_string())
+        .filter(|s| !s.is_empty())
+        .collect();
+
+    // Validate tags
+    if tags.len() > 10 {
+        return Ok((StatusCode::BAD_REQUEST, "Maximum 10 tags allowed".to_string()).into_response());
+    }
+
+    for tag in &tags {
+        if tag.len() > 50 {
+            return Ok((StatusCode::BAD_REQUEST, "Tag too long (maximum 50 characters)".to_string()).into_response());
+        }
+    }
+
+    let bookmark_service = EventBookmarkService::new(
+        Arc::new(ctx.web_context.pool.clone()),
+        Arc::new(ctx.web_context.atrium_oauth_manager.clone()),
+    );
+
+    match bookmark_service
+        .bookmark_event(&current_handle.did, &params.event_aturi, tags)
+        .await
+    {
+        Ok(_bookmark) => {
+            info!("Successfully bookmarked event {} for user {}", params.event_aturi, current_handle.did);
+            
+            let html = r#"<div class="notification is-success">
+                <p>Event bookmarked successfully!</p>
+            </div>"#;
+            
+            Ok(Html(html.to_string()).into_response())
+        }
+        Err(e) => {
+            error!("Failed to bookmark event {}: {}", params.event_aturi, e);
+            Ok((StatusCode::INTERNAL_SERVER_ERROR, "Failed to bookmark event".to_string()).into_response())
+        }
+    }
+}
+
+/// Handle viewing the bookmark calendar timeline
+pub async fn handle_bookmark_calendar(
+    ctx: UserRequestContext,
+    HxBoosted(hx_boosted): HxBoosted,
+    Query(params): Query<CalendarViewParams>,
+) -> Result<impl IntoResponse, WebError> {
+    let current_handle = ctx.auth.require(&ctx.web_context.config.destination_key, "/bookmarks")?;
+
+    let view_mode = params.view.as_deref().unwrap_or("timeline");
+    let limit = params.limit.unwrap_or(20);
+    let offset = params.offset.unwrap_or(0);
+
+    // Create the template renderer with enhanced context
+    let language_clone = ctx.language.clone();
+    let renderer = create_renderer!(ctx.web_context.clone(), language_clone, hx_boosted, false);
+
+    let bookmark_service = EventBookmarkService::new(
+        Arc::new(ctx.web_context.pool.clone()),
+        Arc::new(ctx.web_context.atrium_oauth_manager.clone()),
+    );
+
+    // Parse tags if provided
+    let tags: Option<Vec<String>> = params.tags.as_ref().map(|tag_str| {
+        tag_str
+            .split(',')
+            .map(|s| s.trim().to_string())
+            .filter(|s| !s.is_empty())
+            .collect()
+    });
+
+    match bookmark_service
+        .get_bookmarked_events(
+            &current_handle.did,
+            tags.as_deref(),
+            None, // No date range for now
+            limit,
+            offset,
+            false,
+        )
+        .await
+    {
+        Ok(paginated_events) => {
+            let template_name = match view_mode {
+                "calendar" => "bookmark_calendar_grid",
+                _ => "bookmark_calendar_timeline",
+            };
+
+            let template_context = template_context! {
+                events => paginated_events.events,
+                total_count => paginated_events.total_count,
+                has_more => paginated_events.has_more,
+                current_offset => offset,
+                view_mode => view_mode,
+                filter_tags => params.tags.unwrap_or_default(),
+            };
+            
+            let html = renderer.render_template(
+                template_name, 
+                template_context, 
+                ctx.current_handle.as_ref(),
+                "/bookmarks"
+            );
+            Ok(Html(html).into_response())
+        }
+        Err(e) => {
+            error!("Failed to get bookmarked events for user {}: {}", current_handle.did, e);
+            Ok((StatusCode::INTERNAL_SERVER_ERROR, "Failed to load bookmarks".to_string()).into_response())
+        }
+    }
+}
+
+/// Handle removing a bookmark
+pub async fn handle_remove_bookmark(
+    ctx: UserRequestContext,
+    Path(bookmark_aturi): Path<String>,
+) -> Result<impl IntoResponse, WebError> {
+    let current_handle = ctx.auth.require(&ctx.web_context.config.destination_key, "/bookmarks")?;
+
+    // Decode the bookmark AT-URI if URL-encoded
+    let bookmark_aturi = urlencoding::decode(&bookmark_aturi)
+        .map_err(|_| anyhow::anyhow!("Invalid bookmark URI"))?
+        .to_string();
+
+    let bookmark_service = EventBookmarkService::new(
+        Arc::new(ctx.web_context.pool.clone()),
+        Arc::new(ctx.web_context.atrium_oauth_manager.clone()),
+    );
+
+    match bookmark_service
+        .remove_bookmark(&current_handle.did, &bookmark_aturi)
+        .await
+    {
+        Ok(()) => {
+            info!("Successfully removed bookmark {} for user {}", bookmark_aturi, current_handle.did);
+            
+            // Return empty HTML for HTMX to remove the element
+            Ok(Html(String::new()).into_response())
+        }
+        Err(e) => {
+            error!("Failed to remove bookmark {}: {}", bookmark_aturi, e);
+            Ok((StatusCode::INTERNAL_SERVER_ERROR, "Failed to remove bookmark".to_string()).into_response())
+        }
+    }
+}
+
+/// Handle calendar navigation (mini calendar component)
+pub async fn handle_calendar_navigation(
+    ctx: UserRequestContext,
+    Query(params): Query<CalendarNavParams>,
+) -> Result<impl IntoResponse, WebError> {
+    let _current_handle = ctx.auth.require(&ctx.web_context.config.destination_key, "/bookmarks")?;
+
+    let year = params.year.unwrap_or_else(|| chrono::Utc::now().year());
+    let month = params.month.unwrap_or_else(|| chrono::Utc::now().month() as i32);
+
+    // Create the template renderer with enhanced context
+    let language_clone = ctx.language.clone();
+    let renderer = create_renderer!(ctx.web_context.clone(), language_clone, false, false);
+
+    let template_context = template_context! {
+        year => year,
+        month => month,
+        month_names => vec![
+            "January", "February", "March", "April", "May", "June",
+            "July", "August", "September", "October", "November", "December"
+        ],
+        events => Vec::<String>::new(), // TODO: Fetch events for this month
+    };
+
+    let html = renderer.render_template(
+        "mini_calendar", 
+        template_context, 
+        ctx.current_handle.as_ref(),
+        "/bookmarks/calendar-nav"
+    );
+    Ok(Html(html).into_response())
+}
+
+/// Handle exporting bookmarks as iCal
+pub async fn handle_bookmark_calendar_ical(
+    ctx: UserRequestContext,
+    Query(params): Query<CalendarViewParams>,
+) -> Result<impl IntoResponse, WebError> {
+    let current_handle = ctx.auth.require(&ctx.web_context.config.destination_key, "/bookmarks")?;
+
+    let bookmark_service = EventBookmarkService::new(
+        Arc::new(ctx.web_context.pool.clone()),
+        Arc::new(ctx.web_context.atrium_oauth_manager.clone()),
+    );
+
+    // Parse tags if provided
+    let tags: Option<Vec<String>> = params.tags.as_ref().map(|tag_str| {
+        tag_str
+            .split(',')
+            .map(|s| s.trim().to_string())
+            .filter(|s| !s.is_empty())
+            .collect()
+    });
+
+    match bookmark_service
+        .get_bookmarked_events(
+            &current_handle.did,
+            tags.as_deref(),
+            None,
+            1000, // Get all events for export
+            0,
+            false,
+        )
+        .await
+    {
+        Ok(paginated_events) => {
+            // Generate iCal content
+            let ical_content = generate_ical_from_bookmarks(&paginated_events.events);
+
+            let headers = [
+                ("Content-Type", "text/calendar; charset=utf-8"),
+                ("Content-Disposition", "attachment; filename=\"bookmarks.ics\""),
+            ];
+
+            Ok((StatusCode::OK, headers, ical_content).into_response())
+        }
+        Err(e) => {
+            error!("Failed to export bookmarks for user {}: {}", current_handle.did, e);
+            Ok((StatusCode::INTERNAL_SERVER_ERROR, "Failed to export calendar".to_string()).into_response())
+        }
+    }
+}
+
+#[derive(Deserialize)]
+pub struct CalendarNavParams {
+    year: Option<i32>,
+    month: Option<i32>,
+}
+
+/// Generate iCal content from bookmarked events
+fn generate_ical_from_bookmarks(bookmarks: &[crate::storage::event_bookmarks::EventBookmark]) -> String {
+    let mut ical = String::from("BEGIN:VCALENDAR\r\nVERSION:2.0\r\nPRODID:-//smokesignal//EN\r\n");
+    
+    for bookmark in bookmarks {
+        ical.push_str(&format!(
+            "BEGIN:VEVENT\r\nUID:{}\r\nSUMMARY:Bookmarked Event\r\nDTSTAMP:{}\r\nEND:VEVENT\r\n",
+            bookmark.id,
+            bookmark.created_at.format("%Y%m%dT%H%M%SZ")
+        ));
+    }
+    
+    ical.push_str("END:VCALENDAR\r\n");
+    ical
+}

src/http/mod.rs

···
 pub mod handle_ical_event; // New iCal handler
 pub mod handle_view_feed;
 pub mod handle_view_rsvp;
+pub mod handle_bookmark_events;
+pub mod handle_bookmark_calendars;
 pub mod location_edit_status;
 pub mod macros;
 pub mod middleware_auth;

src/http/server.rs

···
 use axum::{
     http::HeaderValue,
     middleware::{from_fn, from_fn_with_state},
-    routing::{get, post},
+    routing::{delete, get, post, put},
     Router,
 };
 use axum_htmx::AutoVaryLayer;
···
     handle_ical_event::handle_ical_event,
     handle_view_feed::handle_view_feed,
     handle_view_rsvp::handle_view_rsvp,
+    handle_bookmark_events::{
+        handle_bookmark_event, handle_bookmark_calendar, handle_remove_bookmark,
+        handle_calendar_navigation, handle_bookmark_calendar_ical,
+    },
+    handle_bookmark_calendars::{
+        handle_bookmark_calendars_index, handle_create_bookmark_calendar,
+        handle_view_bookmark_calendar, handle_update_bookmark_calendar,
+        handle_delete_bookmark_calendar, handle_export_calendar_ical,
+    },
     middleware_filter,
     middleware_timezone,
 };
···
         .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))
+        // Bookmark event routes
+        .route("/bookmarks", get(handle_bookmark_calendar))
+        .route("/bookmarks", post(handle_bookmark_event))
+        .route("/bookmarks/:bookmark_aturi", delete(handle_remove_bookmark))
+        .route("/bookmarks/calendar-nav", get(handle_calendar_navigation))
+        .route("/bookmarks.ics", get(handle_bookmark_calendar_ical))
+        // Bookmark calendar management routes
+        .route("/bookmark-calendars", get(handle_bookmark_calendars_index))
+        .route("/bookmark-calendars", post(handle_create_bookmark_calendar))
+        .route("/bookmark-calendars/:calendar_id", get(handle_view_bookmark_calendar))
+        .route("/bookmark-calendars/:calendar_id", put(handle_update_bookmark_calendar))
+        .route("/bookmark-calendars/:calendar_id", delete(handle_delete_bookmark_calendar))
+        .route("/bookmark-calendars/:calendar_id.ics", get(handle_export_calendar_ical))
         .route("/favicon.ico", get(|| async { axum::response::Redirect::permanent("/static/favicon.ico") }))
         .route("/{handle_slug}", get(handle_profile_view))
         .nest_service("/static", serve_dir.clone())

src/services/event_bookmarks.rs

···
+use anyhow::Result;
+use chrono::{DateTime, Utc};
+use std::sync::Arc;
+use tracing::{debug, info};
+use uuid::Uuid;
+
+use crate::atproto::atrium_auth::AtriumOAuthManager;
+use crate::storage::{event_bookmarks, StoragePool};
+use crate::storage::event_bookmarks::{EventBookmark, PaginatedBookmarkedEvents};
+
+pub struct EventBookmarkService {
+    storage: Arc<StoragePool>,
+    #[allow(dead_code)]
+    oauth_manager: Arc<AtriumOAuthManager>,
+}
+
+impl EventBookmarkService {
+    pub fn new(storage: Arc<StoragePool>, oauth_manager: Arc<AtriumOAuthManager>) -> Self {
+        Self {
+            storage,
+            oauth_manager,
+        }
+    }
+
+    /// Bookmark an event with tags
+    pub async fn bookmark_event(
+        &self,
+        did: &str,
+        event_aturi: &str,
+        tags: Vec<String>,
+    ) -> Result<EventBookmark> {
+        info!("Creating bookmark for event {} by user {}", event_aturi, did);
+
+        // For now, create a fake bookmark AT-URI since we don't have full ATproto integration yet
+        let bookmark_aturi = format!("at://{}/community.lexicon.bookmarks.bookmark/{}", did, Uuid::new_v4());
+
+        // Store locally for performance
+        let local_bookmark = event_bookmarks::insert(
+            &self.storage,
+            did,
+            &bookmark_aturi,
+            event_aturi,
+            &tags,
+        ).await?;
+
+        info!("Successfully bookmarked event {} with AT-URI {}", event_aturi, bookmark_aturi);
+        Ok(local_bookmark)
+    }
+
+    /// Remove a bookmark
+    pub async fn remove_bookmark(
+        &self,
+        did: &str,
+        bookmark_aturi: &str,
+    ) -> Result<()> {
+        info!("Removing bookmark {} for user {}", bookmark_aturi, did);
+
+        // Remove from local cache
+        event_bookmarks::delete_by_bookmark_aturi(&self.storage, did, bookmark_aturi).await?;
+
+        info!("Successfully removed bookmark {}", bookmark_aturi);
+        Ok(())
+    }
+
+    /// Get bookmarked events with filtering and pagination
+    pub async fn get_bookmarked_events(
+        &self,
+        did: &str,
+        tags: Option<&[String]>,
+        date_range: Option<(DateTime<Utc>, DateTime<Utc>)>,
+        limit: i32,
+        offset: i32,
+        _force_sync: bool,
+    ) -> Result<PaginatedBookmarkedEvents> {
+        debug!("Getting bookmarked events for user {} with limit {} offset {}", did, limit, offset);
+
+        let (bookmarks, total_count) = event_bookmarks::get_by_filters_paginated(
+            &self.storage,
+            did,
+            tags,
+            date_range,
+            limit,
+            offset,
+        ).await?;
+
+        let has_more = (offset + limit) < total_count as i32;
+
+        Ok(PaginatedBookmarkedEvents {
+            events: bookmarks,
+            total_count,
+            has_more,
+        })
+    }
+
+    /// Check if a specific event is bookmarked by the user
+    pub async fn is_event_bookmarked(
+        &self,
+        did: &str,
+        event_aturi: &str,
+    ) -> Result<Option<EventBookmark>> {
+        event_bookmarks::get_bookmark_by_event(&self.storage, did, event_aturi)
+            .await
+            .map_err(Into::into)
+    }
+
+    /// Get bookmarks summary statistics
+    pub async fn get_bookmark_stats(&self, did: &str) -> Result<BookmarkStats> {
+        let bookmarks = event_bookmarks::get_by_filters(&self.storage, did, None, None).await?;
+
+        let total_count = bookmarks.len() as i32;
+        let mut tags = std::collections::HashSet::new();
+        
+        for bookmark in &bookmarks {
+            for tag in &bookmark.tags {
+                tags.insert(tag.clone());
+            }
+        }
+
+        let unique_tags = tags.len() as i32;
+
+        Ok(BookmarkStats {
+            total_bookmarks: total_count,
+            unique_tags,
+            last_synced: bookmarks
+                .iter()
+                .map(|b| b.synced_at)
+                .max(),
+        })
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct BookmarkStats {
+    pub total_bookmarks: i32,
+    pub unique_tags: i32,
+    pub last_synced: Option<DateTime<Utc>>,
+}

src/services/mod.rs

···
 pub mod address_geocoding_strategies;
 pub mod venues;
 pub mod events;
+pub mod event_bookmarks;
 
 #[cfg(test)]
 mod nominatim_client_tests;
···
     handle_venue_nearby, handle_venue_enrich, handle_venue_suggest
 };
 pub use events::{EventVenueIntegrationService, VenueIntegrationError};
+pub use event_bookmarks::{EventBookmarkService, BookmarkStats};

src/storage/bookmark_calendars.rs

···
+use super::{StoragePool, errors::StorageError};
+use chrono::{DateTime, Utc};
+use sqlx::Row;
+use serde::Serialize;
+
+#[derive(Debug, Clone, Serialize)]
+pub struct BookmarkCalendar {
+    pub id: i32,
+    pub calendar_id: String,
+    pub did: String,
+    pub name: String,
+    pub description: Option<String>,
+    pub tags: Vec<String>,
+    pub tag_operator: String,
+    pub is_public: bool,
+    pub event_count: i32,
+    pub created_at: DateTime<Utc>,
+    pub updated_at: DateTime<Utc>,
+}
+
+#[derive(Debug, Clone, Serialize)]
+pub struct BookmarkCalendarStats {
+    pub event_count: i32,
+    pub earliest_event: Option<DateTime<Utc>>,
+    pub latest_event: Option<DateTime<Utc>>,
+}
+
+pub async fn insert(
+    pool: &StoragePool,
+    calendar: &BookmarkCalendar,
+) -> Result<BookmarkCalendar, StorageError> {
+    let result = sqlx::query(
+        r#"
+        INSERT INTO bookmark_calendars (calendar_id, did, name, description, tags, tag_operator, is_public)
+        VALUES ($1, $2, $3, $4, $5, $6, $7)
+        RETURNING id, calendar_id, did, name, description, tags, tag_operator, is_public, event_count, created_at, updated_at
+        "#
+    )
+    .bind(&calendar.calendar_id)
+    .bind(&calendar.did)
+    .bind(&calendar.name)
+    .bind(&calendar.description)
+    .bind(&calendar.tags)
+    .bind(&calendar.tag_operator)
+    .bind(calendar.is_public)
+    .fetch_one(pool)
+    .await?;
+
+    Ok(BookmarkCalendar {
+        id: result.get("id"),
+        calendar_id: result.get("calendar_id"),
+        did: result.get("did"),
+        name: result.get("name"),
+        description: result.get("description"),
+        tags: result.get::<Vec<String>, _>("tags"),
+        tag_operator: result.get("tag_operator"),
+        is_public: result.get("is_public"),
+        event_count: result.get("event_count"),
+        created_at: result.get("created_at"),
+        updated_at: result.get("updated_at"),
+    })
+}
+
+pub async fn get_by_calendar_id(
+    pool: &StoragePool,
+    calendar_id: &str,
+) -> Result<Option<BookmarkCalendar>, StorageError> {
+    let result = sqlx::query(
+        "SELECT id, calendar_id, did, name, description, tags, tag_operator, is_public, event_count, created_at, updated_at FROM bookmark_calendars WHERE calendar_id = $1"
+    )
+    .bind(calendar_id)
+    .fetch_optional(pool)
+    .await?;
+
+    if let Some(row) = result {
+        Ok(Some(BookmarkCalendar {
+            id: row.get("id"),
+            calendar_id: row.get("calendar_id"),
+            did: row.get("did"),
+            name: row.get("name"),
+            description: row.get("description"),
+            tags: row.get::<Vec<String>, _>("tags"),
+            tag_operator: row.get("tag_operator"),
+            is_public: row.get("is_public"),
+            event_count: row.get("event_count"),
+            created_at: row.get("created_at"),
+            updated_at: row.get("updated_at"),
+        }))
+    } else {
+        Ok(None)
+    }
+}
+
+// Helper function to generate a unique calendar_id
+pub fn generate_calendar_id() -> String {
+    use rand::Rng;
+    const CHARSET: &[u8] = b"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
+    let mut rng = rand::thread_rng();
+    (0..12)
+        .map(|_| {
+            let idx = rng.gen_range(0..CHARSET.len());
+            CHARSET[idx] as char
+        })
+        .collect()
+}
+
+// Simplified implementation - we'll implement full functionality later
+pub async fn get_by_user(
+    _pool: &StoragePool,
+    _did: &str,
+    _include_private: bool,
+) -> Result<Vec<BookmarkCalendar>, StorageError> {
+    // For now, return empty vector to allow compilation
+    Ok(Vec::new())
+}
+
+pub async fn get_public_paginated(
+    _pool: &StoragePool,
+    _limit: i32,
+    _offset: i32,
+) -> Result<(Vec<BookmarkCalendar>, i64), StorageError> {
+    // For now, return empty results to allow compilation
+    Ok((Vec::new(), 0))
+}
+
+pub async fn update(
+    pool: &StoragePool,
+    calendar: &BookmarkCalendar,
+) -> Result<(), StorageError> {
+    sqlx::query(
+        "UPDATE bookmark_calendars SET name = $1, description = $2, tags = $3, tag_operator = $4, is_public = $5, updated_at = NOW() WHERE calendar_id = $6 AND did = $7"
+    )
+    .bind(&calendar.name)
+    .bind(&calendar.description)
+    .bind(&calendar.tags)
+    .bind(&calendar.tag_operator)
+    .bind(calendar.is_public)
+    .bind(&calendar.calendar_id)
+    .bind(&calendar.did)
+    .execute(pool)
+    .await?;
+    Ok(())
+}
+
+pub async fn delete(
+    pool: &StoragePool,
+    calendar_id: &str,
+    did: &str,
+) -> Result<(), StorageError> {
+    sqlx::query("DELETE FROM bookmark_calendars WHERE calendar_id = $1 AND did = $2")
+        .bind(calendar_id)
+        .bind(did)
+        .execute(pool)
+        .await?;
+    Ok(())
+}
+
+pub async fn update_event_count(
+    pool: &StoragePool,
+    calendar_id: i32,
+    increment: i32,
+) -> Result<(), StorageError> {
+    sqlx::query("UPDATE bookmark_calendars SET event_count = GREATEST(0, event_count + $1), updated_at = NOW() WHERE id = $2")
+        .bind(increment)
+        .bind(calendar_id)
+        .execute(pool)
+        .await?;
+    Ok(())
+}
+
+pub async fn get_calendar_stats(
+    _pool: &StoragePool,
+    _calendar_id: i32,
+) -> Result<BookmarkCalendarStats, StorageError> {
+    // Simplified implementation for now
+    Ok(BookmarkCalendarStats {
+        event_count: 0,
+        earliest_event: None,
+        latest_event: None,
+    })
+}

src/storage/errors.rs

···
     OAuthModelError(#[from] OAuthModelError),
 }
 
+impl From<sqlx::Error> for StorageError {
+    fn from(err: sqlx::Error) -> Self {
+        StorageError::UnableToExecuteQuery(err)
+    }
+}
+
 /// Represents errors that can occur during cache operations.
 #[derive(Debug, Error)]
 pub enum CacheError {

src/storage/event_bookmarks.rs

···
+use super::{StoragePool, errors::StorageError};
+use chrono::{DateTime, Utc, Duration};
+use crate::atproto::lexicon::community::lexicon::bookmarks::BookmarkRecord;
+use sqlx::Row;
+use serde::Serialize;
+
+#[derive(Debug, Clone, Serialize)]
+pub struct EventBookmark {
+    pub id: i32,
+    pub did: String,
+    pub bookmark_aturi: String,
+    pub event_aturi: String,
+    pub tags: Vec<String>,
+    pub synced_at: DateTime<Utc>,
+    pub created_at: DateTime<Utc>,
+}
+
+#[derive(Debug, Clone, Serialize)]
+pub struct BookmarkedEvent {
+    pub bookmark: EventBookmark,
+    pub event: super::event::model::Event,
+}
+
+#[derive(Debug, Clone, Serialize)]
+pub struct PaginatedBookmarkedEvents {
+    pub events: Vec<EventBookmark>,
+    pub total_count: i64,
+    pub has_more: bool,
+}
+
+pub async fn insert(
+    pool: &StoragePool,
+    did: &str,
+    bookmark_aturi: &str,
+    event_aturi: &str,
+    tags: &[String],
+) -> Result<EventBookmark, StorageError> {
+    let result = sqlx::query(
+        r#"
+        INSERT INTO event_bookmarks (did, bookmark_aturi, event_aturi, tags)
+        VALUES ($1, $2, $3, $4)
+        RETURNING id, did, bookmark_aturi, event_aturi, tags, synced_at, created_at
+        "#
+    )
+    .bind(did)
+    .bind(bookmark_aturi)
+    .bind(event_aturi)
+    .bind(tags)
+    .fetch_one(pool)
+    .await?;
+
+    Ok(EventBookmark {
+        id: result.get("id"),
+        did: result.get("did"),
+        bookmark_aturi: result.get("bookmark_aturi"),
+        event_aturi: result.get("event_aturi"),
+        tags: result.get::<Vec<String>, _>("tags"),
+        synced_at: result.get("synced_at"),
+        created_at: result.get("created_at"),
+    })
+}
+
+pub async fn sync_from_atproto(
+    pool: &StoragePool,
+    did: &str,
+    bookmark_records: &[BookmarkRecord],
+) -> Result<(), StorageError> {
+    let mut tx = pool.begin().await?;
+
+    // Clear existing bookmarks for this user before syncing
+    sqlx::query("DELETE FROM event_bookmarks WHERE did = $1")
+        .bind(did)
+        .execute(&mut *tx)
+        .await?;
+
+    // Insert all bookmarks from ATproto
+    for record in bookmark_records {
+        sqlx::query(
+            r#"
+            INSERT INTO event_bookmarks (did, bookmark_aturi, event_aturi, tags, synced_at)
+            VALUES ($1, $2, $3, $4, NOW())
+            ON CONFLICT (did, event_aturi) DO UPDATE SET
+                bookmark_aturi = EXCLUDED.bookmark_aturi,
+                tags = EXCLUDED.tags,
+                synced_at = NOW()
+            "#
+        )
+        .bind(did)
+        .bind(&record.uri)
+        .bind(&record.value.subject)
+        .bind(&record.value.tags)
+        .execute(&mut *tx)
+        .await?;
+    }
+
+    tx.commit().await?;
+    Ok(())
+}
+
+pub async fn get_by_filters_paginated(
+    pool: &StoragePool,
+    did: &str,
+    tags: Option<&[String]>,
+    _date_range: Option<(DateTime<Utc>, DateTime<Utc>)>,
+    limit: i32,
+    offset: i32,
+) -> Result<(Vec<EventBookmark>, i64), StorageError> {
+    // For now, let's return just bookmarks without joining with events
+    // This can be enhanced later with proper event hydration
+    
+    let mut where_clauses = vec!["did = $1".to_string()];
+    let mut param_count = 1;
+
+    // Add tag filtering
+    if let Some(tag_list) = tags {
+        if !tag_list.is_empty() {
+            param_count += 1;
+            where_clauses.push(format!("tags && ${}", param_count));
+        }
+    }
+
+    let where_clause = where_clauses.join(" AND ");
+
+    // Get total count
+    let count_query = format!("SELECT COUNT(*) FROM event_bookmarks WHERE {}", where_clause);
+
+    // Get paginated results  
+    let events_query = format!(
+        "SELECT id, did, bookmark_aturi, event_aturi, tags, synced_at, created_at FROM event_bookmarks WHERE {} ORDER BY created_at DESC LIMIT ${} OFFSET ${}",
+        where_clause,
+        param_count + 1,
+        param_count + 2
+    );
+
+    // Execute count query
+    let mut count_query_builder = sqlx::query_scalar(&count_query);
+    count_query_builder = count_query_builder.bind(did);
+
+    if let Some(tag_list) = tags {
+        if !tag_list.is_empty() {
+            count_query_builder = count_query_builder.bind(tag_list);
+        }
+    }
+
+    let total_count: i64 = count_query_builder.fetch_one(pool).await?;
+
+    // Execute events query
+    let mut events_query_builder = sqlx::query(&events_query);
+    events_query_builder = events_query_builder.bind(did);
+
+    if let Some(tag_list) = tags {
+        if !tag_list.is_empty() {
+            events_query_builder = events_query_builder.bind(tag_list);
+        }
+    }
+
+    events_query_builder = events_query_builder.bind(limit);
+    events_query_builder = events_query_builder.bind(offset);
+
+    let rows = events_query_builder.fetch_all(pool).await?;
+
+    let mut bookmarks = Vec::new();
+    for row in rows {
+        let bookmark = EventBookmark {
+            id: row.get("id"),
+            did: row.get("did"),
+            bookmark_aturi: row.get("bookmark_aturi"),
+            event_aturi: row.get("event_aturi"),
+            tags: row.get::<Vec<String>, _>("tags"),
+            synced_at: row.get("synced_at"),
+            created_at: row.get("created_at"),
+        };
+
+        bookmarks.push(bookmark);
+    }
+
+    Ok((bookmarks, total_count))
+}
+
+pub async fn get_by_filters(
+    pool: &StoragePool,
+    did: &str,
+    tags: Option<&[String]>,
+    date_range: Option<(DateTime<Utc>, DateTime<Utc>)>,
+) -> Result<Vec<EventBookmark>, StorageError> {
+    let (bookmarks, _) = get_by_filters_paginated(pool, did, tags, date_range, 1000, 0).await?;
+    Ok(bookmarks)
+}
+
+pub async fn delete_by_bookmark_aturi(
+    pool: &StoragePool,
+    did: &str,
+    bookmark_aturi: &str,
+) -> Result<(), StorageError> {
+    sqlx::query("DELETE FROM event_bookmarks WHERE did = $1 AND bookmark_aturi = $2")
+        .bind(did)
+        .bind(bookmark_aturi)
+        .execute(pool)
+        .await?;
+    Ok(())
+}
+
+pub async fn is_cache_stale(
+    pool: &StoragePool,
+    did: &str,
+    max_age: Duration,
+) -> Result<bool, StorageError> {
+    let cutoff = Utc::now() - max_age;
+    
+    let result: i64 = sqlx::query_scalar(
+        "SELECT COUNT(*) FROM event_bookmarks WHERE did = $1 AND synced_at > $2"
+    )
+    .bind(did)
+    .bind(cutoff)
+    .fetch_one(pool)
+    .await?;
+
+    Ok(result == 0)
+}
+
+pub async fn get_bookmark_by_event(
+    pool: &StoragePool,
+    did: &str,
+    event_aturi: &str,
+) -> Result<Option<EventBookmark>, StorageError> {
+    let result = sqlx::query(
+        "SELECT id, did, bookmark_aturi, event_aturi, tags, synced_at, created_at FROM event_bookmarks WHERE did = $1 AND event_aturi = $2"
+    )
+    .bind(did)
+    .bind(event_aturi)
+    .fetch_optional(pool)
+    .await?;
+
+    if let Some(row) = result {
+        Ok(Some(EventBookmark {
+            id: row.get("id"),
+            did: row.get("did"),
+            bookmark_aturi: row.get("bookmark_aturi"),
+            event_aturi: row.get("event_aturi"),
+            tags: row.get::<Vec<String>, _>("tags"),
+            synced_at: row.get("synced_at"),
+            created_at: row.get("created_at"),
+        }))
+    } else {
+        Ok(None)
+    }
+}

src/storage/mod.rs

···
 //! }
 //! ```
 
+pub mod bookmark_calendars;
 pub mod cache;
 pub mod denylist;
 pub mod errors;
 pub mod event;
+pub mod event_bookmarks;
 pub mod handle;
 pub mod oauth;
 pub mod types;

static/bookmark-calendars.js

···
+// Bookmark Calendar JavaScript
+let calendarTags = [];
+
+// Initialize page
+document.addEventListener('DOMContentLoaded', function() {
+    // Initialize tag input handling
+    const tagInput = document.getElementById('new-calendar-tag-input');
+    if (tagInput) {
+        tagInput.addEventListener('keydown', handleTagInput);
+    }
+});
+
+// Handle tag input for calendar creation
+function handleTagInput(event) {
+    if (event.key === 'Enter' || event.key === ',') {
+        event.preventDefault();
+        addCalendarTag();
+    }
+}
+
+// Add a tag to the calendar
+function addCalendarTag() {
+    const input = document.getElementById('new-calendar-tag-input');
+    if (!input) return;
+    
+    const tag = input.value.trim();
+    if (tag && !calendarTags.includes(tag)) {
+        if (calendarTags.length >= 10) {
+            alert('Maximum 10 tags allowed per calendar');
+            return;
+        }
+        
+        if (tag.length > 50) {
+            alert('Tag too long (maximum 50 characters)');
+            return;
+        }
+        
+        calendarTags.push(tag);
+        input.value = '';
+        renderCalendarTags();
+        updateTagOperatorVisibility();
+    }
+}
+
+// Remove a tag from the calendar
+function removeCalendarTag(tag) {
+    calendarTags = calendarTags.filter(t => t !== tag);
+    renderCalendarTags();
+    updateTagOperatorVisibility();
+}
+
+// Render the selected tags
+function renderCalendarTags() {
+    const container = document.getElementById('selected-calendar-tags');
+    if (!container) return;
+    
+    container.innerHTML = calendarTags.map(tag => `
+        <span class="tag is-primary">
+            ${tag}
+            <button class="delete is-small" onclick="removeCalendarTag('${tag}')"></button>
+        </span>
+    `).join('');
+}
+
+// Show/hide tag operator selection based on number of tags
+function updateTagOperatorVisibility() {
+    const operatorField = document.getElementById('tag-operator-field');
+    if (!operatorField) return;
+    
+    if (calendarTags.length > 1) {
+        operatorField.style.display = 'block';
+    } else {
+        operatorField.style.display = 'none';
+    }
+}
+
+// Submit calendar form
+function submitCalendarForm() {
+    const form = document.getElementById('create-calendar-form');
+    if (!form) return;
+    
+    const formData = new FormData(form);
+    
+    // Add tags to form data
+    const tagsInput = document.createElement('input');
+    tagsInput.type = 'hidden';
+    tagsInput.name = 'tags';
+    tagsInput.value = JSON.stringify(calendarTags);
+    form.appendChild(tagsInput);
+    
+    // Submit via HTMX
+    htmx.trigger(form, 'submit');
+}
+
+// Smart calendar suggestions based on existing tags
+function suggestCalendarTags(eventTags) {
+    const suggestions = document.getElementById('tag-suggestions');
+    if (!suggestions || !eventTags) return;
+    
+    const suggestedTags = eventTags.filter(tag => !calendarTags.includes(tag));
+    
+    suggestions.innerHTML = suggestedTags.map(tag => `
+        <button class="button is-small is-light" onclick="addSuggestedTag('${tag}')">
+            ${tag}
+        </button>
+    `).join('');
+}
+
+// Add a suggested tag
+function addSuggestedTag(tag) {
+    if (!calendarTags.includes(tag) && calendarTags.length < 10) {
+        calendarTags.push(tag);
+        renderCalendarTags();
+        updateTagOperatorVisibility();
+        
+        // Update suggestions
+        const allTags = Array.from(document.querySelectorAll('.tag')).map(el => el.textContent.trim());
+        suggestCalendarTags(allTags);
+    }
+}
+
+// Filter timeline by tags
+function filterTimelineByTags() {
+    const tagsInput = document.getElementById('filter-tags');
+    if (!tagsInput) return;
+    
+    const tags = tagsInput.value;
+    const url = `/bookmarks?tags=${encodeURIComponent(tags)}`;
+    
+    htmx.ajax('GET', url, {
+        target: '#timeline-content',
+        swap: 'innerHTML'
+    });
+}
+
+// Handle bookmark form submission
+function bookmarkEvent(eventAturi) {
+    const tagsInput = document.getElementById('bookmark-tags-input');
+    const tags = tagsInput ? tagsInput.value : '';
+    
+    const url = `/bookmarks?event_aturi=${encodeURIComponent(eventAturi)}&tags=${encodeURIComponent(tags)}`;
+    
+    htmx.ajax('POST', url, {
+        target: '#bookmark-feedback',
+        swap: 'innerHTML'
+    });
+}
+
+// Calendar navigation
+function navigateCalendar(year, month) {
+    const url = `/bookmarks/calendar-nav?year=${year}&month=${month}`;
+    
+    htmx.ajax('GET', url, {
+        target: '#mini-calendar',
+        swap: 'outerHTML'
+    });
+}
+
+// Toggle view mode
+function toggleViewMode(mode) {
+    const url = `/bookmarks?view=${mode}`;
+    
+    htmx.ajax('GET', url, {
+        target: '#timeline-content',
+        swap: 'innerHTML'
+    });
+    
+    // Update button states
+    document.querySelectorAll('.view-toggle').forEach(btn => {
+        btn.classList.remove('is-primary');
+    });
+    document.querySelector(`.view-toggle[data-mode="${mode}"]`).classList.add('is-primary');
+}
+
+// Export calendar
+function exportCalendar(calendarId) {
+    const url = calendarId ? 
+        `/bookmark-calendars/${calendarId}.ics` : 
+        `/bookmarks.ics`;
+    
+    window.open(url, '_blank');
+}
+
+// Modal management
+function openCalendarModal() {
+    const modal = document.getElementById('create-calendar-modal');
+    if (modal) {
+        modal.classList.add('is-active');
+        calendarTags = []; // Reset tags
+        renderCalendarTags();
+        updateTagOperatorVisibility();
+    }
+}
+
+function closeCalendarModal() {
+    const modal = document.getElementById('create-calendar-modal');
+    if (modal) {
+        modal.classList.remove('is-active');
+    }
+}
+
+// Handle HTMX events
+document.addEventListener('htmx:afterSwap', function(event) {
+    // Re-initialize any new tag inputs after HTMX swaps
+    const tagInput = document.getElementById('new-calendar-tag-input');
+    if (tagInput) {
+        tagInput.addEventListener('keydown', handleTagInput);
+    }
+});
+
+// Keyboard shortcuts
+document.addEventListener('keydown', function(event) {
+    // Escape to close modals
+    if (event.key === 'Escape') {
+        closeCalendarModal();
+    }
+    
+    // Ctrl+B to bookmark current event (if on event page)
+    if (event.ctrlKey && event.key === 'b') {
+        const bookmarkBtn = document.getElementById('bookmark-event-btn');
+        if (bookmarkBtn) {
+            event.preventDefault();
+            bookmarkBtn.click();
+        }
+    }
+});

templates/bookmark_calendar_timeline.en-us.html

···
+{% extends "base.html" %}
+
+{% block title %}{{ t("bookmark-calendar") }}{% endblock %}
+
+{% block content %}
+<div class="bookmark-calendar-container">
+    <div class="columns">
+        <div class="column is-3">
+            <!-- Mini Calendar Widget -->
+            <div class="box">
+                <h4 class="title is-5">{{ t("calendar-navigation") }}</h4>
+                <div id="mini-calendar" hx-get="/bookmarks/calendar-nav" hx-trigger="load">
+                    <!-- Calendar will be loaded here -->
+                </div>
+            </div>
+            
+            <!-- Filter Controls -->
+            <div class="box">
+                <h4 class="title is-5">{{ t("filter-by-tags") }}</h4>
+                <div class="field">
+                    <div class="control">
+                        <input class="input" type="text" placeholder="{{ t('bookmark-tags') }}" 
+                               id="filter-tags" value="{{ filter_tags }}">
+                    </div>
+                </div>
+                <div class="field">
+                    <div class="control">
+                        <button class="button is-primary" 
+                                hx-get="/bookmarks"
+                                hx-include="#filter-tags"
+                                hx-target="#timeline-content">
+                            {{ t("filter-events") }}
+                        </button>
+                    </div>
+                </div>
+            </div>
+            
+            <!-- My Calendars -->
+            <div class="box">
+                <h4 class="title is-5">{{ t("my-calendars") }}</h4>
+                <div class="buttons">
+                    <button class="button is-success is-small" 
+                            hx-get="/bookmark-calendars/modal"
+                            hx-target="#modal-container">
+                        {{ t("create-new-calendar") }}
+                    </button>
+                </div>
+                <div id="user-calendars" hx-get="/bookmark-calendars" hx-trigger="load">
+                    <!-- User calendars will be loaded here -->
+                </div>
+            </div>
+        </div>
+        
+        <div class="column is-9">
+            <!-- View Mode Toggle -->
+            <div class="level">
+                <div class="level-left">
+                    <div class="level-item">
+                        <h2 class="title is-3">{{ t("bookmarked-events") }}</h2>
+                    </div>
+                </div>
+                <div class="level-right">
+                    <div class="level-item">
+                        <div class="buttons">
+                            <button class="button {% if view_mode == 'timeline' %}is-primary{% endif %}"
+                                    hx-get="/bookmarks?view=timeline"
+                                    hx-target="#timeline-content">
+                                {{ t("timeline-view") }}
+                            </button>
+                            <button class="button {% if view_mode == 'calendar' %}is-primary{% endif %}"
+                                    hx-get="/bookmarks?view=calendar"
+                                    hx-target="#timeline-content">
+                                {{ t("calendar-view") }}
+                            </button>
+                        </div>
+                    </div>
+                </div>
+            </div>
+            
+            <!-- Timeline Content -->
+            <div id="timeline-content">
+                {% include "bookmark_timeline.partial.html" %}
+            </div>
+        </div>
+    </div>
+</div>
+
+<!-- Modal Container -->
+<div id="modal-container"></div>
+{% endblock %}
+
+{% block scripts %}
+<script src="/static/bookmark-calendars.js"></script>
+{% endblock %}

templates/bookmark_calendar_timeline.fr-ca.html

···
+{% extends "base.html" %}
+
+{% block title %}{{ t("bookmark-calendar") }}{% endblock %}
+
+{% block content %}
+<div class="bookmark-calendar-container">
+    <div class="columns">
+        <div class="column is-3">
+            <!-- Mini Calendar Widget -->
+            <div class="box">
+                <h4 class="title is-5">{{ t("calendar-navigation") }}</h4>
+                <div id="mini-calendar" hx-get="/bookmarks/calendar-nav" hx-trigger="load">
+                    <!-- Le calendrier sera chargé ici -->
+                </div>
+            </div>
+            
+            <!-- Contrôles de filtrage -->
+            <div class="box">
+                <h4 class="title is-5">{{ t("filter-by-tags") }}</h4>
+                <div class="field">
+                    <div class="control">
+                        <input class="input" type="text" placeholder="{{ t('bookmark-tags') }}" 
+                               id="filter-tags" value="{{ filter_tags }}">
+                    </div>
+                </div>
+                <div class="field">
+                    <div class="control">
+                        <button class="button is-primary" 
+                                hx-get="/bookmarks"
+                                hx-include="#filter-tags"
+                                hx-target="#timeline-content">
+                            {{ t("filter-events") }}
+                        </button>
+                    </div>
+                </div>
+            </div>
+            
+            <!-- Mes calendriers -->
+            <div class="box">
+                <h4 class="title is-5">{{ t("my-calendars") }}</h4>
+                <div class="buttons">
+                    <button class="button is-success is-small" 
+                            hx-get="/bookmark-calendars/modal"
+                            hx-target="#modal-container">
+                        {{ t("create-new-calendar") }}
+                    </button>
+                </div>
+                <div id="user-calendars" hx-get="/bookmark-calendars" hx-trigger="load">
+                    <!-- Les calendriers utilisateur seront chargés ici -->
+                </div>
+            </div>
+        </div>
+        
+        <div class="column is-9">
+            <!-- Basculement de mode d'affichage -->
+            <div class="level">
+                <div class="level-left">
+                    <div class="level-item">
+                        <h2 class="title is-3">{{ t("bookmarked-events") }}</h2>
+                    </div>
+                </div>
+                <div class="level-right">
+                    <div class="level-item">
+                        <div class="buttons">
+                            <button class="button {% if view_mode == 'timeline' %}is-primary{% endif %}"
+                                    hx-get="/bookmarks?view=timeline"
+                                    hx-target="#timeline-content">
+                                {{ t("timeline-view") }}
+                            </button>
+                            <button class="button {% if view_mode == 'calendar' %}is-primary{% endif %}"
+                                    hx-get="/bookmarks?view=calendar"
+                                    hx-target="#timeline-content">
+                                {{ t("calendar-view") }}
+                            </button>
+                        </div>
+                    </div>
+                </div>
+            </div>
+            
+            <!-- Contenu de la chronologie -->
+            <div id="timeline-content">
+                {% include "bookmark_timeline.partial.html" %}
+            </div>
+        </div>
+    </div>
+</div>
+
+<!-- Conteneur modal -->
+<div id="modal-container"></div>
+{% endblock %}
+
+{% block scripts %}
+<script src="/static/bookmark-calendars.js"></script>
+{% endblock %}

templates/bookmark_success.en-us.partial.html

···
+<div class="notification is-success">
+    <button class="delete"></button>
+    <p>{{ t("bookmark-success") }}</p>
+</div>

templates/bookmark_success.fr-ca.partial.html

···
+<div class="notification is-success">
+    <button class="delete"></button>
+    <p>{{ t("bookmark-success") }}</p>
+</div>

templates/bookmark_timeline.en-us.partial.html

···
+<div class="timeline">
+    {% if events %}
+        {% for bookmarked_event in events %}
+        <div class="timeline-item" id="bookmark-{{ bookmarked_event.bookmark.id }}">
+            <div class="box">
+                <div class="level">
+                    <div class="level-left">
+                        <div class="level-item">
+                            <div>
+                                <h4 class="title is-5">
+                                    <a href="/{{ bookmarked_event.event.handle }}/{{ bookmarked_event.event.rkey }}">
+                                        {{ bookmarked_event.event.name }}
+                                    </a>
+                                </h4>
+                                <p class="subtitle is-6">
+                                    {{ t("bookmarked-on", date=bookmarked_event.bookmark.created_at|date) }}
+                                </p>
+                            </div>
+                        </div>
+                    </div>
+                    <div class="level-right">
+                        <div class="level-item">
+                            <button class="button is-danger is-small" 
+                                    hx-delete="/bookmarks/{{ bookmarked_event.bookmark.bookmark_aturi|urlencode }}"
+                                    hx-target="#bookmark-{{ bookmarked_event.bookmark.id }}"
+                                    hx-swap="outerHTML"
+                                    hx-confirm="{{ t('confirm-remove-bookmark') }}">
+                                {{ t("remove-bookmark") }}
+                            </button>
+                        </div>
+                    </div>
+                </div>
+                
+                <!-- Event details -->
+                {% if bookmarked_event.event.start_time %}
+                <p class="has-text-grey">
+                    <i class="fas fa-clock"></i>
+                    {{ bookmarked_event.event.start_time|date }}
+                    {% if bookmarked_event.event.end_time %}
+                        - {{ t("ends-at", time=bookmarked_event.event.end_time|time) }}
+                    {% endif %}
+                </p>
+                {% endif %}
+                
+                {% if bookmarked_event.event.location %}
+                <p class="has-text-grey">
+                    <i class="fas fa-map-marker-alt"></i>
+                    {{ bookmarked_event.event.location }}
+                </p>
+                {% endif %}
+                
+                <!-- Tags -->
+                {% if bookmarked_event.bookmark.tags %}
+                <div class="tags">
+                    {% for tag in bookmarked_event.bookmark.tags %}
+                    <span class="tag is-light">{{ tag }}</span>
+                    {% endfor %}
+                </div>
+                {% endif %}
+                
+                <!-- RSVP status if available -->
+                {% if bookmarked_event.event.user_rsvp_status %}
+                <div class="tags">
+                    <span class="tag is-primary">
+                        {{ t("rsvp-status-" + bookmarked_event.event.user_rsvp_status) }}
+                    </span>
+                </div>
+                {% endif %}
+            </div>
+        </div>
+        {% endfor %}
+        
+        <!-- Pagination -->
+        {% if has_more %}
+        <div class="has-text-centered">
+            <button class="button is-primary" 
+                    hx-get="/bookmarks?offset={{ current_offset + events|length }}&view={{ view_mode }}"
+                    hx-target="#timeline-content"
+                    hx-swap="beforeend">
+                {{ t("load-more") }}
+            </button>
+        </div>
+        {% endif %}
+    {% else %}
+        <div class="notification is-info">
+            <p>{{ t("no-bookmarked-events") }}</p>
+        </div>
+    {% endif %}
+</div>

templates/bookmark_timeline.fr-ca.partial.html

···
+<div class="timeline">
+    {% if events %}
+        {% for bookmarked_event in events %}
+        <div class="timeline-item" id="bookmark-{{ bookmarked_event.bookmark.id }}">
+            <div class="box">
+                <div class="level">
+                    <div class="level-left">
+                        <div class="level-item">
+                            <div>
+                                <h4 class="title is-5">
+                                    <a href="/{{ bookmarked_event.event.handle }}/{{ bookmarked_event.event.rkey }}">
+                                        {{ bookmarked_event.event.name }}
+                                    </a>
+                                </h4>
+                                <p class="subtitle is-6">
+                                    {{ t("bookmarked-on", date=bookmarked_event.bookmark.created_at|date) }}
+                                </p>
+                            </div>
+                        </div>
+                    </div>
+                    <div class="level-right">
+                        <div class="level-item">
+                            <button class="button is-danger is-small" 
+                                    hx-delete="/bookmarks/{{ bookmarked_event.bookmark.bookmark_aturi|urlencode }}"
+                                    hx-target="#bookmark-{{ bookmarked_event.bookmark.id }}"
+                                    hx-swap="outerHTML"
+                                    hx-confirm="{{ t('confirm-remove-bookmark') }}">
+                                {{ t("remove-bookmark") }}
+                            </button>
+                        </div>
+                    </div>
+                </div>
+                
+                <!-- Détails de l'événement -->
+                {% if bookmarked_event.event.start_time %}
+                <p class="has-text-grey">
+                    <i class="fas fa-clock"></i>
+                    {{ bookmarked_event.event.start_time|date }}
+                    {% if bookmarked_event.event.end_time %}
+                        - {{ t("ends-at", time=bookmarked_event.event.end_time|time) }}
+                    {% endif %}
+                </p>
+                {% endif %}
+                
+                {% if bookmarked_event.event.location %}
+                <p class="has-text-grey">
+                    <i class="fas fa-map-marker-alt"></i>
+                    {{ bookmarked_event.event.location }}
+                </p>
+                {% endif %}
+                
+                <!-- Étiquettes -->
+                {% if bookmarked_event.bookmark.tags %}
+                <div class="tags">
+                    {% for tag in bookmarked_event.bookmark.tags %}
+                    <span class="tag is-light">{{ tag }}</span>
+                    {% endfor %}
+                </div>
+                {% endif %}
+                
+                <!-- Statut RSVP si disponible -->
+                {% if bookmarked_event.event.user_rsvp_status %}
+                <div class="tags">
+                    <span class="tag is-primary">
+                        {{ t("rsvp-status-" + bookmarked_event.event.user_rsvp_status) }}
+                    </span>
+                </div>
+                {% endif %}
+            </div>
+        </div>
+        {% endfor %}
+        
+        <!-- Pagination -->
+        {% if has_more %}
+        <div class="has-text-centered">
+            <button class="button is-primary" 
+                    hx-get="/bookmarks?offset={{ current_offset + events|length }}&view={{ view_mode }}"
+                    hx-target="#timeline-content"
+                    hx-swap="beforeend">
+                {{ t("load-more") }}
+            </button>
+        </div>
+        {% endif %}
+    {% else %}
+        <div class="notification is-info">
+            <p>{{ t("no-bookmarked-events") }}</p>
+        </div>
+    {% endif %}
+</div>

templates/mini_calendar.html

···
+<div class="calendar-mini">
+    <div class="calendar-nav">
+        <button class="button is-small" 
+                hx-get="/bookmarks/calendar-nav?year={{ year }}&month={{ month - 1 }}"
+                hx-target="#mini-calendar">
+            <i class="fas fa-chevron-left"></i>
+        </button>
+        <span class="calendar-month-year">
+            {{ month_names[month - 1] }} {{ year }}
+        </span>
+        <button class="button is-small" 
+                hx-get="/bookmarks/calendar-nav?year={{ year }}&month={{ month + 1 }}"
+                hx-target="#mini-calendar">
+            <i class="fas fa-chevron-right"></i>
+        </button>
+    </div>
+    
+    <table class="table is-narrow is-fullwidth">
+        <thead>
+            <tr>
+                <th>Mo</th>
+                <th>Tu</th>
+                <th>We</th>
+                <th>Th</th>
+                <th>Fr</th>
+                <th>Sa</th>
+                <th>Su</th>
+            </tr>
+        </thead>
+        <tbody>
+            {% set month_start = date(year, month, 1) %}
+            {% set start_weekday = month_start.weekday() %}
+            {% set days_in_month = month_start.days_in_month() %}
+            
+            {% set current_day = 1 %}
+            {% set week_count = 0 %}
+            
+            {% for week in range(6) %}
+                {% if current_day <= days_in_month %}
+                <tr>
+                    {% for day_of_week in range(7) %}
+                        {% if week == 0 and day_of_week < start_weekday %}
+                            <td></td>
+                        {% elif current_day <= days_in_month %}
+                            {% set has_events = false %}
+                            {% for event in events %}
+                                {% set event_date = event.event.start_time|date('Y-m-d') %}
+                                {% set current_date = year ~ '-' ~ month|string|pad(2, '0') ~ '-' ~ current_day|string|pad(2, '0') %}
+                                {% if event_date == current_date %}
+                                    {% set has_events = true %}
+                                {% endif %}
+                            {% endfor %}
+                            
+                            <td class="{% if has_events %}has-background-primary-light{% endif %}">
+                                <button class="button is-small is-white {% if has_events %}has-text-primary{% endif %}"
+                                        hx-get="/bookmarks?start_date={{ year }}-{{ month|string|pad(2, '0') }}-{{ current_day|string|pad(2, '0') }}&end_date={{ year }}-{{ month|string|pad(2, '0') }}-{{ current_day|string|pad(2, '0') }}"
+                                        hx-target="#timeline-content">
+                                    {{ current_day }}
+                                </button>
+                            </td>
+                            {% set current_day = current_day + 1 %}
+                        {% else %}
+                            <td></td>
+                        {% endif %}
+                    {% endfor %}
+                </tr>
+                {% endif %}
+            {% endfor %}
+        </tbody>
+    </table>
+</div>