Handle migration to use new templating renderer with i18n

src/http/handle_admin_denylist.rs

···
     response::{IntoResponse, Redirect},
     Form,
 };
-use axum_template::RenderHtml;
 use minijinja::context as template_context;
 use serde::Deserialize;
 use std::borrow::Cow;
 
 use crate::{
-    contextual_error,
+    contextual_error, create_renderer,
     http::{
-        context::{admin_template_context, AdminRequestContext},
+        context::AdminRequestContext,
         errors::WebError,
         pagination::{Pagination, PaginationView},
     },
-    select_template,
     storage::denylist::{denylist_add_or_update, denylist_list, denylist_remove},
 };
 
···
         "https://{}/admin/denylist",
         admin_ctx.web_context.config.external_base
     );
-    let default_context = admin_template_context(&admin_ctx, &canonical_url);
 
-    let render_template = select_template!("admin_denylist", false, false, admin_ctx.language);
-    let error_template = select_template!(false, false, admin_ctx.language);
+    let renderer = create_renderer!(admin_ctx.web_context, admin_ctx.language, false, false);
 
     let (page, page_size) = pagination.admin_clamped();
 
     let denylist = denylist_list(&admin_ctx.web_context.pool, page, page_size).await;
     if let Err(err) = denylist {
         return contextual_error!(
-            admin_ctx.web_context,
-            admin_ctx.language,
-            error_template,
-            default_context,
-            err
+            renderer: renderer,
+            err,
+            template_context!{}
         );
     }
     let (total_count, mut entries) = denylist.unwrap();
···
         entries.truncate(page_size as usize);
     }
 
-    Ok(RenderHtml(
-        &render_template,
-        admin_ctx.web_context.engine.clone(),
-        template_context! { ..default_context, ..template_context! {
-            entries,
-            total_count,
-            pagination => pagination_view,
-        }},
-    )
-    .into_response())
+    Ok(renderer
+        .render_template(
+            "admin_denylist",
+            template_context! {
+                entries,
+                total_count,
+                pagination => pagination_view,
+            },
+            Some(&admin_ctx.current_handle),
+            &canonical_url,
+        )
+        .into_response())
 }
 
 pub async fn handle_admin_denylist_add(
     admin_ctx: AdminRequestContext,
     Form(form): Form<DenylistAddForm>,
 ) -> Result<impl IntoResponse, WebError> {
-    let error_template = select_template!(false, false, admin_ctx.language);
+    let renderer = create_renderer!(admin_ctx.web_context, admin_ctx.language, false, false);
 
     if let Err(err) = denylist_add_or_update(
         &admin_ctx.web_context.pool,
···
     .await
     {
         return contextual_error!(
-            admin_ctx.web_context,
-            admin_ctx.language,
-            error_template,
-            template_context! {},
-            err
+            renderer: renderer,
+            err,
+            template_context!{}
         );
     }
 
···
     admin_ctx: AdminRequestContext,
     Form(form): Form<DenylistRemoveForm>,
 ) -> Result<impl IntoResponse, WebError> {
-    let error_template = select_template!(false, false, admin_ctx.language);
+    let renderer = create_renderer!(admin_ctx.web_context, admin_ctx.language, false, false);
 
     if let Err(err) = denylist_remove(&admin_ctx.web_context.pool, &form.subject).await {
         return contextual_error!(
-            admin_ctx.web_context,
-            admin_ctx.language,
-            error_template,
-            template_context! {},
-            err
+            renderer: renderer,
+            err,
+            template_context!{}
         );
     }
 

src/http/handle_admin_event.rs

···
 use anyhow::Result;
 use axum::{extract::Query, response::IntoResponse};
-use axum_template::RenderHtml;
 use minijinja::context as template_context;
 use serde::Deserialize;
 
 use crate::{
-    contextual_error,
+    contextual_error, create_renderer,
     http::{context::AdminRequestContext, errors::WebError},
-    select_template,
     storage::event::event_get,
 };
 
···
 
     let canonical_url = format!("https://{}/admin/event", web_context.config.external_base);
 
-    // Create context with query parameters
-    let context_with_aturi = template_context! {
-        language => language.to_string(),
-        current_handle => admin_ctx.admin_handle.clone(),
-        canonical_url => canonical_url,
-        aturi => query.aturi.clone()
-    };
-
-    let render_template = select_template!("admin_event", false, false, language);
-    let error_template = select_template!(false, false, language);
+    // Create the template renderer with enhanced context
+    let renderer = create_renderer!(web_context.clone(), language, false, false);
 
     // Get the event record by AT-URI
     let event = event_get(&web_context.pool, &query.aturi).await;
     if let Err(err) = event {
-        return contextual_error!(
-            web_context,
-            language.0,
-            error_template,
-            context_with_aturi,
-            err
-        );
+        return contextual_error!(renderer: renderer, err, template_context!{ aturi => query.aturi.clone() });
     }
     let event = event.unwrap();
 
···
     let event_json = serde_json::to_string_pretty(&event)
         .unwrap_or_else(|_| "Error formatting JSON".to_string());
 
-    Ok(RenderHtml(
-        &render_template,
-        web_context.engine.clone(),
+    Ok(renderer.render_template(
+        "admin_event",
         template_context! {
-            language => language.to_string(),
-            current_handle => admin_ctx.admin_handle.clone(),
-            canonical_url => canonical_url,
             aturi => query.aturi.clone(),
             event => event,
             event_json => event_json,
         },
-    )
-    .into_response())
+        Some(&admin_ctx.admin_handle),
+        &canonical_url,
+    )?)
 }

src/http/handle_admin_events.rs

···
 use anyhow::Result;
 use axum::{extract::Query, response::IntoResponse};
-use axum_template::RenderHtml;
 use minijinja::context as template_context;
 
 use crate::{
-    contextual_error,
+    contextual_error, create_renderer,
     http::{
         context::AdminRequestContext,
         errors::WebError,
         pagination::{Pagination, PaginationView},
     },
-    select_template,
     storage::event::event_list,
 };
 
···
     let web_context = admin_ctx.web_context;
 
     let canonical_url = format!("https://{}/admin/events", web_context.config.external_base);
-    let default_context = template_context! {
-        language => language.to_string(),
-        current_handle => admin_ctx.admin_handle.clone(),
-        canonical_url => canonical_url,
-    };
 
-    let render_template = select_template!("admin_events", false, false, language);
-    let error_template = select_template!(false, false, language);
+    // Create the template renderer with enhanced context
+    let renderer = create_renderer!(web_context.clone(), language, false, false);
 
     let (page, page_size) = pagination.admin_clamped();
 
     let events = event_list(&web_context.pool, page, page_size).await;
     if let Err(err) = events {
-        return contextual_error!(
-            web_context,
-            language.0,
-            error_template,
-            default_context,
-            err
-        );
+        return contextual_error!(renderer: renderer, err, template_context!{});
     }
     let (total_count, mut events) = events.unwrap();
 
···
         events.truncate(page_size as usize);
     }
 
-    Ok(RenderHtml(
-        &render_template,
-        web_context.engine.clone(),
+    Ok(renderer.render_template(
+        "admin_events",
         template_context! {
-            language => language.to_string(),
-            current_handle => admin_ctx.admin_handle.clone(),
-            canonical_url => canonical_url,
             events => events,
             total_count => total_count,
             pagination => pagination_view,
         },
-    )
-    .into_response())
+        Some(&admin_ctx.admin_handle.handle),
+        &canonical_url,
+    ))
 }

src/http/handle_admin_handles.rs

···
     response::{IntoResponse, Redirect},
 };
 use axum_htmx::{HxRedirect, HxRequest};
-use axum_template::RenderHtml;
 use http::StatusCode;
 use minijinja::context as template_context;
 
 use crate::{
-    contextual_error,
+    contextual_error, create_renderer,
     http::{
         context::{admin_template_context, AdminRequestContext},
         errors::WebError,
         pagination::{Pagination, PaginationView},
     },
-    select_template,
     storage::handle::{handle_list, handle_nuke},
 };
 
···
         "https://{}/admin/handles",
         admin_ctx.web_context.config.external_base
     );
-    let default_context = admin_template_context(&admin_ctx, &canonical_url);
-
-    let render_template = select_template!("admin_handles", false, false, admin_ctx.language);
-    let error_template = select_template!(false, false, admin_ctx.language);
+    
+    // Create the template renderer with enhanced context
+    let renderer = create_renderer!(admin_ctx.web_context.clone(), admin_ctx.language, false, false);
 
     let (page, page_size) = pagination.admin_clamped();
 
     let handles = handle_list(&admin_ctx.web_context.pool, page, page_size).await;
     if let Err(err) = handles {
-        return contextual_error!(
-            admin_ctx.web_context,
-            admin_ctx.language,
-            error_template,
-            default_context,
-            err
-        );
+        return contextual_error!(renderer: renderer, err, template_context!{});
     }
     let (total_count, mut handles) = handles.unwrap();
 
