feat: migrate i18n system from custom fluent to fluent-templates

- Replace custom Fluent implementation with fluent-templates crate
- Fix FluentValue type conversions and remove DateTime variant support
- Update translation methods to return String directly instead of Option<String>
- Maintain backward compatibility for existing form validation calls
- Resolve all compilation errors and ensure tests pass

BREAKING CHANGE: i18n system now uses fluent-templates instead of custom implementation

Cargo.toml

···
 once_cell = "1.19"
 parking_lot = "0.12"
 metrohash = "1.0.7"
+fluent-templates = { version = "0.13.0", features = ["handlebars"] }
 
 [profile.release]
 opt-level = 3

docs/copilot-TODO

···
+This file provides guidance to Claude Code (claude.ai/code) when working with the i18n refactoring migration in this repository.
+
+**Project Overview**
+This is a comprehensive i18n refactoring guide for migrating Smokesignal's i18n system from a complex manual `.ftl` file loading system to `fluent-templates` for simplified architecture and improved performance.
+
+**Common Commands**
+* **Build**: `cargo build`
+* **Check code**: `cargo check --lib`
+* **Run tests**: `cargo test`
+* **Run specific test**: `cargo test fluent_loader`
+* **Run template tests**: `cargo test template_helpers`
+* **Run middleware tests**: `cargo test middleware_i18n`
+* **Run integration tests**: `cargo test template`
+* **Run i18n tests**: `cargo test i18n`
+* **Format code**: `cargo fmt`
+* **Lint**: `cargo clippy`
+
+* All translation files are in i18n folder. 
+
+**Migration Steps**
+
+**Step 1: Analysis of Existing System**
+Analyze current i18n implementation to understand dependencies and architecture.
+
+**Step 2: New fluent-templates Module**
+Reference documentation:
+* https://github.com/XAMPPRocky/fluent-templates
+* https://docs.rs/fluent/latest/fluent/all.html
+* https://docs.rs/minijinja/latest/minijinja/all.html
+
+Controls:
+* Module compiles: `cargo check --lib`
+* Tests pass: `cargo test fluent_loader`
+* No API regression
+
+**Step 3: Template Helpers Adaptation**
+Adapt existing template helpers to work with fluent-templates.
+
+Controls:
+* Helpers compile
+* Existing templates work
+* Test: `cargo test template_helpers`
+
+**Step 3.5: Context Adaptation**
+Update context.rs for simplified I18nContext.
+
+Controls:
+* Simplified I18nContext compiles
+* Translation helpers work
+* Template contexts include locale
+
+**Step 4: Architecture Simplification**
+Create new main module mod.rs for unified API.
+
+Controls:
+* Main module compiles
+* Compatible API maintained
+* Integration tests pass
+
+**Step 4.5: i18n Middleware Optimization**
+Update middleware_i18n.rs for performance improvements.
+
+Controls:
+* Middleware compiles with optimizations
+* Enriched HTMX headers work
+* Faster language detection
+* Tests pass: `cargo test middleware_i18n`
+
+**Step 5: Template Updates**
+Adapt template engine for fluent-templates integration.
+
+Controls:
+* Template engine compiles
+* i18n helpers work
+* Existing templates display correctly
+
+**Step 5.5: Template Handler Refactoring**
+Refactor template handler for complete functionality.
+
+Controls:
+* Template handler compiles without error
+* All template functions available
+* Extended tests pass: `cargo test template_handler`
+* Locale and gender validation works
+* HTMX/URL helpers available
+
+**Step 6: Testing and Validation**
+Complete system and integration testing.
+
+Controls:
+* Unit tests pass: `cargo test i18n`
+* Integration tests pass: `cargo test template`
+* Existing page rendering correct
+
+**Step 7: Cleanup and Optimization**
+Remove obsolete code and update dependencies.
+
+Controls:
+* Successful compilation after cleanup
+* Reduced dependency size
+* Improved performance (compilation time)
+
+**Step 8: Performance Testing and Final Validation**
+Benchmark performance improvements.
+
+Controls:
+* Benchmarks show performance improvement
+* Application starts without error
+* Pages load with correct translations
+* Language switching works
+
+**Step 9.5: Main Binary Update**
+Adapt smokesignal.rs for fluent-templates integration.
+
+Controls:
+* Application starts with fluent-templates
+* Translation validation at startup
+* Logs confirm proper functioning
+* Performance equal or superior to old system
+* Documentation updated to reflect changes
+* No functional regression
+
+**Final Migration Checklist**
+
+**Core Functionality**
+* fluent-templates integrated and functional
+* Gender support preserved (fr-ca)
+* Compatible API maintained
+* Existing templates work
+* Template helpers operational
+
+**Performance and Architecture**
+* Static loading at compile time
+* Reduced dependencies (5 crates removed)
+* Improved compilation time
+* Reduced memory usage
+* Simplified architecture
+
+**Compatibility**
+* No functional regression
+* All translations available (en-us, fr-ca)
+* 5 .ftl files per language loaded
+* Fallback to key if translation missing
+* Support for arguments in translations
+
+**Testing and Validation**
+* Unit tests pass
+* Integration tests pass
+* Application starts without error
+* Performance equal or superior
+* i18n_checker tool functional
+
+**Expected Results**
+* **Performance**: Static loading at compile time
+* **Architecture**: Code simplification (removal of ~500 lines)
+* **Dependencies**: Reduction of 5 external crates
+* **Maintenance**: Simpler and more robust API
+

docs/fluent-template-doc