···
         handles.truncate(page_size as usize);
     }
 
-    Ok(RenderHtml(
-        &render_template,
-        admin_ctx.web_context.engine.clone(),
-        template_context! { ..default_context, ..template_context! {
+    Ok(renderer.render_template(
+        "admin_handles",
+        template_context! {
             handles,
             total_count,
             pagination => pagination_view,
-        }},
-    )
-    .into_response())
+        },
+        Some(&admin_ctx.admin_handle),
+        &canonical_url,
+    )?)
 }
 
 pub async fn handle_admin_nuke_identity(

src/http/handle_admin_rsvp.rs

···
     response::IntoResponse,
 };
 use axum_extra::extract::Cached;
-use axum_template::RenderHtml;
 use minijinja::context as template_context;
 use serde::Deserialize;
 
 use crate::{
-    contextual_error,
+    contextual_error, create_renderer,
     http::{
         context::WebContext, errors::WebError, middleware_auth::Auth, middleware_i18n::Language,
     },
-    select_template,
     storage::event::rsvp_get,
 };
 
···
 ) -> Result<impl IntoResponse, WebError> {
     let current_handle = auth.require_admin(&web_context.config)?;
 
-    let default_context = template_context! {
-        language => language.to_string(),
-        current_handle,
-        canonical_url => format!("https://{}/admin/rsvp", web_context.config.external_base),
-    };
+    let canonical_url = format!("https://{}/admin/rsvp", web_context.config.external_base);
 
-    let render_template = select_template!("admin_rsvp", false, false, language);
-    let error_template = select_template!(false, false, language);
+    // Create the template renderer with enhanced context
+    let renderer = create_renderer!(web_context.clone(), language, false, false);
 
     // Fetch the RSVP
     let rsvp_result = rsvp_get(&web_context.pool, &query.aturi).await;
     if let Err(err) = rsvp_result {
-        return contextual_error!(web_context, language, error_template, default_context, err);
+        return contextual_error!(renderer: renderer, err, template_context!{ aturi => query.aturi.clone() });
     }
     let rsvp = rsvp_result.unwrap();
 
     // Convert the RSVP to a JSON string for display
     let rsvp_json = serde_json::to_string_pretty(&rsvp).unwrap_or_default();
 
-    Ok(RenderHtml(
-        &render_template,
-        web_context.engine.clone(),
-        template_context! { ..default_context, ..template_context! {
+    Ok(renderer.render_template(
+        "admin_rsvp",
+        template_context! {
             rsvp,
             rsvp_json,
-        }},
-    )
-    .into_response())
+        },
+        Some(&current_handle),
+        &canonical_url,
+    )?)
 }

src/http/handle_admin_rsvps.rs

···
 use anyhow::Result;
 use axum::{extract::Query, response::IntoResponse};
-use axum_template::RenderHtml;
 use minijinja::context as template_context;
 use serde::Deserialize;
 
 use crate::{
-    contextual_error,
+    contextual_error, create_renderer,
     http::{
         context::AdminRequestContext,
         errors::WebError,
         pagination::{Pagination, PaginationView},
     },
-    select_template,
     storage::event::rsvp_list,
 };
 
···
 
     let canonical_url = format!("https://{}/admin/rsvps", web_context.config.external_base);
 
-    // Create the context with all needed parameters
-    let default_context = template_context! {
-        language => language.to_string(),
-        current_handle => admin_ctx.admin_handle.clone(),
-        canonical_url => canonical_url,
-        import_success => import_success,
-        imported_aturi => imported_aturi,
-    };
-
-    let render_template = select_template!("admin_rsvps", false, false, language);
-    let error_template = select_template!(false, false, language);
+    // Create the template renderer with enhanced context
+    let renderer = create_renderer!(web_context.clone(), language, false, false);
 
     let (page, page_size) = params.pagination.admin_clamped();
 
     let rsvps = rsvp_list(&web_context.pool, page, page_size).await;
     if let Err(err) = rsvps {
-        return contextual_error!(
-            web_context,
-            language.0,
-            error_template,
-            default_context,
-            err
-        );
+        return contextual_error!(renderer: renderer, err, template_context!{});
     }
     let (total_count, mut rsvps) = rsvps.unwrap();
 
···
         rsvps.truncate(page_size as usize);
     }
 
-    Ok(RenderHtml(
-        &render_template,
-        web_context.engine.clone(),
+    Ok(renderer.render_template(
+        "admin_rsvps",
         template_context! {
-            language => language.to_string(),
-            current_handle => admin_ctx.admin_handle.clone(),
-            canonical_url => canonical_url,
             import_success => import_success,
             imported_aturi => imported_aturi,
             rsvps => rsvps,
             total_count => total_count,
             pagination => pagination_view,
         },
-    )
-    .into_response())
+        Some(&admin_ctx.admin_handle),
+        &canonical_url,
+    )?)
 }

src/http/handle_create_event.rs

···
 use axum_extra::extract::Form;
 use axum_htmx::HxBoosted;
 use axum_htmx::HxRequest;
-use axum_template::RenderHtml;
 use chrono::Utc;
 use http::Method;
 use http::StatusCode;
···
 use crate::atproto::lexicon::community::lexicon::calendar::event::Status;
 use crate::atproto::lexicon::community::lexicon::calendar::event::NSID;
 use crate::atproto::lexicon::community::lexicon::location::Address;
-use crate::contextual_error;
+use crate::create_renderer;
 use crate::http::context::WebContext;
+use crate::http::template_renderer::TemplateRenderer;
 use crate::http::errors::CommonError;
 use crate::http::errors::CreateEventError;
 use crate::http::errors::WebError;
···
 use crate::http::middleware_i18n::Language;
 use crate::http::timezones::supported_timezones;
 use crate::http::utils::url_from_aturi;
-use crate::select_template;
 use crate::storage::event::event_insert;
 
 use super::cache_countries::cached_countries;
···
 ) -> Result<impl IntoResponse, WebError> {
     let current_handle = auth.require(&web_context.config.destination_key, "/event")?;
 
+    // Create the template renderer with enhanced context
+    let renderer = create_renderer!(web_context.clone(), Language(language), hx_boosted, hx_request);
+    
+    let canonical_url = format!("https://{}/event", web_context.config.external_base);
     let is_development = cfg!(debug_assertions);
 
     let default_context = template_context! {
-        current_handle,
-        language => language.to_string(),
-        canonical_url => format!("https://{}/event", web_context.config.external_base),
         is_development,
         create_event => true,
         submit_url => format!("/event"),
     };
-    // <a href="/{{ handle_slug }}/{{ event_rkey }}" class="button">Cancel</a>
-
-    let render_template = select_template!("create_event", hx_boosted, hx_request, language);
-
-    let error_template = select_template!(hx_boosted, hx_request, language);
 
     let (default_tz, timezones) = supported_timezones(auth.0.as_ref());
 
···
             build_event_form.starts_at = starts_form.starts_at.clone();
         }
 
-        return Ok(RenderHtml(
-            &render_template,
-            web_context.engine.clone(),
-            template_context! { ..default_context, ..template_context! {
+        return Ok(renderer.render_template(
+            "create_event",
+            template_context! { 
+                ..default_context, 
                 build_event_form,
                 starts_form,
                 location_form,
                 link_form,
                 timezones,
-            }},
-        )
-        .into_response());
+            },
+            Some(&current_handle.handle),
+            &canonical_url,
+        ));
     }
 
     match build_event_form.build_state {
···
                 let create_record_result = client.create_record(&client_auth, event_record).await;
 
                 if let Err(err) = create_record_result {
-                    return contextual_error!(
-                        web_context,
-                        language,
-                        error_template,
-                        default_context,
-                        err
-                    );
+                    return Ok(renderer.render_error(err, default_context));
                 }
 
                 // create_record_result is guaranteed to be Ok since we checked for Err above
···
                 .await;
 
                 if let Err(err) = event_insert_result {
-                    return contextual_error!(
-                        web_context,
-                        language,
-                        error_template,
-                        default_context,
-                        err
-                    );
+                    return Ok(renderer.render_error(err, default_context));
                 }
 
                 let event_url =
                     url_from_aturi(&web_context.config.external_base, &create_record_result.uri)?;
 
-                return Ok(RenderHtml(
-                    &render_template,
-                    web_context.engine.clone(),
-                    template_context! { ..default_context, ..template_context! {
+                return Ok(renderer.render_template(
+                    "create_event",
+                    template_context! { 
+                        ..default_context, 
                         build_event_form,
                         starts_form,
                         location_form,
                         link_form,
                         operation_completed => true,
                         event_url,
-                    }},
-                )
-                .into_response());
+                    },
+                    Some(&current_handle.handle),
+                    &canonical_url,
+                ));
             }
         }
         _ => {}
     }
 
-    Ok(RenderHtml(
-        &render_template,
-        web_context.engine.clone(),
-        template_context! { ..default_context, ..template_context! {
+    Ok(renderer.render_template(
+        "create_event",
+        template_context! { 
+            ..default_context, 
             build_event_form,
             starts_form,
             timezones,
             location_form,
             link_form,
-        }},
-    )
-    .into_response())
+        },
+        Some(&current_handle.handle),
+        &canonical_url,
+    ))
 }
 
 pub async fn handle_starts_at_builder(
···
 
     let is_development = cfg!(debug_assertions);
 
-    let render_template = format!(
-        "create_event.{}.starts_form.html",
-        language.to_string().to_lowercase()
-    );
+    // Create the template renderer for HTMX partial updates
+    let renderer = create_renderer!(web_context.clone(), Language(language.clone()), false, true);
+    
+    let canonical_url = format!("https://{}/event", web_context.config.external_base);
 
     if starts_form.build_state.is_none() {
         starts_form.build_state = Some(BuildEventContentState::default());
···
     }
 
     if method == Method::GET {
-        return Ok(RenderHtml(
-            &render_template,
-            web_context.engine.clone(),
+        return Ok(renderer.render_template(
+            "create_event.starts_form",
             template_context! {
                 starts_form,
                 is_development,
                 timezones,
             },
-        )
-        .into_response());
+            None,
+            &canonical_url,
+        ));
     }
 
     if starts_form
···
         }
     }
 
-    Ok(RenderHtml(
-        &render_template,
-        web_context.engine.clone(),
+    Ok(renderer.render_template(
+        "create_event.starts_form",
         template_context! {
             starts_form,
             is_development,
             timezones,
         },
-    )
-    .into_response())
+        None,
+        &canonical_url,
+    ))
 }
 
 pub async fn handle_location_at_builder(
···
 
     let is_development = cfg!(debug_assertions);
 
-    let render_template = format!(
-        "create_event.{}.location_form.html",
-        language.to_string().to_lowercase()
-    );
+    // Create the template renderer for HTMX partial updates
+    let renderer = create_renderer!(web_context.clone(), Language(language.clone()), false, true);
+    
+    let canonical_url = format!("https://{}/event", web_context.config.external_base);
 
     if location_form.build_state.is_none() {
         location_form.build_state = Some(BuildEventContentState::default());
     }
 
     if method == Method::GET {
-        return Ok(RenderHtml(
-            &render_template,
-            web_context.engine.clone(),
+        return Ok(renderer.render_template(
+            "create_event.location_form",
             template_context! {
                 location_form,
                 is_development
             },
-        )
-        .into_response());
+            None,
+            &canonical_url,
+        ));
     }
 
     if location_form
···
         }
     }
 
-    Ok(RenderHtml(
-        &render_template,
-        web_context.engine.clone(),
+    Ok(renderer.render_template(
+        "create_event.location_form",
         template_context! {
             location_form,
             is_development,
         },
-    )
-    .into_response())
+        None,
+        &canonical_url,
+    ))
 }
 
 pub async fn handle_link_at_builder(
···
 
     let is_development = cfg!(debug_assertions);
 
-    let render_template = format!(
-        "create_event.{}.link_form.html",
-        language.to_string().to_lowercase()
-    );
+    // Create the template renderer for HTMX partial updates
+    let renderer = create_renderer!(web_context.clone(), Language(language.clone()), false, true);
+    
+    let canonical_url = format!("https://{}/event", web_context.config.external_base);
 
     if link_form.build_state.is_none() {
         link_form.build_state = Some(BuildEventContentState::default());
     }
 
     if method == Method::GET {
-        return Ok(RenderHtml(
-            &render_template,
-            web_context.engine.clone(),
+        return Ok(renderer.render_template(
+            "create_event.link_form",
             template_context! {
                 link_form,
                 is_development
             },
-        )
-        .into_response());
+            None,
+            &canonical_url,
+        ));
     }
 
     if link_form
···
         }
     }
 
-    Ok(RenderHtml(
-        &render_template,
-        web_context.engine.clone(),
+    Ok(renderer.render_template(
+        "create_event.link_form",
         template_context! {
             link_form,
             is_development,
         },
-    )
-    .into_response())
+        None,
+        &canonical_url,
+    ))
 }
 
 #[derive(Deserialize, Debug, Clone)]
···
 
 pub async fn handle_location_datalist(
     State(web_context): State<WebContext>,
+    Language(language): Language,
     HxRequest(hx_request): HxRequest,
     Query(location_country_hint): Query<LocationDataListHint>,
 ) -> Result<impl IntoResponse, WebError> {
···
         return Ok(StatusCode::BAD_REQUEST.into_response());
     }
 
+    // Create the template renderer for HTMX partial updates
+    let renderer = create_renderer!(web_context.clone(), Language(language), false, true);
+    
+    let canonical_url = format!("https://{}/event", web_context.config.external_base);
+
     let all_countries = cached_countries()?;
 
     let locations = if let Some(value) = location_country_hint.location_country {
···
             .collect::<Vec<(String, String)>>()
     };
 
-    Ok(RenderHtml(
-        "create_event.countries_datalist.html",
-        web_context.engine.clone(),
+    Ok(renderer.render_template(
+        "create_event.countries_datalist",
         template_context! {
             locations,
         },
-    )
-    .into_response())
+        None,
+        &canonical_url,
+    ))
 }
 
 // Nick: The next two methods were adapted from https://www.thecodedmessage.com/posts/prefix-ranges/ which has no license. Thank you.

src/http/handle_create_rsvp.rs

···
 use axum::{extract::State, response::IntoResponse};
 use axum_extra::extract::{Cached, Form};
 use axum_htmx::{HxBoosted, HxRequest};
-use axum_template::RenderHtml;
 use chrono::Utc;
 use http::Method;
 use metrohash::MetroHash64;
···
             community::lexicon::calendar::rsvp::{Rsvp, RsvpStatus, NSID},
         },
     },
-    contextual_error,
+    contextual_error, create_renderer,
     http::{
         context::WebContext,
         errors::WebError,
···
         rsvp_form::{BuildRSVPForm, BuildRsvpContentState},
         utils::url_from_aturi,
     },
-    select_template,
     storage::event::rsvp_insert,
 };
 
···
 ) -> Result<impl IntoResponse, WebError> {
     let current_handle = auth.require(&web_context.config.destination_key, "/rsvp")?;
 
-    let default_context = template_context! {
-        current_handle,
-        language => language.to_string(),
-        canonical_url => format!("https://{}/rsvp", web_context.config.external_base),
-        hx_request,
-        hx_boosted,
-    };
-
-    let render_template = select_template!("create_rsvp", hx_boosted, hx_request, language);
-    let error_template = select_template!(hx_boosted, hx_request, language);
+    // Create the template renderer with enhanced context
+    let renderer = create_renderer!(web_context.clone(), Language(language), hx_boosted, hx_request);
+    
+    let canonical_url = format!("https://{}/rsvp", web_context.config.external_base);
 
     if build_rsvp_form.build_state.is_none() {
         build_rsvp_form.build_state = Some(BuildRsvpContentState::default());
···
 
         build_rsvp_form.build_state = Some(BuildRsvpContentState::Selecting);
 
-        return Ok(RenderHtml(
-            &render_template,
-            web_context.engine.clone(),
-            template_context! { ..default_context, ..template_context! {
+        return Ok(renderer.render_template(
+            "create_rsvp",
+            template_context! {
                 build_rsvp_form,
-            }},
-        )
-        .into_response());
+            },
+            Some(&current_handle.handle),
+            &canonical_url,
+        ));
     }
 
     match build_rsvp_form.build_state {
···
                 let put_record_result = client.put_record(&client_auth, rsvp_record).await;
 
                 if let Err(err) = put_record_result {
-                    return contextual_error!(
-                        web_context,
-                        language,
-                        error_template,
-                        default_context,
-                        err
-                    );
+                    return contextual_error!(renderer: renderer, err, template_context!{});
                 }
 
                 let create_record_result = put_record_result.unwrap();
···
                 .await;
 
                 if let Err(err) = rsvp_insert_result {
-                    return contextual_error!(
-                        web_context,
-                        language,
-                        error_template,
-                        default_context,
-                        err
-                    );
+                    return contextual_error!(renderer: renderer, err, template_context!{});
                 }
 
                 let event_url = url_from_aturi(
···
                     build_rsvp_form.subject_aturi.clone().unwrap().as_str(),
                 )?;
 
-                return Ok(RenderHtml(
-                    &render_template,
-                    web_context.engine.clone(),
-                    template_context! { ..default_context, ..template_context! {
+                return Ok(renderer.render_template(
+                    "create_rsvp",
+                    template_context! {
                         build_rsvp_form,
                         event_url,
-                    }},
-                )
-                .into_response());
+                    },
+                    Some(&current_handle.handle),
+                    &canonical_url,
+                ));
             }
         }
         None => unreachable!(),
     }
 