···
+Fluent Templates: A High level Fluent API.
+Build & Test crates.io Help Wanted Lines Of Code Documentation
+
+fluent-templates lets you to easily integrate Fluent localisation into your Rust application or library. It does this by providing a high level "loader" API that loads fluent strings based on simple language negotiation, and the FluentLoader struct which is a Loader agnostic container type that comes with optional trait implementations for popular templating engines such as handlebars or tera that allow you to be able to use your localisations in your templates with no boilerplate.
+
+Loaders
+Currently this crate provides two different kinds of loaders that cover two main use cases.
+
+static_loader! — A procedural macro that loads your fluent resources at compile-time into your binary and creates a new StaticLoader static variable that allows you to access the localisations. static_loader! is most useful when you want to localise your application and want to ship your fluent resources with your binary.
+
+ArcLoader — A struct that loads your fluent resources at run-time using Arc as its backing storage. ArcLoader is most useful for when you want to be able to change and/or update localisations at run-time, or if you're writing a developer tool that wants to provide fluent localisation in your own application such as a static site generator.
+
+static_loader!
+The easiest way to use fluent-templates is to use the static_loader! procedural macro that will create a new StaticLoader static variable.
+
+Basic Example
+fluent_templates::static_loader! {
+    // Declare our `StaticLoader` named `LOCALES`.
+    static LOCALES = {
+        // The directory of localisations and fluent resources.
+        locales: "./tests/locales",
+        // The language to falback on if something is not present.
+        fallback_language: "en-US",
+        // Optional: A fluent resource that is shared with every locale.
+        core_locales: "./tests/locales/core.ftl",
+    };
+}
+Customise Example
+You can also modify each FluentBundle on initialisation to be able to change configuration or add resources from Rust.
+
+use std::sync::LazyLock;
+use fluent_bundle::FluentResource;
+use fluent_templates::static_loader;
+
+static_loader! {
+    // Declare our `StaticLoader` named `LOCALES`.
+    static LOCALES = {
+        // The directory of localisations and fluent resources.
+        locales: "./tests/locales",
+        // The language to falback on if something is not present.
+        fallback_language: "en-US",
+        // Optional: A fluent resource that is shared with every locale.
+        core_locales: "./tests/locales/core.ftl",
+        // Optional: A function that is run over each fluent bundle.
+        customise: |bundle| {
+            // Since this will be called for each locale bundle and
+            // `FluentResource`s need to be either `&'static` or behind an
+            // `Arc` it's recommended you use lazily initialised
+            // static variables.
+            static CRATE_VERSION_FTL: LazyLock<FluentResource> = LazyLock::new(|| {
+                let ftl_string = String::from(
+                    concat!("-crate-version = {}", env!("CARGO_PKG_VERSION"))
+                );
+
+                FluentResource::try_new(ftl_string).unwrap()
+            });
+
+            bundle.add_resource(&CRATE_VERSION_FTL);
+        }
+    };
+}
+Locales Directory
+fluent-templates will collect all subdirectories that match a valid Unicode Language Identifier and bundle all fluent files found in those directories and map those resources to the respective identifier. fluent-templates will recurse through each language directory as needed and will respect any .gitignore or .ignore files present.
+
+Example Layout
+locales
+├── core.ftl
+├── en-US
+│   └── main.ftl
+├── fr
+│   └── main.ftl
+├── zh-CN
+│   └── main.ftl
+└── zh-TW
+    └── main.ftl
+Looking up fluent resources
+You can use the Loader trait to lookup a given fluent resource, and provide any additional arguments as needed with lookup_with_args.
+
+Example
+ # In `locales/en-US/main.ftl`
+ hello-world = Hello World!
+ greeting = Hello { $name }!
+
+ # In `locales/fr/main.ftl`
+ hello-world = Bonjour le monde!
+ greeting = Bonjour { $name }!
+
+ # In `locales/de/main.ftl`
+ hello-world = Hallo Welt!
+ greeting = Hallo { $name }!
+use std::collections::HashMap;
+
+use unic_langid::{LanguageIdentifier, langid};
+use fluent_templates::{Loader, static_loader};
+
+const US_ENGLISH: LanguageIdentifier = langid!("en-US");
+const FRENCH: LanguageIdentifier = langid!("fr");
+const GERMAN: LanguageIdentifier = langid!("de");
+
+static_loader! {
+    static LOCALES = {
+        locales: "./tests/locales",
+        fallback_language: "en-US",
+        // Removes unicode isolating marks around arguments, you typically
+        // should only set to false when testing.
+        customise: |bundle| bundle.set_use_isolating(false),
+    };
+}
+
+fn main() {
+    assert_eq!("Hello World!", LOCALES.lookup(&US_ENGLISH, "hello-world"));
+    assert_eq!("Bonjour le monde!", LOCALES.lookup(&FRENCH, "hello-world"));
+    assert_eq!("Hallo Welt!", LOCALES.lookup(&GERMAN, "hello-world"));
+
+    let args = {
+        let mut map = HashMap::new();
+        map.insert(String::from("name"), "Alice".into());
+        map
+    };
+
+    assert_eq!("Hello Alice!", LOCALES.lookup_with_args(&US_ENGLISH, "greeting", &args));
+    assert_eq!("Bonjour Alice!", LOCALES.lookup_with_args(&FRENCH, "greeting", &args));
+    assert_eq!("Hallo Alice!", LOCALES.lookup_with_args(&GERMAN, "greeting", &args));
+}
+Tera
+With the tera feature you can use FluentLoader as a Tera function. It accepts a key parameter pointing to a fluent resource and lang for what language to get that key for. Optionally you can pass extra arguments to the function as arguments to the resource. fluent-templates will automatically convert argument keys from Tera's snake_case to the fluent's preferred kebab-case arguments.
+
+fluent-templates = { version = "*", features = ["tera"] }
+use fluent_templates::{FluentLoader, static_loader};
+
+static_loader! {
+    static LOCALES = {
+        locales: "./tests/locales",
+        fallback_language: "en-US",
+        // Removes unicode isolating marks around arguments, you typically
+        // should only set to false when testing.
+        customise: |bundle| bundle.set_use_isolating(false),
+    };
+}
+
+fn main() {
+    let mut tera = tera::Tera::default();
+    let ctx = tera::Context::default();
+    tera.register_function("fluent", FluentLoader::new(&*LOCALES));
+    assert_eq!(
+        "Hello World!",
+        tera.render_str(r#"{{ fluent(key="hello-world", lang="en-US") }}"#, &ctx).unwrap()
+    );
+    assert_eq!(
+        "Hello Alice!",
+        tera.render_str(r#"{{ fluent(key="greeting", lang="en-US", name="Alice") }}"#, &ctx).unwrap()
+    );
+}
+Handlebars
+In handlebars, fluent-templates will read the lang field in your handlebars::Context while rendering.
+
+fluent-templates = { version = "*", features = ["handlebars"] }
+use fluent_templates::{FluentLoader, static_loader};
+
+static_loader! {
+    static LOCALES = {
+        locales: "./tests/locales",
+        fallback_language: "en-US",
+        // Removes unicode isolating marks around arguments, you typically
+        // should only set to false when testing.
+        customise: |bundle| bundle.set_use_isolating(false),
+    };
+}
+
+fn main() {
+    let mut handlebars = handlebars::Handlebars::new();
+    handlebars.register_helper("fluent", Box::new(FluentLoader::new(&*LOCALES)));
+    let data = serde_json::json!({"lang": "zh-CN"});
+    assert_eq!("Hello World!", handlebars.render_template(r#"{{fluent "hello-world"}}"#, &data).unwrap());
+    assert_eq!("Hello Alice!", handlebars.render_template(r#"{{fluent "greeting" name="Alice"}}"#, &data).unwrap());
+}
+Handlebars helper syntax.
+The main helper provided is the {{fluent}} helper. If you have the following Fluent file:
+
+foo-bar = "foo bar"
+placeholder = this has a placeholder { $variable }
+placeholder2 = this has { $variable1 } { $variable2 }
+You can include the strings in your template with
+
+<!-- will render "foo bar" -->
+{{fluent "foo-bar"}}
+<!-- will render "this has a placeholder baz" -->
+{{fluent "placeholder" variable="baz"}}
+You may also use the {{fluentparam}} helper to specify variables, especially if you need them to be multiline.
+
+{{#fluent "placeholder2"}}
+    {{#fluentparam "variable1"}}
+        first line
+        second line
+    {{/fluentparam}}
+    {{#fluentparam "variable2"}}
+        first line
+        second line
+    {{/fluentparam}}
+{{/fluent}}
+FAQ
+Why is there extra characters around the values of arguments?
+These are called "Unicode Isolating Marks" that used to allow the text to be bidirectional. You can disable this with FluentBundle::set_isolating_marks being set to false.
+
+static_loader! {
+    static LOCALES = {
+        locales: "./tests/locales",
+        fallback_language: "en-US",
+        // Removes unicode isolating marks around arguments.
+        customise: |bundle| bundle.set_use_isolating(false),
+    };
+}

docs/minijinja-reference

···
+ Docs.rs
+ minijinja-2.10.2 
+ Platform 
+ Feature flags
+docs.rs
+Rust
+ 
+Find crate
+logo
+minijinja
+2.10.2
+Crate Items
+Macros
+Structs
+Enums
+Traits
+Functions
+Type ‘S’ or ‘/’ to search, ‘?’ for more options…
+List of all items
+Structs
+Environment
+Error
+Expression
+HtmlEscape
+Output
+State
+Template
+syntax::SyntaxConfig
+syntax::SyntaxConfigBuilder
+value::DynObject
+value::Kwargs
+value::Rest
+value::Value
+value::ValueIter
+value::ViaDeserialize
+Enums
+AutoEscape
+ErrorKind
+UndefinedBehavior
+value::Enumerator
+value::ObjectRepr
+value::ValueKind
+Traits
+functions::Function
+value::ArgType
+value::FunctionArgs
+value::FunctionResult
+value::Object
+value::ObjectExt
+Macros
+args
+context
+render
+Functions
+default_auto_escape_callback
+escape_formatter
+filters::abs
+filters::attr
+filters::batch
+filters::bool
+filters::capitalize
+filters::default
+filters::dictsort
+filters::escape
+filters::first
+filters::float
+filters::groupby
+filters::indent
+filters::int
+filters::items
+filters::join
+filters::last
+filters::length
+filters::lines
+filters::list
+filters::lower
+filters::map
+filters::max
+filters::min
+filters::pprint
+filters::reject
+filters::rejectattr
+filters::replace
+filters::reverse
+filters::round
+filters::safe
+filters::select
+filters::selectattr
+filters::slice
+filters::sort
+filters::split
+filters::string
+filters::sum
+filters::title
+filters::tojson
+filters::trim
+filters::unique
+filters::upper
+filters::urlencode
+functions::debug
+functions::dict
+functions::namespace
+functions::range
+path_loader
+tests::is_boolean
+tests::is_defined
+tests::is_divisibleby
+tests::is_endingwith
+tests::is_eq
+tests::is_even
+tests::is_false
+tests::is_filter
+tests::is_float
+tests::is_ge
+tests::is_gt
+tests::is_in
+tests::is_integer
+tests::is_iterable
+tests::is_le
+tests::is_lower
+tests::is_lt
+tests::is_mapping
+tests::is_ne
+tests::is_none
+tests::is_number
+tests::is_odd
+tests::is_safe
+tests::is_sameas
+tests::is_sequence
+tests::is_startingwith
+tests::is_string
+tests::is_test
+tests::is_true
+tests::is_undefined
+tests::is_upper
+value::from_args
+value::merge_maps
+value::serializing_for_value

i18n/en-us/actions.ftl

···
+# Action buttons and controls - English (US)
+
+# Basic actions
+save = Save
+add = Add
+update = Update
+remove = Remove
+submit = Submit
+view = View
+clear = Clear
+reset = Reset
+
+# Specific actions
+update-event = Update Event
+remove-entry = Remove
+follow = Follow
+unfollow = Unfollow
+login = Login
+create-rsvp = Create RSVP
+record-rsvp = Record RSVP
+import-event = Import Event
+
+# Admin actions
+manage-handles = Manage known handles
+manage-denylist = Manage blocked identities
+view-events = View all events ordered by recent updates
+view-rsvps = View all RSVPs ordered by recent updates
+import-rsvp = Import RSVP
+nuke-identity = Nuke Identity
+
+# Admin confirmations and warnings
+confirm-nuke-identity = Are you sure you want to nuke this identity? This will delete all records and add the handle, PDS, and DID to the denylist.
+
+# Event actions
+planned = Planned
+scheduled = Scheduled
+cancelled = Cancelled
+postponed = Postponed
+rescheduled = Rescheduled
+
+# Status options for events
+status-active = Active
+
+# Status options for RSVPs
+status-going = Going
+status-interested = Interested
+status-not-going = Not Going
+
+# Event modes
+
+# Location types
+location-type-venue = Venue
+location-type-coordinates = Coordinates
+location-type-virtual = Virtual

i18n/en-us/common.ftl

···
+# Common UI elements - English (US)
+
+# Basic greetings
+welcome = Welcome!
+hello = Hello
+
+# Gender-aware greetings
+profile-greeting = Hello there
+profile-greeting-feminine = Hello miss
+profile-greeting-masculine = Hello sir
+profile-greeting-neutral = Hello there
+
+welcome-user = Welcome {$name}!
+welcome-user-feminine = Welcome miss {$name}!
+welcome-user-masculine = Welcome sir {$name}!
+welcome-user-neutral = Welcome {$name}!
+
+# Actions
+save-changes = Save Changes
+cancel = Cancel
+delete = Delete
+edit = Edit
+create = Create
+back = Back
+next = Next
+previous = Previous
+close = Close
+loading = Loading...
+
+# Navigation
+home = Home
+events = Events
+profile = Profile
+settings = Settings
+admin = Admin
+logout = Logout
+
+# Profile related
+display-name = Display Name
+handle = Handle
+member-since = Member Since
+
+# Event related
+event-title = Event Title
+event-description = Event Description
+create-event = Create Event
+edit-event = Edit Event
+view-event = View Event
+events-created = { $count ->
+    [0] No events created
+    [1] One event created
+   *[other] {$count} events created
+}
+
+# Forms
+enter-name-placeholder = Enter your name
+enter-email-placeholder = Enter your email
+required-field = This field is required
+
+# Messages
+success-saved = Successfully saved
+error-occurred = An error occurred
+validation-error = Please check your input and try again

i18n/en-us/errors.ftl

···
-error-unknown-1 = Unknown error
+# Error messages and validation - English (US)
+
+# Form validation
+validation-required = This field is required
+validation-email = Please enter a valid email
+validation-minlength = Must be at least {$min} characters
+validation-maxlength = Must be no more than {$max} characters
+validation-name-length = Must be at least 10 characters and no more than 500 characters
+validation-description-length = Must be at least 10 characters and no more than 3000 characters
+
+# Error messages
+error-unknown = Unknown error
+form-submit-error = Unable to submit form
+profile-not-found = Profile not found
+event-creation-failed = Failed to create event
+event-update-failed = Failed to update event
+
+# Help text
+help-subject-uri = URI of the content to block (at URI, DIDs, URLs, domains)
+help-reason-blocking = Reason for blocking this content
+
+# Error pages
+error-404-title = Page Not Found
+error-404-message = The page you are looking for does not exist.
+error-500-title = Internal Server Error
+error-500-message = An unexpected error occurred.
+error-403-title = Access Denied
+error-403-message = You do not have permission to access this resource.
+
+# Form validation errors
+error-required-field = This field is required
+error-invalid-email = Invalid email address
+error-invalid-handle = Invalid handle
+error-handle-taken = This handle is already taken
+error-password-too-short = Password must be at least 8 characters
+error-passwords-dont-match = Passwords do not match
+
+# Database errors
+error-database-connection = Database connection error
+error-database-timeout = Database timeout exceeded
+
+# Authentication errors
+error-invalid-credentials = Invalid credentials
+error-account-locked = Account locked
+error-session-expired = Session expired
+
+# File upload errors
+error-file-too-large = File is too large
+error-invalid-file-type = Invalid file type
+error-upload-failed = Upload failed

i18n/en-us/forms.ftl

···
+# Form labels, placeholders, and help text - English (US)
+
+# Form field labels
+label-name = Name
+label-text = Text
+label-description = Description
+label-subject = Subject
+label-reason = Reason
+label-status = Status
+label-display-name = Display Name
+label-handle = Handle
+label-email = Email
+label-password = Password
+label-location-name = Location Name
+label-address = Address
+label-city = City
+label-state = State
+label-zip = ZIP Code
+label-link-name = Link Name
+label-link-url = Link URL
+label-timezone = Timezone
+label-start-day = Start Day
+label-start-time = Start Time
+label-end-day = End Day
+label-end-time = End Time
+label-starts-at = Starts At
+label-ends-at = Ends At
+label-country = Country
+label-street-address = Street Address
+label-locality = Locality
+label-region = Region
+label-postal-code = Postal Code
+label-location = Location
+label-event-at-uri = Event AT-URI
+label-at-uri = AT-URI
+
+# Form placeholders
+placeholder-tickets-url = https://smokesignal.tickets/
+placeholder-at-uri-event = at://smokesignal.events/community.lexicon.calendar.event/neat
+placeholder-at-uri-rsvp = at://did:plc:abc123/app.bsky.feed.post/record123
+placeholder-at-uri-admin = at://did:plc:abcdef/community.lexicon.calendar.rsvp/3jizzrxoalv2h
+
+# Help text
+help-name-length = Must be at least 10 characters and no more than 500 characters
+help-description-length = Must be at least 10 characters and no more than 3000 characters
+help-rsvp-public = RSVPs are public and can be viewed by anyone that can view the information stored in your PDS.
+help-rsvp-learn-more = Learn more about rsvps on the
+help-rsvp-help-page = RSVP Help
+
+# Required field indicators
+optional-field = (optional)
+
+# Time and date
+not-set = Not Set
+add-end-time = Add End Time
+remove-end-time = Remove End Time
+
+# Authentication forms
+label-sign-in = Sign-In
+placeholder-handle-login = you.bsky.social

i18n/en-us/ui.ftl

···
+# User interface labels and text - English (US)
+
+# Page titles and headings
+page-title-admin = Smoke Signal Admin
+page-title-create-event = Smoke Signal - Create Event
+page-title-edit-event = Smoke Signal - Edit Event
+page-title-filter-events = Find Events - Smoke Signal
+page-title-import = Smoke Signal - Import
+page-title-view-rsvp = RSVP Viewer - Smoke Signal
+page-description-filter-events = Discover local events and activities in your community
+acknowledgement = Acknowledgement
+administration-tools = Administration Tools
+
+# Section headings
+what-are-smoke-signals = What are smoke signals?
+why-the-name = Why the name?
+land-acknowledgement = Land Acknowledgement
+learning-more = Learning More
+
+# Admin interface
+denylist = Denylist
+handle-records = Handle Records
+event-records = Event Records
+rsvp-records = RSVP Records
+event-record = Event Record
+add-update-entry = Add or Update Entry
+
+# Table headers
+subject = Subject
+reason = Reason
+updated = Updated
+actions = Actions
+
+# Form labels
+name-required = Name (required)
+text-required = Text (required)
+status = Status
+mode = Mode
+location = Location
+email = Email
+
+# Event status options
+status-planned = Planned
+status-scheduled = Scheduled
+status-cancelled = Cancelled
+status-postponed = Postponed
+status-rescheduled = Rescheduled
+
+# Event mode options
+mode-virtual = Virtual
+mode-hybrid = Hybrid
+mode-inperson = In Person
+
+# Location warnings
+location-cannot-edit = Location cannot be edited
+location-edit-restriction = Only events with a single location of type "Address" can be edited through this form.
+no-location-info = No location information available.
+
+# Location types
+location-type-link = Link
+location-type-address = Address
+location-type-other = Other location type
+
+# Placeholders
+placeholder-awesome-event = My Awesome Event
+placeholder-event-description = A helpful, brief description of the event
+placeholder-at-uri = at://did:plc:...
+placeholder-reason-blocking = Reason for blocking...
+placeholder-handle = you.bsky.social
+placeholder-tickets = Tickets
+placeholder-venue-name = The Gem City
+placeholder-address = 555 Somewhere
+placeholder-city = Dayton
+placeholder-state = Ohio
+placeholder-zip = 11111
+placeholder-rsvp-aturi = at://did:plc:example/community.lexicon.calendar.rsvp/abcdef123
+
+# Navigation
+nav-home = Home
+nav-events = Events
+nav-profile = Profile
+nav-settings = Settings
+nav-admin = Admin
+nav-logout = Logout
+
+# Content messages
+events-count = You have {$count ->
+    [0] no events
+    [1] 1 event
+    *[other] {$count} events
+}
+back-to-profile = Back to Profile
+
+# Success messages
+event-created-success = The event has been created!
+event-updated-success = The event has been updated!
+
+# Info messages
+events-public-notice = Events are public and can be viewed by anyone that can view the information stored in your PDS. Do not publish personal or sensitive information in your events.
+event-help-link = Event Help
+help-rsvp-aturi = Enter the full AT-URI of the RSVP you want to view
+
+# Page titles and headings - English (US)
+
+# Admin and configuration pages
+page-title-admin-denylist = Admin - Denylist
+page-title-admin-events = Events - Smoke Signal Admin
+page-title-admin-rsvps = RSVPs - Smoke Signal Admin
+page-title-admin-rsvp = RSVP Record - Smoke Signal Admin
+page-title-admin-event = Event Record - Smoke Signal Admin
+page-title-admin-handles = Handles - Smoke Signal Admin
+page-title-create-rsvp = Create RSVP
+page-title-login = Smoke Signal - Login
+page-title-settings = Settings - Smoke Signal
+page-title-event-migration = Event Migration Complete - Smoke Signal
+page-title-view-event = Smoke Signal
+page-title-profile = Smoke Signal
+page-title-alert = Smoke Signal
+
+# Event and RSVP viewing
+message-legacy-event = You are viewing a older version of this event.
+message-view-latest = View Latest
+message-migrate-event = Migrate to Lexicon Community Event
+message-fallback-collection = This event was found in the "{$collection}" collection.
+message-edit-event = Edit Event
+message-create-rsvp = Create RSVP
+
+# Authentication and login
+login-instructions = Sign into Smoke Signal using your full ATProto handle.
+login-quick-start = The {$link} is a step-by-step guide to getting started.
+login-quick-start-link = Quick Start Guide
+login-trouble = Trouble signing in?
+
+# Page headings and content
+heading-admin = Admin
+heading-admin-denylist = Denylist
+heading-admin-events = Event Records
+heading-admin-rsvps = RSVP Records
+heading-admin-rsvp = RSVP Record
+heading-admin-event = Event Record
+heading-admin-handles = Handle Records
+heading-create-event = Create Event
+heading-create-rsvp = Create RSVP
+heading-import-event = Import Event by AT-URI
+heading-import-rsvp = Import RSVP
+heading-rsvp-details = RSVP Details
+heading-rsvp-json = RSVP JSON
+heading-rsvp-viewer = RSVP Viewer
+heading-settings = Settings
+heading-import = Import
+heading-edit-event = Edit Event
+
+# Status and notification messages
+message-rsvp-recorded = The RSVP has been recorded!
+message-rsvp-import-success = RSVP imported successfully!
+message-view-rsvp = View RSVP
+message-no-results = No results found.
+
+# Navigation and breadcrumbs
+nav-rsvps = RSVPs
+nav-denylist = Denylist
+nav-handles = Handles
+nav-rsvp-record = RSVP Record
+nav-event-record = Event Record
+nav-help = Help
+nav-blog = Blog
+nav-your-profile = Your Profile
+nav-add-event = Add Event
+nav-login = Log in
+
+# Footer navigation
+footer-support = Support
+footer-privacy-policy = Privacy Policy
+footer-cookie-policy = Cookie Policy
+footer-terms-of-service = Terms of Service
+footer-acknowledgement = Acknowledgement
+footer-made-by = made by
+footer-source-code = Source Code
+
+# Table headers
+header-name = Name
+header-updated = Updated
+header-actions = Actions
+header-rsvp = RSVP
+header-event = Event
+header-status = Status
+header-did = DID
+header-handle = Handle
+header-pds = PDS
+header-language = Language
+header-timezone = Timezone
+
+# Descriptions and subtitles
+subtitle-admin-events = View all events ordered by recent updates
+subtitle-admin-rsvps = View all RSVPs ordered by recent updates
+subtitle-admin-handles = View known handles
+help-import-aturi = Enter the full AT-URI of the event to import
+help-import-rsvp-aturi = Enter the AT-URI of an RSVP to import - supports both "community.lexicon.calendar.rsvp" and "events.smokesignal.calendar.rsvp" collections
+
+# Common UI elements
+greeting = Hello
+greeting-masculine = Hello
+greeting-feminine = Hello
+greeting-neutral = Hello
+timezone = timezone
+event-id = Event ID
+total-count = { $count ->
+    [one] ({ $count })
+   *[other] ({ $count })
+}
+
+# Technical labels and identifiers
+label-aturi = AT-URI
+label-cid = CID
+label-did = DID
+label-lexicon = Lexicon
+label-event-aturi = Event AT-URI
+label-event-cid = Event CID
+label-rsvp-details = RSVP Details
+label-rsvp-json = RSVP JSON
+label-rsvp-aturi = RSVP AT-URI
+
+# Home page
+page-title-home = Smoke Signal
+page-description-home = Smoke Signal is an event and RSVP management system.
+
+# Utility pages
+page-title-privacy-policy = Privacy Policy - Smoke Signal
+page-title-cookie-policy = Cookie Policy - Smoke Signal
+page-title-terms-of-service = Terms of Service - Smoke Signal
+page-title-acknowledgement = Acknowledgement - Smoke Signal
+
+# Event viewing - maps and links
+link-apple-maps = Apple Maps
+link-google-maps = Google Maps
+text-event-link = Event Link
+message-view-latest-rsvps = View latest version to see RSVPs
+
+# Event status tooltips
+tooltip-cancelled = The event is cancelled.
+tooltip-postponed = The event is postponed.
+tooltip-no-status = No event status set.
+tooltip-in-person = In person
+tooltip-virtual = A virtual (online) event
+tooltip-hybrid = A hybrid in-person and virtual (online) event
+
+# RSVP login message
+message-login-to-rsvp = Log in to RSVP to this
+
+# Event viewing - edit button
+button-edit = Edit
+
+# Event status labels
+label-no-status = No Status Set
+
+# Time labels
+label-no-start-time = No Start Time Set
+label-no-end-time = No End Time Set
+tooltip-starts-at = Starts at {$time}
+tooltip-ends-at = Ends at {$time}
+tooltip-no-start-time = No start time is set.
+tooltip-no-end-time = No end time is set.
+
+# RSVP buttons and status
+button-going = Going
+button-interested = Interested
+button-not-going = Not Going
+message-no-rsvp = You have not RSVP'd.
+message-rsvp-going = You have RSVP'd <strong>Going</strong>.
+message-rsvp-interested = You have RSVP'd <strong>Interested</strong>.
+message-rsvp-not-going = You have RSVP'd <strong>Not Going</strong>.
+
+# Tab labels for RSVP lists
+tab-going = Going ({$count})
+tab-interested = Interested ({$count})
+tab-not-going = Not Going ({$count})
+
+# Legacy event messages
+message-rsvps-not-available = RSVPs are not available for legacy events.
+message-use-standard-version = Please use the <a href="{$url}">standard version</a> of this event to RSVP.
+button-migrate-rsvp = Migrate my RSVP to Lexicon Community Event
+message-rsvp-migrated = Your RSVP has been migrated
+message-rsvp-info-not-available = RSVP information is not available for legacy events.
+message-view-latest-to-see-rsvps = View latest version to see RSVPs
+
+# Settings sub-templates
+label-language = Language
+label-time-zone = Time Zone
+message-language-updated = Language updated successfully.
+message-timezone-updated = Time zone updated successfully.
+
+# Event list - role status labels
+role-going = Going
+role-interested = Interested
+role-not-going = Not Going
+role-organizer = Organizer
+role-unknown = Unknown
+label-legacy = Legacy
+
+# Event list - mode labels and tooltips
+mode-in-person = In Person
+
+# Event list - RSVP count tooltips
+tooltip-count-going = {$count} Going
+tooltip-count-interested = {$count} Interested
+tooltip-count-not-going = {$count} Not Going
+
+# Event list - status tooltips
+tooltip-planned = The event is planned.
+tooltip-scheduled = The event is scheduled.
+tooltip-rescheduled = The event is rescheduled.
+
+# Pagination
+pagination-previous = Previous
+pagination-next = Next
+
+# Home Page
+site-name = Smoke Signal
+site-tagline = Find events, make connections, and create community.
+home-quick-start = The <a href="https://docs.smokesignal.events/docs/getting-started/quick-start/">Quick Start Guide</a> is a step-by-step guide to getting started!
+home-recent-events = Recently Updated Events
+
+# Import Functionality
+import-complete = Import complete!
+import-start = Start Import
+import-continue = Continue Import
+import-complete-button = Import Complete
+
+# Navigation and Branding
+nav-logo-alt = Smoke Signal
+
+# Profile Page Meta
+profile-meta-description = {"@"}{$handle} {$did} on Smoke Signal
+
+# Site Branding (used in meta tags and structured data)
+site-branding = Smoke Signal
+
+# Event Filtering Interface
+filter-events-title = Filter Events
+filter-search-label = Search Events
+filter-search-placeholder = Search by title, description, or keywords...
+filter-date-label = Date Range
+filter-location-label = Location
+filter-latitude-placeholder = Latitude
+filter-longitude-placeholder = Longitude
+filter-radius-placeholder = Radius (km)
+filter-creator-label = Event Creator
+filter-creator-all = All Creators
+filter-sort-label = Sort By
+filter-sort-newest = Newest Events
+filter-sort-oldest = Upcoming Events
+filter-sort-recently-created = Recently Created
+filter-sort-distance = Nearest to You
+filter-apply-button = Apply Filters
+filter-active-filters = Active Filters
+filter-results-title = Events
+filter-results-per-page = per page
+filter-no-results-title = No events found
+filter-no-results-subtitle = Try adjusting your search criteria or clear filters
+filter-clear-all = Clear All Filters
+
+# Event Cards
+event-by = by
+event-rsvps = RSVPs
+event-view-details = View Details
+event-rsvp = RSVP

i18n/fr-ca/actions.ftl

···
+# Boutons d'action et contrôles - Français (Canada)
+
+# Actions de base
+save = Sauvegarder
+add = Ajouter
+update = Mettre à jour
+remove = Supprimer
+submit = Soumettre
+view = Voir
+clear = Effacer
+reset = Réinitialiser
+
+# Actions spécifiques
+update-event = Mettre à jour l'événement
+remove-entry = Supprimer
+follow = Suivre
+unfollow = Ne plus suivre
+login = Connexion
+create-rsvp = Créer une RSVP
+record-rsvp = Enregistrer une RSVP
+import-event = Importer un événement
+
+# Actions administratives
+manage-handles = Gérer les identifiants connus
+manage-denylist = Gérer les identités bloquées
+view-events = Voir tous les événements par mises à jour récentes
+view-rsvps = Voir toutes les RSVP par mises à jour récentes
+import-rsvp = Importer une RSVP
+nuke-identity = Supprimer l'identité
+
+# Confirmations et avertissements administratifs
+confirm-nuke-identity = Es-tu sûr de vouloir supprimer cette identité? Cette action va effacer tous les enregistrements et ajouter l'identifiant, le PDS et le DID à la liste de blocage.
+
+# Actions d'événement
+planned = Planifié
+scheduled = Programmé
+cancelled = Annulé
+postponed = Reporté
+rescheduled = Reprogrammé
+
+# Options de statut pour les événements
+status-active = Actif
+
+# Options de statut pour les RSVP
+status-going = J'y vais
+status-interested = Intéressé
+status-not-going = Je n'y vais pas
+
+# Modes d'événement
+
+# Types d'emplacement
+location-type-venue = Lieu
+location-type-coordinates = Coordonnées
+location-type-virtual = Virtuel

i18n/fr-ca/common.ftl

···
+# Éléments communs de l'interface utilisateur - Français (Canada)
+
+# Salutations de base
+welcome = Bienvenue!
+hello = Bonjour
+
+# Salutations selon le genre
+profile-greeting = Salut
+profile-greeting-feminine = Salut
+profile-greeting-masculine = Salut
+profile-greeting-neutral = Salut
+
+welcome-user = Bienvenue {$name}!
+welcome-user-feminine = Bienvenue {$name}!
+welcome-user-masculine = Bienvenue {$name}!
+welcome-user-neutral = Bienvenue {$name}!
+
+# Actions
+save-changes = Sauvegarder les changements
+cancel = Annuler
+delete = Supprimer
+edit = Modifier
+create = Créer
+back = Retour
+next = Suivant
+previous = Précédent
+close = Fermer
+loading = Chargement en cours...
+
+# Navigation
+home = Accueil
+events = Événements
+profile = Profil
+settings = Paramètres
+admin = Admin
+logout = Déconnexion
+
+# Lié au profil
+display-name = Nom d'affichage
+handle = Identifiant
+member-since = Membre depuis
+
+# Lié aux événements
+event-title = Titre de l'événement
+event-description = Description de l'événement
+create-event = Créer un événement
+edit-event = Modifier un événement
+view-event = Voir l'événement
+events-created = { $count ->
+    [0] Aucun événement créé
+    [1] Un événement créé
+   *[other] {$count} événements créés
+}
+
+# Formulaires
+enter-name-placeholder = Entre ton nom
+enter-email-placeholder = Entre ton courriel
+required-field = Ce champ est requis
+
+# Messages
+success-saved = Sauvegardé avec succès
+error-occurred = Une erreur est survenue
+validation-error = Vérifie tes informations et essaie à nouveau

i18n/fr-ca/errors.ftl

···
+# Messages d'erreur et validation - Français (Canada)
+
+# Validation de formulaire
+validation-required = Ce champ est requis
+validation-email = Entre un courriel valide
+validation-minlength = Doit contenir au moins {$min} caractères
+validation-maxlength = Ne doit pas dépasser {$max} caractères
+validation-name-length = Doit contenir au moins 10 caractères et pas plus de 500 caractères
+validation-description-length = Doit contenir au moins 10 caractères et pas plus de 3000 caractères
+
+# Messages d'erreur
+error-unknown = Erreur inconnue
+form-submit-error = Impossible de soumettre le formulaire
+profile-not-found = Profil introuvable
+event-creation-failed = Échec de création de l'événement
+event-update-failed = Échec de mise à jour de l'événement
+
+# Textes d'aide
+help-subject-uri = URI du contenu à bloquer (URI AT, DIDs, URLs, domaines)
+help-reason-blocking = Raison du blocage de ce contenu
+
+# Pages d'erreur
+error-404-title = Page introuvable
+error-404-message = La page que tu cherches n'existe pas.
+error-500-title = Erreur interne du serveur
+error-500-message = Une erreur inattendue s'est produite.
+error-403-title = Accès refusé
+error-403-message = Tu n'as pas la permission d'accéder à cette ressource.
+
+# Erreurs de validation de formulaire
+error-required-field = Ce champ est requis
+error-invalid-email = Adresse courriel invalide
+error-invalid-handle = Identifiant invalide
+error-handle-taken = Cet identifiant est déjà pris
+error-password-too-short = Le mot de passe doit contenir au moins 8 caractères
+error-passwords-dont-match = Les mots de passe ne correspondent pas
+
+# Erreurs de base de données
+error-database-connection = Erreur de connexion à la base de données
+error-database-timeout = Délai de connexion à la base de données dépassé
+
+# Erreurs d'authentification
+error-invalid-credentials = Identifiants invalides
+error-account-locked = Compte verrouillé
+error-session-expired = Session expirée
+
+# Erreurs de téléchargement de fichier
+error-file-too-large = Fichier trop volumineux
+error-invalid-file-type = Type de fichier invalide
+error-upload-failed = Échec du téléchargement

i18n/fr-ca/forms.ftl

···
+# Étiquettes, textes indicatifs et aide pour les formulaires - Français (Canada)
+
+# Étiquettes de champs de formulaire
+label-name = Nom
+label-text = Texte
+label-description = Description
+label-subject = Sujet
+label-reason = Raison
+label-status = Statut
+label-display-name = Nom d'affichage
+label-handle = Identifiant
+label-email = Courriel
+label-password = Mot de passe
+label-location-name = Nom du lieu
+label-address = Adresse
+label-city = Ville
+label-state = Province
+label-zip = Code postal
+label-link-name = Nom du lien
+label-link-url = URL du lien
+label-timezone = Fuseau horaire
+label-start-day = Jour de début
+label-start-time = Heure de début
+label-end-day = Jour de fin
+label-end-time = Heure de fin
+label-starts-at = Commence à
+label-ends-at = Se termine à
+label-country = Pays
+label-street-address = Adresse civique
+label-locality = Localité
+label-region = Région
+label-postal-code = Code postal
+label-location = Lieu
+label-event-at-uri = AT-URI de l'événement
+label-at-uri = AT-URI
+
+# Textes indicatifs
+placeholder-tickets-url = https://smokesignal.tickets/
+placeholder-at-uri-event = at://smokesignal.events/community.lexicon.calendar.event/neat
+placeholder-at-uri-rsvp = at://did:plc:abc123/app.bsky.feed.post/record123
+placeholder-at-uri-admin = at://did:plc:abcdef/community.lexicon.calendar.rsvp/3jizzrxoalv2h
+
+# Textes d'aide
+help-name-length = Doit contenir au moins 10 caractères et pas plus de 500 caractères
+help-description-length = Doit contenir au moins 10 caractères et pas plus de 3000 caractères
+help-rsvp-public = Les RSVP sont publiques et peuvent être vues par quiconque peut voir les informations stockées dans ton PDS.
+help-rsvp-learn-more = En savoir plus sur les RSVP sur la
+help-rsvp-help-page = Page d'aide RSVP
+
+# Indicateurs de champs obligatoires
+optional-field = (optionnel)
+
+# Heure et date
+not-set = Non défini
+add-end-time = Ajouter une heure de fin
+remove-end-time = Supprimer l'heure de fin
+
+# Formulaires d'authentification
+label-sign-in = Connexion
+placeholder-handle-login = toi.bsky.social

i18n/fr-ca/ui.ftl

···
+# Libellés et textes de l'interface utilisateur - Français (Canada)
+
+# Titres de page et en-têtes
+page-title-admin = Administration de Smoke Signal
+page-title-create-event = Smoke Signal - Créer un événement
+page-title-edit-event = Smoke Signal - Modifier un événement
+page-title-filter-events = Trouver des événements - Smoke Signal
+page-title-import = Smoke Signal - Importation
+page-title-view-rsvp = Visualiseur RSVP - Smoke Signal
+page-description-filter-events = Découvre des événements et activités locaux dans ta communauté
+acknowledgement = Reconnaissance
+administration-tools = Outils d'administration
+
+# En-têtes de section
+what-are-smoke-signals = Que sont les signaux de fumée?
+why-the-name = Pourquoi ce nom?
+land-acknowledgement = Reconnaissance territoriale
+learning-more = En savoir plus
+
+# Interface d'administration
+denylist = Liste de blocage
+handle-records = Registre des identifiants
+event-records = Registre des événements
+rsvp-records = Registre des RSVP
+event-record = Enregistrement d'événement
+add-update-entry = Ajouter ou mettre à jour une entrée
+
+# En-têtes de tableau
+subject = Sujet
+reason = Raison
+updated = Mis à jour
+actions = Actions
+
+# Étiquettes de formulaire
+name-required = Nom (requis)
+text-required = Texte (requis)
+status = Statut
+mode = Mode
+location = Lieu
+email = Courriel
+
+# Options de statut d'événement
+status-planned = Planifié
+status-scheduled = Programmé
+status-cancelled = Annulé
+status-postponed = Reporté
+status-rescheduled = Reprogrammé
+
+# Options de mode d'événement
+mode-virtual = Virtuel
+mode-hybrid = Hybride
+mode-inperson = En personne
+
+# Avertissements liés au lieu
+location-cannot-edit = Le lieu ne peut pas être modifié
+location-edit-restriction = Seuls les événements avec un seul lieu de type "Adresse" peuvent être modifiés via ce formulaire.
+no-location-info = Aucune information de lieu disponible.
+
+# Types de lieu
+location-type-link = Lien
+location-type-address = Adresse
+location-type-other = Autre type de lieu
+
+# Textes indicatifs
+placeholder-awesome-event = Mon événement génial
+placeholder-event-description = Une description brève et utile de l'événement
+placeholder-at-uri = at://did:plc:...
+placeholder-reason-blocking = Raison du blocage...
+placeholder-handle = toi.bsky.social
+placeholder-tickets = Billets
+placeholder-venue-name = La Ville des Gemmes
+placeholder-address = 555 Quelque Part
+placeholder-city = Montréal
+placeholder-state = Québec
+placeholder-zip = H1H 1H1
+placeholder-rsvp-aturi = at://did:plc:example/community.lexicon.calendar.rsvp/abcdef123
+
+# Navigation
+nav-home = Accueil
+nav-events = Événements
+nav-profile = Profil
+nav-settings = Paramètres
+nav-admin = Admin
+nav-logout = Déconnexion
+
+# Messages de contenu
+events-count = Tu as {$count ->
+    [0] aucun événement
+    [1] 1 événement
+    *[other] {$count} événements
+}
+back-to-profile = Retour au profil
+
+# Messages de succès
+event-created-success = L'événement a été créé!
+event-updated-success = L'événement a été mis à jour!
+
+# Messages d'information
+events-public-notice = Les événements sont publics et peuvent être vus par quiconque peut voir les informations stockées dans ton PDS. Ne publie pas d'informations personnelles ou sensibles dans tes événements.
+event-help-link = Aide sur les événements
+help-rsvp-aturi = Entre l'AT-URI complet de la RSVP que tu veux voir
+
+# Titres de page et en-têtes - Français (Canada)
+
+# Pages d'administration et de configuration
+page-title-admin-denylist = Admin - Liste de blocage
+page-title-admin-events = Événements - Admin Smoke Signal
+page-title-admin-rsvps = RSVPs - Admin Smoke Signal
+page-title-admin-rsvp = Enregistrement RSVP - Admin Smoke Signal
+page-title-admin-event = Enregistrement d'événement - Admin Smoke Signal
+page-title-admin-handles = Identifiants - Admin Smoke Signal
+page-title-create-rsvp = Créer une RSVP
+page-title-login = Smoke Signal - Connexion
+page-title-settings = Paramètres - Smoke Signal
+page-title-event-migration = Migration d'événement terminée - Smoke Signal
+page-title-view-event = Smoke Signal
+page-title-profile = Smoke Signal
+page-title-alert = Smoke Signal
+
+# Visualisation d'événement et de RSVP
+message-legacy-event = Tu consultes une ancienne version de cet événement.
+message-view-latest = Voir la dernière version
+message-migrate-event = Migrer vers un événement communautaire Lexicon
+message-fallback-collection = Cet événement a été trouvé dans la collection "{$collection}".
+message-edit-event = Modifier l'événement
+message-create-rsvp = Créer une RSVP
+
+# Authentification et connexion
+login-instructions = Connecte-toi à Smoke Signal en utilisant ton identifiant ATProto complet.
+login-quick-start = Le {$link} est un guide étape par étape pour démarrer.
+login-quick-start-link = Guide de démarrage rapide
+login-trouble = Problème de connexion?
+
+# En-têtes et contenu de page
+heading-admin = Admin
+heading-admin-denylist = Liste de blocage
+heading-admin-events = Registre des événements
+heading-admin-rsvps = Registre des RSVP
+heading-admin-rsvp = Enregistrement RSVP
+heading-admin-event = Enregistrement d'événement
+heading-admin-handles = Registre des identifiants
+heading-create-event = Créer un événement
+heading-create-rsvp = Créer une RSVP
+heading-import-event = Importer un événement par AT-URI
+heading-import-rsvp = Importer une RSVP
+heading-rsvp-details = Détails de la RSVP
+heading-rsvp-json = RSVP JSON
+heading-rsvp-viewer = Visualiseur RSVP
+heading-settings = Paramètres
+heading-import = Importation
+heading-edit-event = Modifier un événement
+
+# Messages d'état et notifications
+message-rsvp-recorded = La RSVP a été enregistrée!
+message-rsvp-import-success = RSVP importée avec succès!
+message-view-rsvp = Voir la RSVP
+message-no-results = Aucun résultat trouvé.
+
+# Navigation et fil d'Ariane
+nav-rsvps = RSVPs
+nav-denylist = Liste de blocage
+nav-handles = Identifiants
+nav-rsvp-record = Enregistrement RSVP
+nav-event-record = Enregistrement d'événement
+nav-help = Aide
+nav-blog = Blogue
+nav-your-profile = Ton profil
+nav-add-event = Ajouter un événement
+nav-login = Se connecter
+
+# Navigation de pied de page
+footer-support = Support
+footer-privacy-policy = Politique de confidentialité
+footer-cookie-policy = Politique des cookies
+footer-terms-of-service = Conditions d'utilisation
+footer-acknowledgement = Reconnaissance
+footer-made-by = fait par
+footer-source-code = Code source
+
+# En-têtes de tableau
+header-name = Nom
+header-updated = Mis à jour
+header-actions = Actions
+header-rsvp = RSVP
+header-event = Événement
+header-status = Statut
+header-did = DID
+header-handle = Identifiant
+header-pds = PDS
+header-language = Langue
+header-timezone = Fuseau horaire
+
+# Descriptions et sous-titres
+subtitle-admin-events = Voir tous les événements classés par mises à jour récentes
+subtitle-admin-rsvps = Voir toutes les RSVP classées par mises à jour récentes
+subtitle-admin-handles = Voir les identifiants connus
+help-import-aturi = Entre l'AT-URI complet de l'événement à importer
+help-import-rsvp-aturi = Entre l'AT-URI d'une RSVP à importer - supporte les collections "community.lexicon.calendar.rsvp" et "events.smokesignal.calendar.rsvp"
+
+# Éléments d'interface communs
+greeting = Salut
+greeting-masculine = Salut
+greeting-feminine = Salut
+greeting-neutral = Salut
+timezone = fuseau horaire
+event-id = ID de l'événement
+total-count = { $count ->
+    [one] ({ $count })
+   *[other] ({ $count })
+}
+
+# Étiquettes et identifiants techniques
+label-aturi = AT-URI
+label-cid = CID
+label-did = DID
+label-lexicon = Lexicon
+label-event-aturi = AT-URI de l'événement
+label-event-cid = CID de l'événement
+label-rsvp-details = Détails de la RSVP
+label-rsvp-json = RSVP JSON
+label-rsvp-aturi = AT-URI de la RSVP
+
+# Page d'accueil
+page-title-home = Smoke Signal
+page-description-home = Smoke Signal est un système de gestion d'événements et de RSVP.
+
+# Pages utilitaires
+page-title-privacy-policy = Politique de confidentialité - Smoke Signal
+page-title-cookie-policy = Politique des cookies - Smoke Signal
+page-title-terms-of-service = Conditions d'utilisation - Smoke Signal
+page-title-acknowledgement = Reconnaissance - Smoke Signal
+
+# Visualisation d'événements - cartes et liens
+link-apple-maps = Apple Maps
+link-google-maps = Google Maps
+text-event-link = Lien de l'événement
+message-view-latest-rsvps = Voir la dernière version pour voir les RSVP
+
+# Infobulles d'état d'événement
+tooltip-cancelled = L'événement est annulé.
+tooltip-postponed = L'événement est reporté.
+tooltip-no-status = Aucun statut d'événement défini.
+tooltip-in-person = En personne
+tooltip-virtual = Un événement virtuel (en ligne)
+tooltip-hybrid = Un événement hybride en personne et virtuel (en ligne)
+
+# Message de connexion RSVP
+message-login-to-rsvp = Connecte-toi pour répondre à cet événement
+
+# Visualisation d'événement - bouton modifier
+button-edit = Modifier
+
+# Étiquettes de statut d'événement
+label-no-status = Aucun statut défini
+
+# Étiquettes de temps
+label-no-start-time = Aucune heure de début définie
+label-no-end-time = Aucune heure de fin définie
+tooltip-starts-at = Commence à {$time}
+tooltip-ends-at = Se termine à {$time}
+tooltip-no-start-time = Aucune heure de début n'est définie.
+tooltip-no-end-time = Aucune heure de fin n'est définie.
+
+# Boutons RSVP et statut
+button-going = J'y vais
+button-interested = Intéressé
+button-not-going = Je n'y vais pas
+message-no-rsvp = Tu n'as pas encore répondu.
+message-rsvp-going = Tu as répondu <strong>J'y vais</strong>.
+message-rsvp-interested = Tu as répondu <strong>Intéressé</strong>.
+message-rsvp-not-going = Tu as répondu <strong>Je n'y vais pas</strong>.
+
+# Étiquettes d'onglets pour les listes RSVP
+tab-going = J'y vais ({$count})
+tab-interested = Intéressés ({$count})
+tab-not-going = N'y vont pas ({$count})
+
+# Messages pour événements hérités
+message-rsvps-not-available = Les RSVP ne sont pas disponibles pour les événements hérités.
+message-use-standard-version = Utilise la <a href="{$url}">version standard</a> de cet événement pour répondre.
+button-migrate-rsvp = Migrer ma réponse vers un événement communautaire Lexicon
+message-rsvp-migrated = Ta réponse a été migrée
+message-rsvp-info-not-available = Les informations de réponse ne sont pas disponibles pour les événements hérités.
+message-view-latest-to-see-rsvps = Voir la dernière version pour voir les RSVP
+
+# Sous-modèles de paramètres
+label-language = Langue
+label-time-zone = Fuseau horaire
+message-language-updated = Langue mise à jour avec succès.
+message-timezone-updated = Fuseau horaire mis à jour avec succès.
+
+# Liste d'événements - étiquettes de rôle
+role-going = J'y vais
+role-interested = Intéressé
+role-not-going = Je n'y vais pas
+role-organizer = Organisateur
+role-unknown = Inconnu
+label-legacy = Hérité
+
+# Liste d'événements - étiquettes de mode et infobulles
+mode-in-person = En personne
+
+# Liste d'événements - infobulles de compte RSVP
+tooltip-count-going = {$count} y vont
+tooltip-count-interested = {$count} intéressés
+tooltip-count-not-going = {$count} n'y vont pas
+
+# Liste d'événements - infobulles de statut
+tooltip-planned = L'événement est planifié.
+tooltip-scheduled = L'événement est programmé.
+tooltip-rescheduled = L'événement est reprogrammé.
+
+# Pagination
+pagination-previous = Précédent
+pagination-next = Suivant
+
+# Page d'accueil
+site-name = Smoke Signal
+site-tagline = Trouve des événements, crée des connexions et forme une communauté.
+home-quick-start = Le <a href="https://docs.smokesignal.events/docs/getting-started/quick-start/">Guide de démarrage rapide</a> est un guide étape par étape pour commencer!
+home-recent-events = Événements récemment mis à jour
+
+# Fonctionnalité d'importation
+import-complete = Importation terminée!
+import-start = Démarrer l'importation
+import-continue = Continuer l'importation
+import-complete-button = Importation terminée
+
+# Navigation et marque
+nav-logo-alt = Smoke Signal
+
+# Méta profil de page
+profile-meta-description = {"@"}{$handle} {$did} sur Smoke Signal
+
+# Marque du site (utilisée dans les balises meta et les données structurées)
+site-branding = Smoke Signal
+
+# Interface de filtrage d'événements
+filter-events-title = Filtrer les événements
+filter-search-label = Rechercher des événements
+filter-search-placeholder = Rechercher par titre, description ou mots-clés...
+filter-date-label = Plage de dates
+filter-location-label = Lieu
+filter-latitude-placeholder = Latitude
+filter-longitude-placeholder = Longitude
+filter-radius-placeholder = Rayon (km)
+filter-creator-label = Créateur d'événement
+filter-creator-all = Tous les créateurs
+filter-sort-label = Trier par
+filter-sort-newest = Événements les plus récents
+filter-sort-oldest = Événements à venir
+filter-sort-recently-created = Créés récemment
+filter-sort-distance = Plus près de toi
+filter-apply-button = Appliquer les filtres
+filter-active-filters = Filtres actifs
+filter-results-title = Événements
+filter-results-per-page = par page
+filter-no-results-title = Aucun événement trouvé
+filter-no-results-subtitle = Essaie d'ajuster tes critères de recherche ou de supprimer les filtres
+filter-clear-all = Effacer tous les filtres
+
+# Cartes d'événement
+event-by = par
+event-rsvps = RSVP
+event-view-details = Voir les détails
+event-rsvp = Répondre

src/bin/smokesignal.rs

···
         AppEngine::from(jinja),
         &http_client,
         config.clone(),
-        I18nContext::new(supported_languages, locales),
+        I18nContext::new(),
         dns_resolver,
     );
 

src/http/context.rs

···
     config::Config,
     http::middleware_auth::Auth,
     http::middleware_i18n::Language,
-    i18n::Locales,
+    i18n::{get_supported_languages, get_translation, Locales},
     storage::handle::model::Handle,
     storage::{CachePool, StoragePool},
 };
···
     pub locales: Locales,
 }
 
+impl I18nContext {
+    pub fn new() -> Self {
+        let supported_languages = get_supported_languages();
+        let locales = Locales::new(supported_languages.clone());
+        Self {
+            supported_languages,
+            locales,
+        }
+    }
+
+    /// Get a translation for the given locale and key
+    pub fn get_translation(&self, locale: &LanguageIdentifier, key: &str) -> String {
+        get_translation(locale, key, None)
+    }
+
+    /// Get a translation with arguments
+    pub fn get_translation_with_args(
+        &self,
+        locale: &LanguageIdentifier,
+        key: &str,
+        args: std::collections::HashMap<std::borrow::Cow<'static, str>, fluent::FluentValue<'static>>,
+    ) -> String {
+        // Convert the HashMap to the expected format
+        let converted_args: std::collections::HashMap<String, fluent_templates::fluent_bundle::FluentValue> = args
+            .into_iter()
+            .map(|(k, v)| {
+                let converted_value = match v {
+                    fluent::FluentValue::String(s) => fluent_templates::fluent_bundle::FluentValue::String(s),
+                    fluent::FluentValue::Number(n) => fluent_templates::fluent_bundle::FluentValue::Number(n),
+                    fluent::FluentValue::None => fluent_templates::fluent_bundle::FluentValue::String("".into()),
+                    fluent::FluentValue::Error => fluent_templates::fluent_bundle::FluentValue::String("".into()),
+                    _ => fluent_templates::fluent_bundle::FluentValue::String("".into()), // Handle any other variants
+                };
+                (k.to_string(), converted_value)
+            })
+            .collect();
+        
+        get_translation(locale, key, Some(converted_args))
+    }
+
+    /// Check if a language is supported
+    pub fn supports_language(&self, locale: &LanguageIdentifier) -> bool {
+        self.supported_languages.contains(locale)
+    }
+}
+
 pub struct InnerWebContext {
     pub engine: AppEngine,
     pub http_client: reqwest::Client,
···
     }
 }
 
-impl I18nContext {
-    pub fn new(supported_languages: Vec<LanguageIdentifier>, locales: Locales) -> Self {
-        Self {
-            supported_languages,
-            locales,
-        }
-    }
-}
-
 impl FromRef<WebContext> for Key {
     fn from_ref(context: &WebContext) -> Self {
         context.0.config.http_cookie_key.as_ref().clone()
···
     ctx: &AdminRequestContext,
     canonical_url: &str,
 ) -> minijinja::value::Value {
+    let supported_languages: Vec<String> = ctx.web_context.i18n_context.supported_languages
+        .iter()
+        .map(|lang| lang.to_string())
+        .collect();
+    
     template_context! {
         language => ctx.language.to_string(),
+        locale => ctx.language.to_string(),
         current_handle => ctx.admin_handle.clone(),
         canonical_url => canonical_url,
+        supported_languages => supported_languages,
     }
 }
 
···
         })
     }
 }
+
+/// Helper function to create standard template context for user views
+pub fn user_template_context(
+    ctx: &UserRequestContext,
+    canonical_url: &str,
+) -> minijinja::value::Value {
+    let supported_languages: Vec<String> = ctx.web_context.i18n_context.supported_languages
+        .iter()
+        .map(|lang| lang.to_string())
+        .collect();
+    
+    template_context! {
+        language => ctx.language.to_string(),
+        locale => ctx.language.to_string(),
+        current_handle => ctx.current_handle.clone(),
+        canonical_url => canonical_url,
+        supported_languages => supported_languages,
+    }
+}
+
+/// Helper function to create basic template context with just locale information
+pub fn basic_template_context(
+    language: &Language,
+    supported_languages: &[LanguageIdentifier],
+) -> minijinja::value::Value {
+    let supported_languages: Vec<String> = supported_languages
+        .iter()
+        .map(|lang| lang.to_string())
+        .collect();
+    
+    template_context! {
+        language => language.to_string(),
+        locale => language.to_string(),
+        supported_languages => supported_languages,
+    }
+}

src/http/macros.rs

···
         {
             let (err_bare, err_partial) = $crate::errors::expand_error($error.to_string());
             tracing::warn!(error = ?$error, "encountered error");
-            let error_message =
-                $web_context
-                    .i18n_context
-                    .locales
-                    .format_error(&$language, &err_bare, &err_partial);
+            let error_message = $crate::i18n::fluent_loader::format_error(&$language, &err_bare, &err_partial);
             Ok(
                 (
                     $status_code,

src/http/templates.rs

···
 
     use minijinja::{path_loader, Environment};
     use minijinja_autoreload::AutoReloader;
+    use crate::i18n::register_i18n_functions;
 
     pub fn build_env(http_external: &str, version: &str) -> AutoReloader {
         let http_external = http_external.to_string();
···
             env.add_global("base", format!("https://{}", http_external));
             env.add_global("version", version.clone());
             env.set_loader(path_loader(&template_path));
+            register_i18n_functions(&mut env);
             notifier.set_fast_reload(true);
             notifier.watch_path(&template_path, true);
             Ok(env)
···
 #[cfg(feature = "embed")]
 pub mod embed_env {
     use minijinja::Environment;
+    use crate::i18n::register_i18n_functions;
 
     pub fn build_env(http_external: String, version: String) -> Environment<'static> {
         let mut env = Environment::new();
···
         env.set_lstrip_blocks(true);
         env.add_global("base", format!("https://{}", http_external));
         env.add_global("version", version.clone());
+        register_i18n_functions(&mut env);
         minijinja_embed::load_templates!(&mut env);
         env
     }

src/i18n.rs src/i18n_old.rs

···
 use std::collections::HashMap;
 use unic_langid::LanguageIdentifier;
 
+// Define error types here instead of importing them
+// Using errors from i18n module
 use crate::i18n::errors::I18nError;
 
 pub type Bundle = FluentBundle<FluentResource, intl_memoizer::concurrent::IntlLangMemoizer>;
···
         Ok(())
     }
 }
-
-pub mod errors {
-    use thiserror::Error;
-
-    #[derive(Debug, Error)]
-    pub enum I18nError {
-        #[error("error-i18n-1 Invalid language")]
-        InvalidLanguage,
-
-        #[error("error-i18n-2 Language resource failed")]
-        LanguageResourceFailed(Vec<fluent_syntax::parser::ParserError>),
-
-        #[error("error-i18n-3 Bundle load failed")]
-        BundleLoadFailed(Vec<fluent::FluentError>),
-    }
-}

src/i18n/errors.rs

···
+use fluent::{FluentError};
+use fluent_syntax::parser::ParserError;
+use std::error::Error;
+use std::fmt;
+use unic_langid::LanguageIdentifier;
+
+#[derive(Debug)]
+pub enum I18nError {
+    InvalidLanguage,
+    LanguageResourceFailed(Vec<ParserError>),
+    BundleLoadFailed(Vec<FluentError>),
+    TemplateError(String),
+    MissingTranslation {
+        locale: LanguageIdentifier,
+        message_id: String,
+    },
+}
+
+impl fmt::Display for I18nError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            I18nError::InvalidLanguage => write!(f, "Invalid language identifier"),
+            I18nError::LanguageResourceFailed(errors) => {
+                write!(f, "Failed to parse language resource: {:?}", errors)
+            }
+            I18nError::BundleLoadFailed(errors) => {
+                write!(f, "Failed to load bundle: {:?}", errors)
+            }
+            I18nError::TemplateError(msg) => write!(f, "Template error: {}", msg),
+            I18nError::MissingTranslation { locale, message_id } => {
+                write!(f, "Missing translation for '{}' in locale '{}'", message_id, locale)
+            }
+        }
+    }
+}
+
+impl Error for I18nError {}

src/i18n/fluent_loader.rs

···
+use fluent_templates::{static_loader, Loader};
+use unic_langid::LanguageIdentifier;
+use std::{collections::HashMap, borrow::Cow};
+
+// Use the static_loader! macro as recommended in the documentation
+static_loader! {
+    pub static LOCALES = {
+        locales: "./i18n",
+        fallback_language: "en-us",
+        // Removes unicode isolating marks around arguments for cleaner output
+        customise: |bundle| bundle.set_use_isolating(false),
+    };
+}
+
+/// Helper function to get a translation with specific arguments
+pub fn get_translation(language: &LanguageIdentifier, message_id: &str, args: Option<HashMap<String, fluent_templates::fluent_bundle::FluentValue>>) -> String {
+    match args {
+        Some(arg_map) => {
+            // Convert HashMap<String, FluentValue> to HashMap<Cow<str>, FluentValue>
+            let fluent_args: HashMap<Cow<str>, fluent_templates::fluent_bundle::FluentValue> = arg_map
+                .into_iter()
+                .map(|(k, v)| (Cow::Owned(k), v))
+                .collect();
+            
+            LOCALES.lookup_with_args(language, message_id, &fluent_args)
+        },
+        None => LOCALES.lookup(language, message_id)
+    }
+}
+
+/// A simplified function to get all supported languages  
+pub fn get_supported_languages() -> Vec<LanguageIdentifier> {
+    LOCALES
+        .locales()
+        .cloned()
+        .collect()
+}
+
+/// Format an error message using fluent templates
+/// This function takes error keys and returns a localized error message
+pub fn format_error(language: &LanguageIdentifier, err_bare: &str, err_partial: &str) -> String {
+    // Try to get the specific error message first (err_partial)
+    let error_key = if err_partial.is_empty() {
+        err_bare
+    } else {
+        err_partial
+    };
+    
+    // Get the translation, it will fallback to the key if not found
+    get_translation(language, error_key, None)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use unic_langid::langid;
+
+    #[test]
+    fn test_static_loader() {
+        // Test with English locale
+        let en_us = langid!("en-us");
+        
+        // Simple lookup - just test that the function works
+        let result = get_translation(&en_us, "error-unknown", None);
+        assert!(!result.is_empty()); // Just verify we get some result
+    }
+
+    #[test]
+    fn test_supported_languages() {
+        let langs = get_supported_languages();
+        assert!(!langs.is_empty()); // Should have at least one language
+        
+        // Test that we can parse at least one valid language
+        assert!(langs.iter().any(|lang| lang.to_string().starts_with("en")));
+    }
+}

src/i18n/fluent_templates.rs

···
+// Fluent Templates integration module
+use fluent_templates::{static_loader, Loader, LanguageIdentifier};
+use std::collections::HashMap;
+use std::path::PathBuf;
+use std::sync::Arc;
+use std::borrow::Cow;
+use fluent::FluentValue;
+use tracing::{debug, info, warn};
+
+use crate::i18n::errors::I18nError;
+use crate::i18n::gender::Gender;
+use crate::i18n::SUPPORTED_LANGUAGES;
+
+// Initialize the static loader with localization files
+static_loader! {
+    pub static LOCALES = {
+        locales: "./i18n",
+        fallback_language: "en-us",
+        // Remove unicode isolating marks for consistent output
+        customise: |bundle| {
+            bundle.set_use_isolating(false);
+        }
+    };
+}
+
+// Type alias for the Fluent bundle
+pub type Bundle = fluent::bundle::FluentBundle<fluent::FluentResource, intl_memoizer::concurrent::IntlLangMemoizer>;
+
+// Compatibility wrapper for fluent-templates
+pub struct Locales(pub HashMap<LanguageIdentifier, Bundle>);
+
+impl Locales {
+    pub fn new(locales: Vec<LanguageIdentifier>) -> Self {
+        debug!("Creating new Locales for {} languages", locales.len());
+        let mut store = HashMap::new();
+        for locale in &locales {
+            // Initialize empty bundles that will be populated later
+            let bundle: Bundle = fluent::bundle::FluentBundle::new_concurrent(vec![locale.clone()]);
+            store.insert(locale.clone(), bundle);
+        }
+        Self(store)
+    }
+
+    pub fn add_bundle(
+        &mut self,
+        locale: LanguageIdentifier,
+        content: String,
+    ) -> Result<(), I18nError> {
+        let bundle = self.0.get_mut(&locale).ok_or(I18nError::InvalidLanguage)?;
+
+        let resource = fluent::FluentResource::try_new(content)
+            .map_err(|(_, errors)| I18nError::LanguageResourceFailed(errors))?;
+
+        bundle
+            .add_resource(resource)
+            .map_err(I18nError::BundleLoadFailed)?;
+
+        debug!("Successfully added bundle content for {}", locale);
+        Ok(())
+    }
+
+    pub fn format_message(
+        &self,
+        locale: &LanguageIdentifier,
+        message: &str,
+        args: fluent::FluentArgs,
+    ) -> String {
+        // Use fluent-templates for translation first
+        let fluent_args = convert_fluent_args(args);
+        let result = if fluent_args.is_empty() {
+            LOCALES.lookup(&locale, message)
+        } else {
+            LOCALES.lookup_with_args(&locale, message, &fluent_args)
+        };
+        
+        // If result is the same as the key, it means the translation was not found
+        // in that case, fallback to the original implementation
+        if result == message {
+            // Fallback to existing bundle if available
+            if let Some(bundle) = self.0.get(locale) {
+                if let Some(bundle_message) = bundle.get_message(message) {
+                    if let Some(value) = bundle_message.value() {
+                        let mut errors = Vec::new();
+                        let formatted = bundle.format_pattern(value, None, &mut errors);
+                        return formatted.to_string();
+                    }
+                }
+            }
+        }
+        
+        result
+    }
+
+    pub fn format_error(&self, locale: &LanguageIdentifier, bare: &str, partial: &str) -> String {
+        // Use fluent-templates first
+        let result = LOCALES.lookup(locale, bare);
+        if result != bare {
+            return result;
+        }
+        
+        // Fallback to original implementation
+        if let Some(bundle) = self.0.get(locale) {
+            if let Some(bundle_message) = bundle.get_message(bare) {
+                if let Some(value) = bundle_message.value() {
+                    let mut errors = Vec::new();
+                    let formatted = bundle.format_pattern(value, None, &mut errors);
+                    return formatted.to_string();
+                }
+            }
+        }
+        
+        partial.to_string()
+    }
+    
+    pub fn format_message_with_gender(
+        &self, 
+        locale: &LanguageIdentifier,
+        key: &str,
+        gender: &Gender,
+        args: Option<&fluent::FluentArgs>
+    ) -> String {
+        // Try gender-specific key first
+        let gender_key = format!("{}{}", key, gender.as_suffix());
+        let fluent_args = args.map(convert_fluent_args);
+        
+        // Try looking up gender-specific key with fluent-templates
+        let result = if let Some(args_map) = &fluent_args {
+            LOCALES.lookup_with_args(locale, &gender_key, args_map)
+        } else {
+            LOCALES.lookup(locale, &gender_key)
+        };
+        
+        // If gender-specific key returned the key itself (not found), try base key
+        if result == gender_key {
+            if let Some(args_map) = &fluent_args {
+                LOCALES.lookup_with_args(locale, key, args_map)
+            } else {
+                LOCALES.lookup(locale, key)
+            }
+        } else {
+            result
+        }
+    }
+}
+
+// Convert FluentArgs to fluent-templates compatible format
+fn convert_fluent_args(args: fluent::FluentArgs) -> HashMap<Cow<'static, str>, FluentValue<'static>> {
+    args.iter()
+        .map(|(k, v)| {
+            let owned_key = k.to_string();
+            let owned_value = match v {
+                FluentValue::String(s) => FluentValue::String(Cow::Owned(s.to_string())),
+                FluentValue::Number(n) => FluentValue::Number(n.clone()),
+                _ => FluentValue::String(Cow::Owned(format!("{:?}", v))),
+            };
+            (Cow::Owned(owned_key), owned_value)
+        })
+        .collect()
+}
+
+// Embedded mode implementation
+#[cfg(feature = "embed")]
+pub mod embed {
+    use rust_embed::Embed;
+    use unic_langid::LanguageIdentifier;
+
+    use crate::i18n::{errors::I18nError, Locales};
+
+    #[derive(Embed)]
+    #[folder = "i18n/"]
+    struct I18nAssets;
+
+    pub fn populate_locale(
+        supported_locales: &Vec<LanguageIdentifier>,
+        locales: &mut Locales,
+    ) -> Result<(), I18nError> {
+        let locale_files = vec!["actions", "common", "errors", "forms", "ui"];
+
+        for locale in supported_locales {
+            for file in &locale_files {
+                let source_file = format!("{}/{}.ftl", locale.to_string().to_lowercase(), file);
+                let i18n_asset = I18nAssets::get(&source_file).expect("locale file not found");
+                let content = std::str::from_utf8(i18n_asset.data.as_ref())
+                    .expect("invalid utf-8 in locale file");
+                locales.add_bundle(locale.clone(), content.to_string())?;
+            }
+        }
+        
+        // fluent-templates will load files automatically via static_loader!
+        Ok(())
+    }
+}
+
+// Reload mode implementation
+#[cfg(feature = "reload")]
+pub mod reload {
+    use std::path::PathBuf;
+    use unic_langid::LanguageIdentifier;
+    use tracing::{info, debug};
+
+    use crate::i18n::{errors::I18nError, Locales};
+
+    pub fn populate_locale(
+        supported_locales: &Vec<LanguageIdentifier>,
+        locales: &mut Locales,
+    ) -> Result<(), I18nError> {
+        let locale_files = vec!["actions", "common", "errors", "forms", "ui"];
+
+        for locale in supported_locales {
+            let locale_dir = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
+                .join("i18n")
+                .join(locale.to_string().to_lowercase());
+                
+            debug!("Loading locale directory: {:?}", locale_dir);
+                
+            for file in &locale_files {
+                let source_file = locale_dir.join(format!("{}.ftl", file));
+                info!("Loading locale file: {:?}", source_file);
+                
+                if !source_file.exists() {
+                    debug!("Skipping non-existent file: {:?}", source_file);
+                    continue;
+                }
+                
+                let i18n_asset = std::fs::read(&source_file)
+                    .map_err(|e| I18nError::DirectoryError(format!("{}: {}", source_file.display(), e)))?;
+                    
+                let content =
+                    std::str::from_utf8(&i18n_asset)
+                        .map_err(|e| I18nError::DirectoryError(format!("Invalid UTF-8: {}: {}", source_file.display(), e)))?;
+                        
+                locales.add_bundle(locale.clone(), content.to_string())?;
+            }
+        }
+        
+        // fluent-templates will load files automatically via static_loader!
+        Ok(())
+    }
+}

src/i18n/gender.rs

···
+// Gender handling module for fluent-templates integration
+// This will contain functions for handling gender variants in translations,
+// especially for languages like French Canadian (fr-ca).
+
+use std::{borrow::Cow, collections::HashMap, str::FromStr};
+use unic_langid::LanguageIdentifier;
+ 
+use crate::i18n::fluent_loader::LOCALES;
+use fluent_templates::Loader;
+use fluent_templates::fluent_bundle::types::FluentValue;
+
+#[derive(Clone, Copy, Debug)]
+pub enum Gender {
+    Male,
+    Female,
+    Neutral,
+}
+
+impl Default for Gender {
+    fn default() -> Self {
+        Gender::Neutral
+    }
+}
+
+impl FromStr for Gender {
+    type Err = String;
+    
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s.to_lowercase().as_str() {
+            "male" | "m" | "masculine" => Ok(Gender::Male),
+            "female" | "f" | "feminine" => Ok(Gender::Female),
+            "neutral" | "n" => Ok(Gender::Neutral),
+            _ => Err(format!("Invalid gender: {}", s)),
+        }
+    }
+}
+
+impl From<&str> for Gender {
+    fn from(s: &str) -> Self {
+        match s.to_lowercase().as_str() {
+            "male" | "m" | "masculine" => Gender::Male,
+            "female" | "f" | "feminine" => Gender::Female,
+            _ => Gender::Neutral,
+        }
+    }
+}
+
+// Function to get a gender-specific translation
+pub fn get_gendered_translation(
+    language: &LanguageIdentifier, 
+    message_id: &str,
+    gender: Gender,
+    args: Option<HashMap<String, String>>
+) -> String {
+    // Convert the generic arguments
+    let mut fluent_args: HashMap<Cow<'static, str>, FluentValue> = match args {
+        Some(arg_map) => arg_map
+            .iter()
+            .map(|(k, v)| (Cow::Owned(k.to_string()), FluentValue::String(v.to_string().into())))
+            .collect(),
+        None => HashMap::new(),
+    };
+    
+    // Add the gender argument
+    let gender_value = match gender {
+        Gender::Male => "male",
+        Gender::Female => "female",
+        Gender::Neutral => "neutral",
+    };
+    
+    // Create FluentValue for gender
+    let gender_value = FluentValue::String(gender_value.into());
+    fluent_args.insert(Cow::Borrowed("gender"), gender_value);
+    
+    // Use the fluent-templates loader with the gender argument
+    LOCALES.lookup_with_args(language, message_id, &fluent_args)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use unic_langid::langid;
+
+    #[test]
+    fn test_gender_handling() {
+        // This test will be expanded when gender functionality is fully implemented
+        let fr_ca = langid!("fr-ca");
+        
+        // This will only work if fr-ca locale exists and has gendered translations
+        let supported_langs = crate::i18n::fluent_loader::get_supported_languages();
+        if supported_langs.contains(&fr_ca) {
+            let mut args = HashMap::new();
+            args.insert("name".to_string(), "Alice".to_string());
+            
+            // Test with female gender
+            let result = get_gendered_translation(&fr_ca, "greeting", Gender::Female, Some(args.clone()));
+            
+            // For now, we're just ensuring it returns something and doesn't panic
+            assert!(!result.is_empty());
+        }
+    }
+}

src/i18n/mod.rs

···
+// Keep previous i18n functionality for compatibility
+
+// Public exports for the new fluent-templates based i18n system
+pub mod fluent_loader;
+pub mod gender;
+pub mod errors;
+pub mod template_helpers;
+
+// Re-export the static loader for direct access
+pub use fluent_loader::LOCALES;
+
+// Re-export utility functions
+pub use fluent_loader::{get_translation, get_supported_languages, format_error};
+pub use template_helpers::register_i18n_functions;
+
+// Re-export errors from the new errors module
+pub use errors::I18nError;
+
+// Compatibility type aliasing to support legacy code
+use fluent_bundle::bundle::FluentBundle;
+use fluent::FluentResource;
+pub type Bundle = FluentBundle<FluentResource, intl_memoizer::concurrent::IntlLangMemoizer>;
+
+// Core constants and utility functions for unified API
+use std::str::FromStr;
+use unic_langid::LanguageIdentifier;
+
+/// Supported languages - matches directory structure in ./i18n/
+pub const SUPPORTED_LANGUAGES: &[&str] = &["en-us", "fr-ca"];
+
+/// Creates the list of supported language identifiers
+pub fn create_supported_languages() -> Vec<LanguageIdentifier> {
+    SUPPORTED_LANGUAGES
+        .iter()
+        .map(|lang| LanguageIdentifier::from_str(lang).unwrap())
+        .collect()
+}
+
+/// Normalize a language identifier to lowercase format for consistent storage and lookup
+/// This ensures consistency between browser language detection and our internal storage
+pub fn normalize_language_identifier(locale: &LanguageIdentifier) -> LanguageIdentifier {
+    // Convert to lowercase string format and parse back to LanguageIdentifier
+    // This normalizes cases like "en-US" to "en-us" to match our file structure
+    LanguageIdentifier::from_str(&locale.to_string().to_lowercase()).unwrap()
+}
+
+/// Check if a language identifier is supported (after normalization)
+pub fn is_supported_language(locale: &LanguageIdentifier) -> bool {
+    let normalized = normalize_language_identifier(locale);
+    SUPPORTED_LANGUAGES
+        .iter()
+        .any(|&supported| LanguageIdentifier::from_str(supported).unwrap() == normalized)
+}
+
+// Temporary compatibility struct that will eventually be phased out
+// This provides a bridge between the old system and the new fluent-templates system
+use std::collections::HashMap;
+use fluent::FluentArgs;
+
+pub struct Locales(pub HashMap<LanguageIdentifier, Bundle>);
+
+impl Locales {
+    pub fn new(locales: Vec<LanguageIdentifier>) -> Self {
+        let mut store = HashMap::new();
+        for locale in &locales {
+            let bundle = FluentBundle::new_concurrent(vec![locale.clone()]);
+            store.insert(locale.clone(), bundle);
+        }
+        Self(store)
+    }
+
+    pub fn add_bundle(
+        &mut self,
+        locale: LanguageIdentifier,
+        content: String,
+    ) -> Result<(), I18nError> {
+        // In the new system, bundles are loaded statically at compile time
+        // This is just a compatibility wrapper
+        let bundle = self.0.get_mut(&locale).ok_or(I18nError::InvalidLanguage)?;
+
+        let resource = FluentResource::try_new(content)
+            .map_err(|(_, errors)| I18nError::LanguageResourceFailed(errors))?;
+
+        bundle
+            .add_resource(resource)
+            .map_err(I18nError::BundleLoadFailed)?;
+
+        Ok(())
+    }
+
+    pub fn format_error(&self, locale: &LanguageIdentifier, bare: &str, partial: &str) -> String {
+        // Use the new fluent-templates system internally
+        let result = fluent_loader::get_translation(locale, bare, None);
+        if result.is_empty() {
+            partial.to_string()
+        } else {
+            result
+        }
+    }
+
+    pub fn format_message(
+        &self,
+        locale: &LanguageIdentifier,
+        message: &str,
+        args: FluentArgs,
+    ) -> String {
+        // Convert FluentArgs to HashMap<String, FluentValue> for the new system
+        let mut args_map: HashMap<String, fluent_templates::fluent_bundle::FluentValue> = HashMap::new();
+        
+        for (k, v) in args.iter() {
+            // Convert FluentValue to the fluent_templates FluentValue
+            let value = match v {
+                fluent::FluentValue::String(s) => fluent_templates::fluent_bundle::FluentValue::String(s.clone()),
+                fluent::FluentValue::Number(n) => fluent_templates::fluent_bundle::FluentValue::Number(n.clone()),
+                fluent::FluentValue::Custom(_) => fluent_templates::fluent_bundle::FluentValue::String(format!("{:?}", v).into()),
+                fluent::FluentValue::None => fluent_templates::fluent_bundle::FluentValue::String("".into()),
+                fluent::FluentValue::Error => fluent_templates::fluent_bundle::FluentValue::String("".into()),
+            };
+            args_map.insert(k.to_string(), value);
+        }
+
+        fluent_loader::get_translation(locale, message, Some(args_map))
+    }
+}
+
+// Compatibility modules for feature flags
+#[cfg(feature = "embed")]
+pub mod embed {
+    use unic_langid::LanguageIdentifier;
+    use crate::i18n::{errors::I18nError, Locales};
+
+    // This function is now a no-op since fluent-templates loads resources statically
+    pub fn populate_locale(
+        _supported_locales: &Vec<LanguageIdentifier>,
+        _locales: &mut Locales,
+    ) -> Result<(), I18nError> {
+        // All locales are already loaded by fluent-templates static_loader
+        Ok(())
+    }
+}
+
+#[cfg(feature = "reload")]
+pub mod reload {
+    use unic_langid::LanguageIdentifier;
+    use crate::i18n::{errors::I18nError, Locales};
+
+    // This function is now a compatibility layer
+    pub fn populate_locale(
+        _supported_locales: &Vec<LanguageIdentifier>,
+        _locales: &mut Locales,
+    ) -> Result<(), I18nError> {
+        // All locales are already loaded by fluent-templates static_loader
+        Ok(())
+    }
+}

src/i18n/template_helpers.rs

···
+//! Template helper functions for MiniJinja integration with fluent-templates
+//! 
+//! This module provides template functions that can be used directly in templates
+//! for internationalization support, including gender-aware translations and
+//! locale-specific formatting.
+
+use minijinja::{Environment, Error, ErrorKind, Value};
+use minijinja::value::Kwargs;
+use unic_langid::LanguageIdentifier;
+use std::collections::HashMap;
+use std::borrow::Cow;
+use fluent_templates::Loader;
+use fluent::FluentValue;
+
+use crate::i18n::{gender::Gender, fluent_loader::{LOCALES, get_supported_languages}};
+
+/// Register i18n template functions in a MiniJinja environment
+/// 
+/// This function adds the following template functions:
+/// - `t(key, **kwargs)` - Basic translation
+/// - `tg(key, gender, **kwargs)` - Gender-aware translation
+/// - `tl(locale, key, **kwargs)` - Translation with explicit locale
+/// - `tlg(locale, key, gender, **kwargs)` - Gender-aware translation with explicit locale
+/// - `current_locale()` - Get current locale string
+/// - `has_locale(locale)` - Check if locale is supported
+/// - `plural(count, key, **kwargs)` - Pluralization support
+/// - `format_number(number, style?)` - Number formatting
+/// - `format_date(date, format?)` - Date formatting (placeholder)
+///
+/// # Arguments
+/// 
+/// * `env` - MiniJinja environment to register functions in
+///
+/// # Example
+/// 
+/// ```rust
+/// use minijinja::Environment;
+/// use smokesignal::i18n::template_helpers::register_i18n_functions;
+/// 
+/// let mut env = Environment::new();
+/// register_i18n_functions(&mut env);
+/// 
+/// // Now templates can use: {{ t('welcome') }}, {{ tg('greeting', 'masculine') }}
+/// ```
+pub fn register_i18n_functions(env: &mut Environment) {
+    // Basic translation: t(key, **kwargs)
+    env.add_function("t", move |key: String, kwargs: Kwargs| -> Result<String, Error> {
+        let default_locale = "en-us".parse::<LanguageIdentifier>().unwrap();
+        let locale = extract_locale_from_kwargs(&kwargs, &default_locale)?;
+        let fluent_args = kwargs_to_fluent_hashmap(kwargs)?;
+        
+        let result = if fluent_args.is_empty() {
+            LOCALES.lookup(&locale, &key)
+        } else {
+            LOCALES.lookup_with_args(&locale, &key, &fluent_args)
+        };
+        
+        Ok(result)
+    });
+
+    // Translation with explicit locale: tl(locale, key, **kwargs)
+    env.add_function("tl", move |locale: String, key: String, kwargs: Kwargs| -> Result<String, Error> {
+        let lang_id = locale.parse::<LanguageIdentifier>()
+            .map_err(|_| Error::new(ErrorKind::InvalidOperation, format!("Invalid locale: {}", locale)))?;
+        let fluent_args = kwargs_to_fluent_hashmap(kwargs)?;
+        
+        let result = if fluent_args.is_empty() {
+            LOCALES.lookup(&lang_id, &key)
+        } else {
+            LOCALES.lookup_with_args(&lang_id, &key, &fluent_args)
+        };
+        
+        Ok(result)
+    });
+
+    // Gender-aware translation: tg(key, gender, **kwargs)
+    env.add_function("tg", move |key: String, gender: String, kwargs: Kwargs| -> Result<String, Error> {
+        let default_locale = "en-us".parse::<LanguageIdentifier>().unwrap();
+        let locale = extract_locale_from_kwargs(&kwargs, &default_locale)?;
+        let string_args = kwargs_to_hashmap(kwargs)?;
+        let gender_enum = gender.parse::<Gender>()
+            .map_err(|_| Error::new(ErrorKind::InvalidOperation, format!("Invalid gender: {}", gender)))?;
+        
+        let args_ref = if string_args.is_empty() { None } else { Some(&string_args) };
+        let result = lookup_with_gender(&locale, &key, &gender_enum, args_ref);
+        
+        Ok(result)
+    });
+
+    // Gender-aware translation with explicit locale: tlg(locale, key, gender, **kwargs)
+    env.add_function("tlg", move |locale: String, key: String, gender: String, kwargs: Kwargs| -> Result<String, Error> {
+        let lang_id = locale.parse::<LanguageIdentifier>()
+            .map_err(|_| Error::new(ErrorKind::InvalidOperation, format!("Invalid locale: {}", locale)))?;
+        let string_args = kwargs_to_hashmap(kwargs)?;
+        let gender_enum = gender.parse::<Gender>()
+            .map_err(|_| Error::new(ErrorKind::InvalidOperation, format!("Invalid gender: {}", gender)))?;
+        
+        let args_ref = if string_args.is_empty() { None } else { Some(&string_args) };
+        let result = lookup_with_gender(&lang_id, &key, &gender_enum, args_ref);
+        
+        Ok(result)
+    });
+
+    // Get current locale: current_locale()
+    env.add_function("current_locale", move || -> String {
+        "en-us".to_string()
+    });
+
+    // Check if locale is available: has_locale(locale)
+    env.add_function("has_locale", move |locale: String| -> Result<bool, Error> {
+        let supported = get_supported_languages();
+        match locale.parse::<LanguageIdentifier>() {
+            Ok(lang_id) => Ok(supported.contains(&lang_id)),
+            Err(_) => Ok(false),
+        }
+    });
+
+    // Handle pluralization: plural(count, key, **kwargs)
+    env.add_function("plural", move |count: i64, key: String, kwargs: Kwargs| -> Result<String, Error> {
+        let default_locale = "en-us".parse::<LanguageIdentifier>().unwrap();
+        let locale = extract_locale_from_kwargs(&kwargs, &default_locale)?;
+        let mut fluent_args = kwargs_to_fluent_hashmap(kwargs)?;
+        fluent_args.insert(Cow::Borrowed("count"), FluentValue::Number(count.into()));
+        
+        let result = LOCALES.lookup_with_args(&locale, &key, &fluent_args);
+        Ok(result)
+    });
+
+    // Format number with locale: format_number(number, style?)
+    env.add_function("format_number", move |number: Value, _style: Option<String>| -> Result<String, Error> {
+        if number.is_number() {
+            if let Some(i) = number.as_i64() {
+                Ok(i.to_string())
+            } else {
+                // Try to convert to f64 via string parsing
+                let s = number.to_string();
+                if let Ok(f) = s.parse::<f64>() {
+                    Ok(format!("{:.2}", f))
+                } else {
+                    Ok(number.to_string())
+                }
+            }
+        } else {
+            Err(Error::new(ErrorKind::InvalidOperation, "Expected number for formatting"))
+        }
+    });
+
+    // Format date/time (placeholder implementation)
+    env.add_function("format_date", move |date: Value, format: Option<String>| -> Result<String, Error> {
+        if let Some(s) = date.as_str() {
+            Ok(format!("{} ({})", s, format.unwrap_or_else(|| "default".to_string())))
+        } else {
+            Err(Error::new(ErrorKind::InvalidOperation, "Expected string for date formatting"))
+        }
+    });
+}
+
+/// Extract locale from function kwargs, falling back to default
+fn extract_locale_from_kwargs(kwargs: &Kwargs, default: &LanguageIdentifier) -> Result<LanguageIdentifier, Error> {
+    if let Ok(Some(locale_str)) = kwargs.get::<Option<String>>("locale") {
+        locale_str.parse::<LanguageIdentifier>()
+            .map_err(|_| Error::new(ErrorKind::InvalidOperation, format!("Invalid locale: {}", locale_str)))
+    } else {
+        Ok(default.clone())
+    }
+}
+
+/// Convert MiniJinja kwargs to HashMap<String, String>
+fn kwargs_to_hashmap(kwargs: Kwargs) -> Result<HashMap<String, String>, Error> {
+    let mut result = HashMap::new();
+    
+    for key in kwargs.args() {
+        if key == "locale" {
+            continue; // Skip locale parameter
+        }
+        if let Ok(value) = kwargs.get::<Value>(key) {
+            result.insert(key.to_string(), value.to_string());
+        }
+    }
+    
+    Ok(result)
+}
+
+/// Convert MiniJinja kwargs to fluent-templates compatible HashMap
+fn kwargs_to_fluent_hashmap(kwargs: Kwargs) -> Result<HashMap<Cow<'static, str>, FluentValue<'static>>, Error> {
+    let mut result = HashMap::new();
+    
+    for key in kwargs.args() {
+        if key == "locale" {
+            continue; // Skip locale parameter
+        }
+        if let Ok(value) = kwargs.get::<Value>(key) {
+            let fluent_value = if let Some(s) = value.as_str() {
+                FluentValue::String(Cow::Owned(s.to_string()))
+            } else if let Some(i) = value.as_i64() {
+                FluentValue::Number(i.into())
+            } else {
+                // For floating point numbers, parse from string representation
+                let s = value.to_string();
+                if let Ok(f) = s.parse::<f64>() {
+                    FluentValue::Number(f.into())
+                } else {
+                    FluentValue::String(Cow::Owned(value.to_string()))
+                }
+            };
+            
+            result.insert(Cow::Owned(key.to_string()), fluent_value);
+        }
+    }
+    
+    Ok(result)
+}
+
+/// Perform gender-aware lookup using our gender module
+fn lookup_with_gender(
+    locale: &LanguageIdentifier, 
+    key: &str, 
+    gender: &Gender, 
+    args: Option<&HashMap<String, String>>
+) -> String {
+    // Use our gender-aware lookup from the gender module
+    crate::i18n::gender::get_gendered_translation(locale, key, *gender, args.cloned())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use minijinja::{Environment, context};
+
+    #[test]
+    fn test_template_function_registration() {
+        let mut env = Environment::new();
+        
+        register_i18n_functions(&mut env);
+        
+        // Test that functions are registered by attempting to compile expressions that use them
+        assert!(env.compile_expression("current_locale()").is_ok());
+        assert!(env.compile_expression("has_locale('en-us')").is_ok());
+        assert!(env.compile_expression("t('test')").is_ok());
+        assert!(env.compile_expression("tl('en-us', 'test')").is_ok());
+    }
+
+    #[test]
+    fn test_current_locale_function() {
+        let mut env = Environment::new();
+        
+        register_i18n_functions(&mut env);
+        
+        let tmpl = env.compile_expression("current_locale()").unwrap();
+        let result = tmpl.eval(context!()).unwrap();
+        assert_eq!(result.as_str().unwrap(), "en-us");
+    }
+
+    #[test]
+    fn test_has_locale_function() {
+        let mut env = Environment::new();
+        
+        register_i18n_functions(&mut env);
+        
+        let tmpl = env.compile_expression("has_locale('en-us')").unwrap();
+        let result = tmpl.eval(context!()).unwrap();
+        assert!(result.is_true());
+        
+        let tmpl = env.compile_expression("has_locale('invalid-locale')").unwrap();
+        let result = tmpl.eval(context!()).unwrap();
+        assert!(!result.is_true());
+    }
+
+    #[test]
+    fn test_gender_aware_translation_function() {
+        let mut env = Environment::new();
+        
+        register_i18n_functions(&mut env);
+        
+        // Test gender-aware translation function registration
+        assert!(env.compile_expression("tg('test', 'masculine')").is_ok());
+        assert!(env.compile_expression("tg('test', 'feminine')").is_ok());
+        assert!(env.compile_expression("tg('test', 'neutral')").is_ok());
+        assert!(env.compile_expression("tlg('en-us', 'test', 'masculine')").is_ok());
+    }
+
+    #[test]
+    fn test_translation_with_args() {
+        let mut env = Environment::new();
+        
+        register_i18n_functions(&mut env);
+        
+        // Test that translation functions can accept kwargs
+        assert!(env.compile_expression("t('test', name='Alice')").is_ok());
+        assert!(env.compile_expression("tg('test', 'masculine', name='Bob')").is_ok());
+    }
+
+    #[test]
+    fn test_number_formatting() {
+        let mut env = Environment::new();
+        
+        register_i18n_functions(&mut env);
+        
+        let tmpl = env.compile_expression("format_number(1234)").unwrap();
+        let result = tmpl.eval(context!()).unwrap();
+        assert_eq!(result.as_str().unwrap(), "1234");
+        
+        let tmpl = env.compile_expression("format_number(12.34)").unwrap();
+        let result = tmpl.eval(context!()).unwrap();
+        assert_eq!(result.as_str().unwrap(), "12.34");
+    }
+
+    #[test]
+    fn test_pluralization() {
+        let mut env = Environment::new();
+        
+        register_i18n_functions(&mut env);
+        
+        // Test that pluralization function compiles
+        assert!(env.compile_expression("plural(1, 'items')").is_ok());
+        assert!(env.compile_expression("plural(5, 'items', item='books')").is_ok());
+    }
+}

src/lib.rs

···
 pub mod errors;
 pub mod http;
 pub mod i18n;
+// Keeping old i18n module for compatibility during migration
+pub mod i18n_old;
 pub mod jose;
 pub mod jose_errors;
 pub mod oauth;