-    Ok(RenderHtml(
-        &render_template,
-        web_context.engine.clone(),
-        template_context! { ..default_context, ..template_context! {
+    Ok(renderer.render_template(
+        "create_rsvp",
+        template_context! {
             build_rsvp_form
-        }},
-    )
-    .into_response())
+        },
+        Some(&current_handle.handle),
+        &canonical_url,
+    ))
 }

src/http/handle_edit_event.rs

···
 use axum::{extract::Path, response::IntoResponse};
 use axum_extra::extract::Form;
 use axum_htmx::{HxBoosted, HxRequest};
-use axum_template::RenderHtml;
 use chrono::Utc;
 use http::{Method, StatusCode};
 use minijinja::context as template_context;
···
     http::timezones::supported_timezones,
     http::utils::url_from_aturi,
     resolve::{parse_input, InputType},
-    select_template,
+    create_renderer,
     storage::{
         event::{event_get, event_update_with_metadata},
         handle::{handle_for_did, handle_for_handle},
···
         .auth
         .require(&ctx.web_context.config.destination_key, "/")?;
 
-    let default_context = template_context! {
-        current_handle,
-        language => ctx.language.to_string(),
-        canonical_url => format!("https://{}/{}/{}/edit", ctx.web_context.config.external_base, handle_slug, event_rkey),
-        create_event => false,
-        submit_url => format!("/{}/{}/edit", handle_slug, event_rkey),
-        cancel_url => format!("/{}/{}", handle_slug, event_rkey),
-    };
+    let canonical_url = format!(
+        "https://{}/{}/{}/edit",
+        ctx.web_context.config.external_base, handle_slug, event_rkey
+    );
 
-    let render_template = select_template!("edit_event", hx_boosted, hx_request, ctx.language);
-    let error_template = select_template!(hx_boosted, hx_request, ctx.language);
+    // Create the template renderer with enhanced context
+    let renderer = create_renderer!(ctx.web_context.clone(), ctx.language, hx_boosted, hx_request);
 
     // Lookup the event
     let profile = match parse_input(&handle_slug) {
···
     // Check if the user is authorized to edit this event (must be the creator)
     if profile.did != current_handle.did {
         return contextual_error!(
-            ctx.web_context,
-            ctx.language,
-            error_template,
-            default_context,
+            renderer: renderer,
             EditEventError::NotAuthorized,
+            template_context!{},
             StatusCode::FORBIDDEN
         );
     }
 
     let event = event_get(&ctx.web_context.pool, &lookup_aturi).await;
     if let Err(err) = event {
-        return contextual_error!(
-            ctx.web_context,
-            ctx.language,
-            error_template,
-            default_context,
-            err,
-            StatusCode::OK
-        );
+        return contextual_error!(renderer: renderer, err, template_context!{}, StatusCode::OK);
     }
 
     let event = event.unwrap();
···
     // Check if this is a community calendar event (we only support editing those)
     if event.lexicon != LexiconCommunityEventNSID {
         return contextual_error!(
-            ctx.web_context,
-            ctx.language,
-            error_template,
-            default_context,
+            renderer: renderer,
             EditEventError::UnsupportedEventType,
+            template_context!{},
             StatusCode::BAD_REQUEST
         );
     }
···
             Ok(event) => event,
             Err(_) => {
                 return contextual_error!(
-                    ctx.web_context,
-                    ctx.language,
-                    error_template,
-                    default_context,
+                    renderer: renderer,
                     CommonError::InvalidEventFormat,
+                    template_context!{},
                     StatusCode::BAD_REQUEST
                 );
             }
···
 
         return Ok((
             StatusCode::OK,
-            RenderHtml(
-                &render_template,
-                ctx.web_context.engine.clone(),
-                template_context! { ..default_context, ..template_context! {
+            renderer.render_template(
+                "edit_event",
+                template_context! {
                     build_event_form,
                     starts_form,
                     location_form,
···
                     locations_editable,
                     location_edit_reason,
                     location_display_info,
-                }},
-            ),
-        )
-            .into_response());
+                    create_event => false,
+                    submit_url => format!("/{}/{}/edit", handle_slug, event_rkey),
+                    cancel_url => format!("/{}/{}", handle_slug, event_rkey),
+                },
+                Some(&current_handle),
+                &canonical_url,
+            )?,
+        ));
     }
 
     // Process form state changes just like in create_event
···
                             };
 
                             return contextual_error!(
-                                ctx.web_context,
-                                ctx.language,
-                                error_template,
-                                default_context,
+                                renderer: renderer,
                                 error,
+                                template_context!{},
                                 StatusCode::BAD_REQUEST
                             );
                         }
···
 
                 if let Err(err) = update_record_result {
                     return contextual_error!(
-                        ctx.web_context,
-                        ctx.language,
-                        error_template,
-                        default_context,
+                        renderer: renderer,
                         err,
+                        template_context!{},
                         StatusCode::OK
                     );
                 }
···
 
                 if let Err(err) = event_update_result {
                     return contextual_error!(
-                        ctx.web_context,
-                        ctx.language,
-                        error_template,
-                        default_context,
+                        renderer: renderer,
                         err,
+                        template_context!{},
                         StatusCode::OK
                     );
                 }
···
 
                 return Ok((
                     StatusCode::OK,
-                    RenderHtml(
-                        &render_template,
-                        ctx.web_context.engine.clone(),
-                        template_context! { ..default_context, ..template_context! {
+                    renderer.render_template(
+                        "edit_event",
+                        template_context! {
                             build_event_form,
                             starts_form,
                             location_form,
···
                             is_development,
                             locations_editable,
                             location_edit_reason,
-                        }},
-                    ),
-                )
-                    .into_response());
+                            create_event => false,
+                            submit_url => format!("/{}/{}/edit", handle_slug, event_rkey),
+                            cancel_url => format!("/{}/{}", handle_slug, event_rkey),
+                        },
+                        Some(&current_handle),
+                        &canonical_url,
+                    )?,
+                ));
             }
         }
         _ => {}
···
 
     Ok((
         StatusCode::OK,
-        RenderHtml(
-            &render_template,
-            ctx.web_context.engine.clone(),
-            template_context! { ..default_context, ..template_context! {
+        renderer.render_template(
+            "edit_event",
+            template_context! {
                 build_event_form,
                 starts_form,
                 location_form,
···
                 is_development,
                 locations_editable,
                 location_edit_reason,
-            }},
-        ),
-    )
-        .into_response())
+                create_event => false,
+                submit_url => format!("/{}/{}/edit", handle_slug, event_rkey),
+                cancel_url => format!("/{}/{}", handle_slug, event_rkey),
+            },
+            Some(&current_handle),
+            &canonical_url,
+        )?,
+    ))
 }

src/http/handle_import.rs

···
 };
 use axum_extra::extract::Cached;
 use axum_htmx::{HxBoosted, HxRequest};
-use axum_template::RenderHtml;
 use http::StatusCode;
 use minijinja::context as template_context;
 use serde::Deserialize;
···
             },
         },
     },
-    contextual_error,
+    contextual_error, create_renderer,
     http::{
         context::WebContext,
         errors::{ImportError, WebError},
         middleware_auth::Auth,
         middleware_i18n::Language,
     },
-    select_template,
     storage::event::{event_insert_with_metadata, rsvp_insert_with_metadata},
 };
 
···
 ) -> Result<impl IntoResponse, WebError> {
     let current_handle = auth.require(&web_context.config.destination_key, "/import")?;
 
-    let default_context = template_context! {
-        current_handle,
-        language => language.to_string(),
-        canonical_url => format!("https://{}/import", web_context.config.external_base),
-    };
-
-    let render_template = select_template!("import", hx_boosted, hx_request, language);
+    // Create the template renderer with enhanced context
+    let renderer = create_renderer!(web_context.clone(), Language(language), hx_boosted, hx_request);
+    
+    let canonical_url = format!("https://{}/import", web_context.config.external_base);
 
-    Ok(RenderHtml(
-        &render_template,
-        web_context.engine.clone(),
-        default_context,
-    )
-    .into_response())
+    Ok(renderer.render_template(
+        "import",
+        template_context! {},
+        Some(&current_handle.handle),
+        &canonical_url,
+    ))
 }
 
 #[derive(Debug, Deserialize)]
···
         return Ok(StatusCode::BAD_REQUEST.into_response());
     }
 
-    let render_template = select_template!("import", false, true, language);
-    let error_template = select_template!(false, hx_request, language);
+    // Create the template renderer for HTMX partial updates
+    let renderer = create_renderer!(web_context.clone(), Language(language), false, true);
+    
+    let canonical_url = format!("https://{}/import", web_context.config.external_base);
 
     let collections = [
         LEXICON_COMMUNITY_EVENT_NSID,
···
                 }
                 Err(err) => {
                     return contextual_error!(
-                        web_context,
-                        language,
-                        error_template,
-                        template_context! {},
-                        ImportError::FailedToListCommunityEvents(err.to_string())
+                        renderer: renderer,
+                        ImportError::FailedToListCommunityEvents(err.to_string()),
+                        template_context!{}
                     )
                 }
             }
···
                 }
                 Err(err) => {
                     return contextual_error!(
-                        web_context,
-                        language,
-                        error_template,
-                        template_context! {},
-                        ImportError::FailedToListCommunityRSVPs(err.to_string())
+                        renderer: renderer,
+                        ImportError::FailedToListCommunityRSVPs(err.to_string()),
+                        template_context!{}
                     )
                 }
             }
···
                 }
                 Err(err) => {
                     return contextual_error!(
-                        web_context,
-                        language,
-                        error_template,
-                        template_context! {},
-                        ImportError::FailedToListSmokesignalEvents(err.to_string())
+                        renderer: renderer,
+                        ImportError::FailedToListSmokesignalEvents(err.to_string()),
+                        template_context!{}
                     )
                 }
             }
···
                 }
                 Err(err) => {
                     return contextual_error!(
-                        web_context,
-                        language,
-                        error_template,
-                        template_context! {},
-                        ImportError::FailedToListSmokesignalRSVPs(err.to_string())
+                        renderer: renderer,
+                        ImportError::FailedToListSmokesignalRSVPs(err.to_string()),
+                        template_context!{}
                     )
                 }
             }
         }
         _ => {
             return contextual_error!(
-                web_context,
-                language,
-                error_template,
-                template_context! {},
-                ImportError::UnsupportedCollectionType(collection.clone())
+                renderer: renderer,
+                ImportError::UnsupportedCollectionType(collection.clone()),
+                template_context!{}
             )
         }
     };
 
-    Ok(RenderHtml(
-        &render_template,
-        web_context.engine.clone(),
-        template_context! {
-            current_handle,
-            language => language.to_string(),
-            canonical_url => format!("https://{}/import", web_context.config.external_base),
-            ..render_context,
-        },
-    )
-    .into_response())
+    Ok(renderer
+        .render_template(
+            "import",
+            template_context! {
+                ..render_context,
+            },
+            Some(&current_handle.handle),
+            &canonical_url,
+        )
+        .into_response())
 }

src/http/handle_index.rs

···
 };
 use axum_extra::extract::Cached;
 use axum_htmx::HxBoosted;
-use axum_template::RenderHtml;
 
 use minijinja::context as template_context;
 use serde::{Deserialize, Serialize};
 
 use crate::{
-    contextual_error,
+    contextual_error, create_renderer,
     http::{
         context::WebContext,
         errors::WebError,
···
         pagination::{Pagination, PaginationView},
         tab_selector::TabSelector,
     },
-    select_template,
     storage::event::event_list_recently_updated,
 };
 
···
     pagination: Query<Pagination>,
     tab_selector: Query<TabSelector>,
 ) -> Result<impl IntoResponse, WebError> {
-    let render_template = select_template!("index", hx_boosted, false, language);
-    let error_template = select_template!(false, false, language);
+    // Create the template renderer with enhanced context
+    let renderer = create_renderer!(web_context.clone(), Language(language), hx_boosted, false);
+    
+    let canonical_url = format!("https://{}/", web_context.config.external_base);
 
     let (page, page_size) = pagination.clamped();
     let tab: HomeTab = tab_selector.0.into();
···
         match tab_events {
             Ok(values) => values,
             Err(err) => {
-                return contextual_error!(
-                    web_context,
-                    language,
-                    error_template,
-                    template_context! {},
-                    err
-                );
+                return contextual_error!(renderer: renderer, err, template_context!{});
             }
         }
     };
···
 
     Ok((
         http::StatusCode::OK,
-        RenderHtml(
-            &render_template,
-            web_context.engine.clone(),
+        renderer.render_template(
+            "index",
             template_context! {
-                current_handle => auth.0,
-                language => language.to_string(),
-                canonical_url => format!("https://{}/", web_context.config.external_base),
                 tab => tab.to_string(),
                 events,
                 pagination => pagination_view,
             },
+            auth.0.as_ref().map(|h| h.handle.as_str()),
+            &canonical_url,
         ),
     )
         .into_response())

src/http/handle_migrate_event.rs

···
 };
 use axum_extra::extract::Cached;
 use axum_htmx::{HxBoosted, HxRequest};
-use axum_template::RenderHtml;
 use http::StatusCode;
 use minijinja::context as template_context;
 use std::collections::HashMap;
···
             },
         },
     },
-    contextual_error,
+    create_renderer,
     http::{
-        context::WebContext, errors::MigrateEventError, errors::WebError, middleware_auth::Auth,
-        middleware_i18n::Language, utils::url_from_aturi,
+        context::WebContext, 
+        errors::{MigrateEventError, WebError}, 
+        middleware_auth::Auth,
+        middleware_i18n::Language, 
+        template_renderer::TemplateRenderer,
+        utils::url_from_aturi,
     },
     resolve::{parse_input, InputType},
-    select_template,
     storage::{
         event::{event_get, event_insert_with_metadata},
         handle::{handle_for_did, handle_for_handle, model::Handle},
···
 ) -> Result<impl IntoResponse, WebError> {
     let current_handle = auth.require(&web_context.config.destination_key, "/")?;
 
-    // Configure templates
-    let default_context = template_context! {
-        current_handle,
-        language => language.to_string(),
-        canonical_url => format!("https://{}/{}/{}/migrate", web_context.config.external_base, handle_slug, event_rkey),
-    };
-    let render_template = select_template!("migrate_event", hx_boosted, hx_request, language);
-    let error_template = select_template!(hx_boosted, hx_request, language);
+    // Create the template renderer with enhanced context
+    let renderer = create_renderer!(web_context.clone(), Language(language), hx_boosted, hx_request);
+    let canonical_url = format!("https://{}/{}/{}/migrate", renderer.web_context.config.external_base, handle_slug, event_rkey);
 
     // Lookup the user handle/profile
     let profile: Result<Handle> = match parse_input(&handle_slug) {
···
     };
 
     if let Err(err) = profile {
-        return contextual_error!(
-            web_context,
-            language,
-            error_template,
-            default_context,
+        return Ok(renderer.render_error(
             err,
-            StatusCode::NOT_FOUND
-        );
+            template_context! {
+                current_handle => current_handle.handle.as_str(),
+                canonical_url => canonical_url,
+            },
+        ));
     }
     let profile = profile.unwrap();
 
···
 
     // Check if the user is authorized to migrate this event (must be the event creator/organizer)
     if profile.did != current_handle.did {
-        return contextual_error!(
-            web_context,
-            language,
-            error_template,
-            default_context,
+        return Ok(renderer.render_error(
             MigrateEventError::NotAuthorized,
-            StatusCode::FORBIDDEN
-        );
+            template_context! {
+                current_handle => current_handle.handle.as_str(),
+                canonical_url => canonical_url,
+            },
+        ));
     }
 
     // Fetch the event from the database
     let event = event_get(&web_context.pool, &source_aturi).await;
     if let Err(err) = event {
-        return contextual_error!(
-            web_context,
-            language,
-            error_template,
-            default_context,
+        return Ok(renderer.render_error(
             err,
-            StatusCode::OK
-        );
+            template_context! {
+                current_handle => current_handle.handle.as_str(),
+                canonical_url => canonical_url,
+            },
+        ));
     }
     let event = event.unwrap();
 
···
     if event.lexicon != SMOKESIGNAL_NSID {
         // If it's already the community event type, we don't need to migrate
         if event.lexicon == COMMUNITY_NSID {
-            return contextual_error!(
-                web_context,
-                language,
-                error_template,
-                default_context,
+            return Ok(renderer.render_error(
                 MigrateEventError::AlreadyMigrated,
-                StatusCode::BAD_REQUEST
-            );
+                template_context! {
+                    current_handle => current_handle.handle.as_str(),
+                    canonical_url => canonical_url,
+                },
+            ));
         }
 
-        return contextual_error!(
-            web_context,
-            language,
-            error_template,
-            default_context,
+        return Ok(renderer.render_error(
             MigrateEventError::UnsupportedEventType,
-            StatusCode::BAD_REQUEST
-        );
+            template_context! {
+                current_handle => current_handle.handle.as_str(),
+                canonical_url => canonical_url,
+            },
+        ));
     }
 
     // Parse the legacy event
     let legacy_event = match serde_json::from_value::<SmokeSignalEvent>(event.record.0.clone()) {
         Ok(event) => event,
         Err(err) => {
-            return contextual_error!(
-                web_context,
-                language,
-                error_template,
-                default_context,
+            return Ok(renderer.render_error(
                 err,
-                StatusCode::BAD_REQUEST
-            );
+                template_context! {
+                    current_handle => current_handle.handle.as_str(),
+                    canonical_url => canonical_url,
+                },
+            ));
         }
     };
 
···
     // Check if a record already exists at the target AT-URI
     let existing_event = event_get(&web_context.pool, &migrated_aturi).await;
     if existing_event.is_ok() {
-        return contextual_error!(
-            web_context,
-            language,
-            error_template,
-            default_context,
+        return Ok(renderer.render_error(
             MigrateEventError::DestinationExists,
-            StatusCode::CONFLICT
-        );
+            template_context! {
+                current_handle => current_handle.handle.as_str(),
+                canonical_url => canonical_url,
+            },
+        ));
     }
 
     // Set up XRPC client
···
     // Write to the PDS
     let update_record_result = client.put_record(&client_auth, update_record_request).await;
     if let Err(err) = update_record_result {
-        return contextual_error!(
-            web_context,
-            language,
-            error_template,
-            default_context,
+        return Ok(renderer.render_error(
             err,
-            StatusCode::OK
-        );
+            template_context! {
+                current_handle => current_handle.handle.as_str(),
+                canonical_url => canonical_url,
+            },
+        ));
     }
     // update_record_result is guaranteed to be Ok at this point since we checked for Err above
-    let update_record_result = update_record_result?;
+    let update_record_result = update_record_result.unwrap();
 
     // We already have the migrated AT-URI defined above
 
···
     .await;
 
     if let Err(err) = migrated_event_insert_result {
-        return contextual_error!(
-            web_context,
-            language,
-            error_template,
-            default_context,
+        return Ok(renderer.render_error(
             err,
-            StatusCode::OK
-        );
+            template_context! {
+                current_handle => current_handle.handle.as_str(),
+                canonical_url => canonical_url,
+            },
+        ));
     }
 
     // Generate URL for the migrated event
     let migrated_event_url = url_from_aturi(&web_context.config.external_base, &migrated_aturi)?;
 
     // Return success with migration complete template
-    Ok(RenderHtml(
-        &render_template,
-        web_context.engine.clone(),
+    Ok(renderer.render_template(
+        "migrate_event",
         template_context! {
             migrated_event_url => migrated_event_url,
             source_aturi => source_aturi,
···
             event_name => name,
             source_lexicon => SMOKESIGNAL_NSID,
             target_lexicon => COMMUNITY_NSID,
-            ..default_context
         },
-    )
-    .into_response())
+        Some(current_handle.handle.as_str()),
+        &canonical_url,
+    ))
 }

src/http/handle_oauth_login.rs

···
 use axum::{extract::State, response::IntoResponse};
 use axum_extra::extract::{Cached, Form, Query};
 use axum_htmx::{HxBoosted, HxRedirect, HxRequest};
-use axum_template::RenderHtml;
 use base64::{engine::general_purpose, Engine as _};
 use http::StatusCode;
 use minijinja::context as template_context;
···
 use std::borrow::Cow;
 
 use crate::{
-    contextual_error,
+    contextual_error, create_renderer,
     did::{plc::query as plc_query, web::query as web_query},
     http::{
         context::WebContext, errors::LoginError, errors::WebError, middleware_auth::Auth,
···
     jose,
     oauth::{oauth_init, pds_resources},
     resolve::{parse_input, resolve_subject, InputType},
-    select_template,
     storage::{
         denylist::denylist_exists,
         handle::handle_warm_up,
···
     Query(destination): Query<Destination>,
     Form(login_form): Form<OAuthLoginForm>,
 ) -> Result<impl IntoResponse, WebError> {
+    // Create the template renderer with enhanced context
+    let renderer = create_renderer!(web_context.clone(), Language(language), hx_boosted, hx_request);
+    
+    let canonical_url = format!("https://{}/oauth/login", web_context.config.external_base);
+    let current_handle = auth.0.as_ref().map(|h| h.handle.as_str()).unwrap_or("");
+    
     let default_context = template_context! {
-        current_handle => auth.0,
-        language => language.to_string(),
-        canonical_url => format!("https://{}/oauth/login", web_context.config.external_base),
         destination => destination.destination,
     };
 
-    let render_template = select_template!("login", hx_boosted, hx_request, language);
-    let error_template = select_template!(hx_boosted, hx_request, language);
-
     if let Some(subject) = login_form.handle {
         let resolved_did = resolve_subject(
             &web_context.http_client,
···
         .await;
 
         if let Err(err) = resolved_did {
-            return contextual_error!(
-                web_context,
-                language,
-                render_template,
-                template_context! { ..default_context.clone(), ..template_context! {
-                    handle_error => true,
-                    handle_input => subject,
-                }},
-                err
-            );
+            let error_context = template_context! { 
+                ..default_context.clone(), 
+                handle_error => true,
+                handle_input => subject,
+            };
+            return contextual_error!(renderer: renderer, err, error_context);
         }
 
         let resolved_did = resolved_did.unwrap();
···
         let did_document = match query_results {
             Ok(value) => value,
             Err(err) => {
-                return contextual_error!(
-                    web_context,
-                    language,
-                    render_template,
-                    template_context! { ..default_context.clone(), ..template_context! {
-                        handle_error => true,
-                        handle_input => subject,
-                    }},
-                    err
-                );
+                let error_context = template_context! { 
+                    ..default_context.clone(), 
+                    handle_error => true,
+                    handle_input => subject,
+                };
+                return contextual_error!(renderer: renderer, err, error_context);
             }
         };
 
···
         let pds = match did_document.pds_endpoint() {
             Some(value) => value,
             None => {
-                return contextual_error!(
-                    web_context,
-                    language,
-                    render_template,
-                    template_context! { ..default_context.clone(), ..template_context! {
-                        handle_error => true,
-                        handle_input => subject,
-                    }},
-                    LoginError::NoPDS
-                );
+                let error_context = template_context! { 
+                    ..default_context.clone(), 
+                    handle_error => true,
+                    handle_input => subject,
+                };
+                return contextual_error!(renderer: renderer, LoginError::NoPDS, error_context);
             }
         };
 
         let primary_handle = match did_document.primary_handle() {
             Some(value) => value,
             None => {
-                return contextual_error!(
-                    web_context,
-                    language,
-                    render_template,
-                    template_context! { ..default_context.clone(), ..template_context! {
-                        handle_error => true,
-                        handle_input => subject,
-                    }},
-                    LoginError::NoHandle
-                );
+                let error_context = template_context! { 
+                    ..default_context.clone(), 
+                    handle_error => true,
+                    handle_input => subject,
+                };
+                return contextual_error!(renderer: renderer, LoginError::NoHandle, error_context);
             }
         };
 
         if let Err(err) =
             handle_warm_up(&web_context.pool, &did_document.id, primary_handle, pds).await
         {
-            return contextual_error!(web_context, language, error_template, default_context, err);
+            return contextual_error!(renderer: renderer, err, default_context);
         }
 
         let state: String = rand::thread_rng()
···
         return Ok(Redirect::temporary(destination.as_str()).into_response());
     }
 
-    Ok(RenderHtml(
-        &render_template,
-        web_context.engine.clone(),
-        template_context! { ..default_context, ..template_context! {
-            destination => destination.destination,
-        }},
-    )
-    .into_response())
+    let final_context = template_context! { 
+        ..default_context, 
+        destination => destination.destination,
+    };
+    
+    Ok(renderer.render_template(
+        "login",
+        final_context,
+        Some(current_handle),
+        &canonical_url,
+    ))
 }
 
 pub fn gen_pkce() -> (String, String) {

src/http/handle_oauth_logout.rs

···
 };
 use axum_extra::extract::{cookie::Cookie, PrivateCookieJar};
 use axum_htmx::{HxRedirect, HxRequest};
-use axum_template::RenderHtml;
 use http::StatusCode;
 use minijinja::context as template_context;
 
-use crate::http::{
-    context::WebContext, errors::WebError, middleware_auth::AUTH_COOKIE_NAME,
-    middleware_i18n::Language,
+use crate::{
+    create_renderer,
+    http::{
+        context::WebContext, errors::WebError, middleware_auth::AUTH_COOKIE_NAME,
+        middleware_i18n::Language,
+    },
 };
 
 pub async fn handle_logout(
···
         let hx_redirect = HxRedirect::try_from("/");
         if let Err(err) = hx_redirect {
             tracing::error!("Failed to create HxLocation: {}", err);
-            return Ok(RenderHtml(
-                format!("alert.{}.partial.html", language.to_string().to_lowercase()),
-                web_context.engine.clone(),
+            
+            // Create the template renderer for error handling
+            let renderer = create_renderer!(web_context.clone(), Language(language), false, true);
+            let canonical_url = format!("https://{}/", web_context.config.external_base);
+            
+            return Ok(renderer.render_template(
+                "alert.partial",
                 template_context! { message => "Internal Server Error" },
-            )
-            .into_response());
+                None,
+                &canonical_url,
+            ));
         }
         let hx_redirect = hx_redirect.unwrap();
         Ok((StatusCode::OK, hx_redirect, "").into_response())

src/http/handle_policy.rs

···
 use axum::{extract::State, response::IntoResponse};
 use axum_extra::extract::Cached;
 use axum_htmx::HxBoosted;
-use axum_template::RenderHtml;
 
 use minijinja::context as template_context;
 
 use crate::{
+    create_renderer,
     http::{
         context::WebContext, errors::WebError, middleware_auth::Auth, middleware_i18n::Language,
     },
-    select_template,
 };
 
 pub async fn handle_privacy_policy(
···
     Language(language): Language,
     Cached(auth): Cached<Auth>,
 ) -> Result<impl IntoResponse, WebError> {
-    let render_template = select_template!("privacy-policy", hx_boosted, false, language);
+    // Create the template renderer with enhanced context
+    let renderer = create_renderer!(web_context.clone(), Language(language), hx_boosted, false);
+    
+    let canonical_url = format!("https://{}/privacy-policy", web_context.config.external_base);
+    let current_handle = auth.0.as_ref().map(|h| h.handle.as_str()).unwrap_or("");
+    
     Ok((
         http::StatusCode::OK,
-        RenderHtml(
-            &render_template,
-            web_context.engine.clone(),
-            template_context! {
-                current_handle => auth.0,
-                language => language.to_string(),
-                canonical_url => format!("https://{}/privacy-policy", web_context.config.external_base),
-            },
+        renderer.render_template(
+            "privacy-policy",
+            template_context! {},
+            Some(current_handle),
+            &canonical_url,
         ),
     )
         .into_response())
···
     Language(language): Language,
     Cached(auth): Cached<Auth>,
 ) -> Result<impl IntoResponse, WebError> {
-    let render_template = select_template!("terms-of-service", hx_boosted, false, language);
+    // Create the template renderer with enhanced context
+    let renderer = create_renderer!(web_context.clone(), Language(language), hx_boosted, false);
+    
+    let canonical_url = format!("https://{}/terms-of-service", web_context.config.external_base);
+    let current_handle = auth.0.as_ref().map(|h| h.handle.as_str()).unwrap_or("");
+    
     Ok((
         http::StatusCode::OK,
-        RenderHtml(
-            &render_template,
-            web_context.engine.clone(),
-            template_context! {
-                current_handle => auth.0,
-                language => language.to_string(),
-                canonical_url => format!("https://{}/terms-of-service", web_context.config.external_base),
-            },
+        renderer.render_template(
+            "terms-of-service",
+            template_context! {},
+            Some(current_handle),
+            &canonical_url,
         ),
     )
         .into_response())
···
     Language(language): Language,
     Cached(auth): Cached<Auth>,
 ) -> Result<impl IntoResponse, WebError> {
-    let render_template = select_template!("cookie-policy", hx_boosted, false, language);
+    // Create the template renderer with enhanced context
+    let renderer = create_renderer!(web_context.clone(), Language(language), hx_boosted, false);
+    
+    let canonical_url = format!("https://{}/cookie-policy", web_context.config.external_base);
+    let current_handle = auth.0.as_ref().map(|h| h.handle.as_str()).unwrap_or("");
+    
     Ok((
         http::StatusCode::OK,
-        RenderHtml(
-            &render_template,
-            web_context.engine.clone(),
-            template_context! {
-                current_handle => auth.0,
-                language => language.to_string(),
-                canonical_url => format!("https://{}/cookie-policy", web_context.config.external_base),
-            },
+        renderer.render_template(
+            "cookie-policy",
+            template_context! {},
+            Some(current_handle),
+            &canonical_url,
         ),
     )
         .into_response())
···
     Language(language): Language,
     Cached(auth): Cached<Auth>,
 ) -> Result<impl IntoResponse, WebError> {
-    let render_template = select_template!("acknowledgement", hx_boosted, false, language);
+    // Create the template renderer with enhanced context
+    let renderer = create_renderer!(web_context.clone(), Language(language), hx_boosted, false);
+    
+    let canonical_url = format!("https://{}/acknowledgement", web_context.config.external_base);
+    let current_handle = auth.0.as_ref().map(|h| h.handle.as_str()).unwrap_or("");
+    
     Ok((
         http::StatusCode::OK,
-        RenderHtml(
-            &render_template,
-            web_context.engine.clone(),
-            template_context! {
-                current_handle => auth.0,
-                language => language.to_string(),
-                canonical_url => format!("https://{}/acknowledgement", web_context.config.external_base),
-            },
+        renderer.render_template(
+            "acknowledgement",
+            template_context! {},
+            Some(current_handle),
+            &canonical_url,
         ),
     )
         .into_response())

src/http/handle_profile.rs

···
 use axum::response::IntoResponse;
 use axum_extra::extract::Query;
 use axum_htmx::{HxBoosted, HxRequest};
-use axum_template::RenderHtml;
 use chrono_tz::Tz;
 use http::StatusCode;
 use minijinja::context as template_context;
···
 use std::fmt;
 
 use crate::{
-    contextual_error,
+    contextual_error, create_renderer,
     http::{
         context::UserRequestContext,
         errors::{CommonError, WebError},
···
         tab_selector::{TabLink, TabSelector},
         utils::build_url,
     },
-    select_template,
     storage::{
         errors::StorageError,
         event::{event_list_did_recently_updated, model::EventWithRole},
···
     pagination: Query<Pagination>,
     tab_selector: Query<TabSelector>,
 ) -> Result<impl IntoResponse, WebError> {
-    let default_context = template_context! {
-        language => ctx.language.to_string(),
-        current_handle => ctx.current_handle,
-    };
-
-    let render_template = select_template!("profile", hx_boosted, hx_request, ctx.language);
-    let error_template = select_template!(false, hx_request, ctx.language);
+    let renderer = create_renderer!(ctx.web_context, ctx.language, hx_boosted, hx_request);
 
     if !handle_slug.starts_with("did:web:")
         && !handle_slug.starts_with("did:plc:")
         && !handle_slug.starts_with('@')
     {
         return contextual_error!(
-            ctx.web_context,
-            ctx.language,
-            error_template,
-            default_context,
+            renderer: renderer,
             CommonError::InvalidHandleSlug,
+            template_context!{},
             StatusCode::NOT_FOUND
         );
     }
···
 
     if let Err(err) = profile {
         return contextual_error!(
-            ctx.web_context,
-            ctx.language,
-            error_template,
-            default_context,
+            renderer: renderer,
             err,
+            template_context!{},
             StatusCode::NOT_FOUND
         );
     }
···
             Ok(values) => values,
             Err(err) => {
                 return contextual_error!(
-                    ctx.web_context,
-                    ctx.language,
-                    error_template,
-                    default_context,
+                    renderer: renderer,
                     err,
+                    template_context!{},
                     StatusCode::NOT_FOUND
                 );
             }
···
         active: tab == ProfileTab::RecentlyUpdated,
     }];
 
+    let canonical_url = format!(
+        "https://{}/{}",
+        ctx.web_context.config.external_base,
+        handle_slug
+    );
+
     Ok((
         StatusCode::OK,
-        RenderHtml(
-            &render_template,
-            ctx.web_context.engine.clone(),
-            template_context! { ..default_context, ..template_context! {
+        renderer.render_template(
+            "profile",
+            template_context! {
                 tab => tab.to_string(),
                 tabs => tab_links,
                 events,
                 pagination => pagination_view,
-            }},
+            },
+            ctx.current_handle.as_ref().map(|h| &h.handle),
+            &canonical_url,
         ),
     )
         .into_response())

src/http/handle_settings.rs

···
 use axum::{extract::State, response::IntoResponse};
 use axum_extra::extract::{Cached, Form};
 use axum_htmx::HxBoosted;
-use axum_template::RenderHtml;
 use http::StatusCode;
 use minijinja::context as template_context;
 use serde::Deserialize;
···
 use unic_langid::LanguageIdentifier;
 
 use crate::{
-    contextual_error,
+    contextual_error, create_renderer,
     http::{
         context::WebContext, errors::WebError, middleware_auth::Auth, middleware_i18n::Language,
         timezones::supported_timezones,
     },
-    select_template,
     storage::handle::{handle_for_did, handle_update_field, HandleField},
 };
 
···
     // Require authentication
     let current_handle = auth.require(&web_context.config.destination_key, "/settings")?;
 
-    let default_context = template_context! {
-        current_handle => current_handle.clone(),
-        language => language.to_string(),
-        canonical_url => format!("https://{}/settings", web_context.config.external_base),
-    };
-
-    let render_template = select_template!("settings", hx_boosted, false, language);
+    // Create the template renderer with enhanced context
+    let renderer = create_renderer!(web_context.clone(), Language(language), hx_boosted, false);
+    
+    let canonical_url = format!("https://{}/settings", web_context.config.external_base);
 
     // Get available timezones
     let (_, timezones) = supported_timezones(Some(&current_handle));
···
     // Render the form
     Ok((
         StatusCode::OK,
-        RenderHtml(
-            &render_template,
-            web_context.engine.clone(),
+        renderer.render_template(
+            "settings",
             template_context! {
                 timezones => timezones,
                 languages => supported_languages,
-                ..default_context,
             },
+            Some(&current_handle.handle),
+            &canonical_url,
         ),
     )
         .into_response())
···
 ) -> Result<impl IntoResponse, WebError> {
     let current_handle = auth.require_flat()?;
 
-    let default_context = template_context! {
-        current_handle => current_handle.clone(),
-        language => language.to_string(),
-    };
-
-    let error_template = select_template!(false, true, language);
-    let render_template = format!("settings.{}.tz.html", language.to_string().to_lowercase());
+    // Create the template renderer for partial updates
+    let renderer = create_renderer!(web_context.clone(), Language(language), false, true);
+    
+    let canonical_url = format!("https://{}/settings", web_context.config.external_base);
 
     let (_, timezones) = supported_timezones(Some(&current_handle));
 
···
         || timezone_form.timezone == current_handle.tz
         || !timezones.contains(&timezone_form.timezone.as_str())
     {
-        return contextual_error!(
-            web_context,
-            language,
-            error_template,
-            default_context,
-            "error-xxx Invalid timezone"
-        );
+        return contextual_error!(renderer: renderer, "Invalid timezone", template_context!{});
     }
 
     if let Err(err) = handle_update_field(
···
     )
     .await
     {
-        return contextual_error!(web_context, language, error_template, default_context, err);
+        return contextual_error!(renderer: renderer, err, template_context!{});
     }
 
     let current_handle = match handle_for_did(&web_context.pool, &current_handle.did).await {
         Ok(value) => value,
         Err(err) => {
-            return contextual_error!(web_context, language, error_template, default_context, err);
+            return contextual_error!(renderer: renderer, err, template_context!{});
         }
     };
 
     Ok((
         StatusCode::OK,
-        RenderHtml(
-            &render_template,
-            web_context.engine.clone(),
+        renderer.render_template(
+            "settings.tz",
             template_context! {
                 timezone_updated => true,
                 timezones,
-                current_handle,
-                ..default_context
             },
+            Some(&current_handle.handle),
+            &canonical_url,
         ),
     )
         .into_response())
···
 ) -> Result<impl IntoResponse, WebError> {
     let current_handle = auth.require_flat()?;
 
-    let default_context = template_context! {
-        current_handle => current_handle.clone(),
-        language => language.to_string(),
-    };
-
-    let error_template = select_template!(false, true, language);
-    let render_template = format!(
-        "settings.{}.language.html",
-        language.to_string().to_lowercase()
-    );
+    // Create the template renderer for partial updates
+    let renderer = create_renderer!(web_context.clone(), Language(language), false, true);
+    
+    let canonical_url = format!("https://{}/settings", web_context.config.external_base);
 
     // Get the list of supported languages
     let supported_languages = web_context
···
         .collect::<Vec<String>>();
 
     if language_form.language.is_empty() || language_form.language == current_handle.language {
-        return contextual_error!(
-            web_context,
-            language,
-            error_template,
-            default_context,
-            "error-xxx Invalid language"
-        );
+        return contextual_error!(renderer: renderer, "Invalid language", template_context!{});
     }
 
     let lang_id = match language_form.language.parse::<LanguageIdentifier>() {
         Ok(value) => value,
         Err(err) => {
-            return contextual_error!(web_context, language, error_template, default_context, err);
+            return contextual_error!(renderer: renderer, err, template_context!{});
         }
     };
 
···
         .iter()
         .any(|l| l == &lang_id)
     {
-        return contextual_error!(
-            web_context,
-            language,
-            error_template,
-            default_context,
-            "error-xxx Invalid language"
-        );
+        return contextual_error!(renderer: renderer, "Invalid language", template_context!{});
     }
 
     if let Err(err) = handle_update_field(
···
     )
     .await
     {
-        return contextual_error!(web_context, language, error_template, default_context, err);
+        return contextual_error!(renderer: renderer, err, template_context!{});
     }
 
     let current_handle = match handle_for_did(&web_context.pool, &current_handle.did).await {
         Ok(value) => value,
         Err(err) => {
-            return contextual_error!(web_context, language, error_template, default_context, err);
+            return contextual_error!(renderer: renderer, err, template_context!{});
         }
     };
 
     Ok((
         StatusCode::OK,
-        RenderHtml(
-            &render_template,
-            web_context.engine.clone(),
+        renderer.render_template(
+            "settings.lang",
             template_context! {
-                current_handle,
                 language_updated => true,
                 languages => supported_languages,
-                ..default_context
             },
+            Some(&current_handle.handle),
+            &canonical_url,
         ),
     )
         .into_response())

src/http/handle_view_event.rs

···
     response::{IntoResponse, Redirect},
 };
 use axum_htmx::HxBoosted;
-use axum_template::RenderHtml;
 use http::StatusCode;
 use minijinja::context as template_context;
 use serde::{Deserialize, Serialize};
···
 use crate::atproto::lexicon::community::lexicon::calendar::event::NSID;
 use crate::atproto::lexicon::events::smokesignal::calendar::event::NSID as SMOKESIGNAL_EVENT_NSID;
 use crate::contextual_error;
+use crate::create_renderer;
 use crate::http::context::UserRequestContext;
 use crate::http::errors::CommonError;
 use crate::http::errors::ViewEventError;
···
 use crate::http::utils::url_from_aturi;
 use crate::resolve::parse_input;
 use crate::resolve::InputType;
-use crate::select_template;
 use crate::storage::event::count_event_rsvps;
 use crate::storage::event::event_exists;
 use crate::storage::event::event_get;
···
     tab_selector: Query<TabSelector>,
     collection_param: Query<CollectionParam>,
 ) -> Result<impl IntoResponse, WebError> {
-    let default_context = template_context! {
-        language => ctx.language.to_string(),
-        current_handle => ctx.current_handle,
-    };
+    let event_url = format!(
+        "https://{}/event/{}/{}",
+        ctx.web_context.config.external_base, handle_slug, event_rkey
+    );
 
-    let render_template = select_template!("view_event", hx_boosted, false, ctx.language);
-    let error_template = select_template!(hx_boosted, false, ctx.language);
+    // Create the template renderer with enhanced context
+    let renderer = create_renderer!(ctx.web_context.clone(), ctx.language, hx_boosted, false);
 
     let profile: Result<Handle, WebError> = match parse_input(&handle_slug) {
         Ok(InputType::Handle(handle)) => handle_for_handle(&ctx.web_context.pool, &handle)
···
     };
 
     if let Err(err) = profile {
-        return contextual_error!(
-            ctx.web_context,
-            ctx.language,
-            error_template,
-            default_context,
-            err,
-            StatusCode::NOT_FOUND
-        );
+        return contextual_error!(renderer: renderer, err, template_context!{}, StatusCode::NOT_FOUND);
     }
 
     let profile = profile.unwrap();
···
     }
 
     if let Err(err) = event_result {
-        return contextual_error!(
-            ctx.web_context,
-            ctx.language,
-            error_template,
-            default_context,
-            err,
-            StatusCode::NOT_FOUND
-        );
+        return contextual_error!(renderer: renderer, err, template_context!{}, StatusCode::NOT_FOUND);
     }
 
     let mut event = event_result.unwrap();
···
 
     Ok((
         StatusCode::OK,
-        RenderHtml(
-            &render_template,
-            ctx.web_context.engine.clone(),
+        renderer.render_template(
+            "view_event",
             template_context! {
-                current_handle => ctx.current_handle,
-                language => ctx.language.to_string(),
-                canonical_url => event_url,
                 event => event_with_counts,
                 is_self,
                 can_edit,
···
                 SMOKESIGNAL_EVENT_NSID => SMOKESIGNAL_EVENT_NSID,
                 using_SMOKESIGNAL_EVENT_NSID => collection == SMOKESIGNAL_EVENT_NSID,
             },
-        ),
-    )
-        .into_response())
+            ctx.current_handle.as_ref(),
+            &event_url,
+        )?,
+    ))
 }
 
 #[cfg(test)]