diff --git a/config/reference.toml b/config/reference.toml
deleted file mode 100644
index c94cb4cc..00000000
--- a/config/reference.toml
+++ /dev/null
@@ -1,149 +0,0 @@
-# ==================================================================================================
-# Referencia de opciones de configuración de PageTop y sus extensiones.
-#
-# Este fichero NO se carga: sólo documenta todas las opciones disponibles con su valor por defecto.
-# Para usarlas, copia las que necesites en alguno de los ficheros de la cascada de configuración,
-# que se aplican en este orden (cada uno sobrescribe al anterior):
-#
-#   1. config/common.toml         -> ajustes comunes a todos los entornos.
-#   2. config/{rm}.toml           -> ajustes del modo de ejecución (p. ej. default.toml).
-#   3. config/local.{rm}.toml     -> ajustes locales del modo de ejecución (no se versiona).
-#   4. config/local.toml          -> ajustes locales para cualquier entorno (no se versiona).
-#
-# Donde {rm} es el valor de la variable de entorno PAGETOP_RUN_MODE ("default" si no se define).
-# El directorio config/ puede cambiarse con la variable de entorno CONFIG_DIR. No hay más
-# variables de entorno: el resto de opciones sólo se leen de estos ficheros.
-#
-# Las opciones comentadas no tienen valor por defecto; se muestran con un valor de ejemplo.
-# ==================================================================================================
-
-
-# **< PageTop (núcleo) >****************************************************************************
-
-[app]
-name              = "PageTop App"   # Nombre de la aplicación.
-theme             = "Basic"         # Tema predeterminado: "Basic" o el de una extensión enlazada
-                                    # por la aplicación ("Aliner", "Bootsier"...).
-#language         = "es-ES"         # Idioma predeterminado (BCP 47: "es-ES", "en-US"...). Sin
-                                    # valor, o si no es válido, el idioma se negocia con otras
-                                    # fuentes (cabecera Accept-Language, idioma de respaldo).
-lang_negotiation  = "Full"          # Estrategia para resolver el idioma de cada petición:
-                                    #   "Full"       -> ?lang de la URL, idioma del usuario,
-                                    #                   'language', Accept-Language y respaldo.
-                                    #   "NoQuery"    -> igual que "Full" pero sin ?lang.
-                                    #   "ConfigOnly" -> sólo 'language' o el idioma de respaldo
-                                    #                   (no se ofrece elegir idioma al usuario).
-timezone          = "UTC"           # Zona horaria del sitio (IANA: "UTC", "Europe/Madrid"...);
-                                    # da igual escribirla en mayúsculas o minúsculas.
-                                    # Se aplica a anónimos y a usuarios sin zona horaria propia,
-                                    # y a todos si 'timezone_per_user' es false.
-timezone_regions  = ""              # Regiones de zonas horarias que se ofrecen, separadas por
-                                    # comas (p. ej. "Europe, America"): "Africa", "America",
-                                    # "Antarctica", "Arctic", "Asia", "Atlantic", "Australia",
-                                    # "Europe", "Indian" y "Pacific". "Etc" (Etc/UTC) se ofrece
-                                    # siempre. Vacío -> todas. Los nombres desconocidos se ignoran
-                                    # con un aviso al arrancar. No cambia las zonas ya asignadas a
-                                    # los usuarios (las conservan), sólo las nuevas elecciones.
-                                    # Es el valor por defecto del selector de zona horaria; la
-                                    # aplicación puede cambiarlo en un formulario concreto.
-timezone_order    = "Nearest"       # Orden de esas regiones al elegir zona horaria:
-                                    #   "Nearest"      -> la del sitio primero, si tiene región, y
-                                    #                     luego por cercanía de su desfase horario.
-                                    #   "Alphabetical" -> por el nombre de la región traducido al
-                                    #                     idioma de la página.
-                                    #   "Listed"       -> en el orden de 'timezone_regions' (sin
-                                    #                     regiones, como "Alphabetical").
-                                    # Es el valor por defecto del selector de zona horaria; la
-                                    # aplicación puede cambiarlo en un formulario concreto.
-timezone_per_user = true            # Si cada usuario puede tener su propia zona horaria (true) o
-                                    # se usa siempre 'timezone' (false). Con false no se ofrece
-                                    # elegirla y la guardada se conserva por si se reactiva.
-startup_banner    = "Slant"         # Banner ASCII al arrancar: "Off", "Slant", "Small", "Speed"
-                                    # o "Starwars".
-
-[dev]
-pagetop_static_dir = ""             # Directorio static/ de PageTop para servir sus archivos
-                                    # estáticos desde disco (editables sin recompilar). Ruta
-                                    # absoluta o relativa al proyecto o al binario. Vacío -> se
-                                    # sirven los incluidos en el binario.
-bootsier_static_dir = ""            # Igual que el anterior, para los archivos estáticos de
-                                    # pagetop-bootsier.
-
-[log]
-enabled = true                      # Activa (true) o desactiva (false) las trazas.
-tracing = "Info"                    # Filtro de trazas: "Error", "Warn", "Info", "Debug" o
-                                    # "Trace", o combinaciones separadas por comas por módulo,
-                                    # p. ej. "Info,pagetop=Debug,sqlx=Warn".
-rolling = "Stdout"                  # Salida de las trazas:
-                                    #   "Stdout"   -> terminal, sin archivos.
-                                    #   "Daily", "Hourly", "Minutely" -> archivos con rotación.
-                                    #   "Endless"  -> un único archivo, sin rotación.
-path    = "log"                     # Directorio de los archivos de traza (si rolling != Stdout).
-prefix  = "tracing.log"             # Prefijo de los archivos de traza (si rolling != Stdout).
-format  = "Full"                    # Formato: "Full", "Compact", "Pretty" o "Json".
-
-[server]
-bind_address = "localhost"          # Dirección de enlace del servidor web.
-bind_port    = 8080                 # Puerto de escucha del servidor web.
-
-
-# **< pagetop-seaorm >******************************************************************************
-
-[database]
-db_type       = ""                  # Motor: "mysql" (o "mariadb"), "postgres" (o "postgresql")
-                                    # o "sqlite". Obligatorio: sin él la aplicación no arranca.
-db_name       = ""                  # Nombre (mysql/postgres) o referencia (sqlite) de la BD.
-db_user       = ""                  # Usuario de conexión (mysql/postgres).
-db_pass       = ""                  # Contraseña de conexión (mysql/postgres).
-db_host       = "localhost"         # Servidor de la base de datos (mysql/postgres).
-#db_port      = 5432                # Puerto (mysql/postgres). Sin valor -> 3306 para MySQL y
-                                    # 5432 para PostgreSQL.
-max_pool_size = 5                   # Número máximo de conexiones simultáneas.
-
-
-# **< pagetop-user >********************************************************************************
-
-[user]
-allow_registration         = true   # Permite que los visitantes creen su propia cuenta.
-require_email_verification = false  # Las cuentas nuevas quedan pendientes ("Pending") en lugar
-                                    # de activas hasta verificar el correo.
-
-session_cookie_name   = "pgt_session" # Nombre de la cookie de sesión.
-session_ttl_secs      = 1209600     # Duración de la sesión en segundos si se marca "recordarme"
-                                    # al acceder (14 días).
-session_idle_ttl_secs = 7200        # Duración de la sesión en segundos sin "recordarme" (2
-                                    # horas). Se cuenta desde el acceso, no desde la última
-                                    # actividad.
-secure_cookie         = false       # Marca la cookie como Secure (sólo HTTPS). Activar en
-                                    # producción.
-
-max_failed_logins        = 5        # Intentos fallidos de acceso antes de bloquear la cuenta.
-failed_login_window_secs = 900      # Ventana de recuento de intentos fallidos (15 minutos).
-                                    # Reservada: todavía no tiene efecto.
-locked_for_secs          = 600      # Duración del bloqueo de la cuenta en segundos (10 minutos).
-
-login_strict = false                # Dificulta que el navegador recuerde o autorrellene las
-                                    # credenciales en el formulario de acceso.
-
-[user.password]                     # Contraseñas, cifradas con Argon2id.
-argon2_m_cost = 19456               # Coste de memoria en KiB. Si cambia, las contraseñas se
-                                    # vuelven a cifrar en el siguiente acceso de cada usuario.
-argon2_t_cost = 2                   # Coste de tiempo (número de iteraciones).
-argon2_p_cost = 1                   # Grado de paralelismo (número de hilos).
-min_length    = 8                   # Longitud mínima de las contraseñas.
-
-[user.seed]                         # Primer administrador, creado si no existe ningún usuario.
-admin_username  = "admin"           # Nombre de usuario.
-admin_email     = "admin@example.com" # Correo electrónico.
-#admin_password = "cambiar"         # Contraseña. Sin valor -> se genera una aleatoria y se
-                                    # muestra una sola vez por la salida estándar al crearlo.
-
-[user.admin]
-list_page_size = 20                 # Filas por página en los listados de administración
-                                    # (usuarios, roles...).
-
-
-# **< pagetop-bootsier >****************************************************************************
-
-[bootsier]
-max_width = "1440px"                # Ancho máximo de la página ("100%", "90rem", "1440px"...).
diff --git a/extensions/pagetop-user/src/component/admin/user_form.rs b/extensions/pagetop-user/src/component/admin/user_form.rs
index 9795bb08..0f50aee5 100644
--- a/extensions/pagetop-user/src/component/admin/user_form.rs
+++ b/extensions/pagetop-user/src/component/admin/user_form.rs
@@ -3,7 +3,6 @@
 use pagetop::prelude::*;
 
 use crate::LOCALES_USER;
-use crate::config::{user_language_applies, user_timezone_applies};
 use crate::user_path;
 use crate::{ADMIN_USERS_PATH, PROFILE_EDIT_PATH};
 
@@ -87,33 +86,25 @@ impl Component for UserForm {
                     .with_name("display_name")
                     .with_value(self.display_name())
                     .with_label(Lc::t("field-display-name", &LOCALES_USER)),
-            );
-
-        // Sólo se ofrecen si se aplican (ver `config::user_language_applies()` y
-        // `config::user_timezone_applies()`).
-        if user_language_applies() {
-            form = form.with_child(
+            )
+            .with_child(
                 form::SelectLanguage::new()
                     .with_name("language")
                     .with_label(Lc::t("field-language", &LOCALES_USER))
                     .with_selected(self.language()),
-            );
-        }
-        if user_timezone_applies() {
-            form = form.with_child(
+            )
+            .with_child(
                 form::SelectTimezone::new()
                     .with_name("timezone")
                     .with_label(Lc::t("field-timezone", &LOCALES_USER))
-                    .with_utc_offset(true)
                     .with_selected(self.timezone()),
+            )
+            .with_child(
+                form::SelectTheme::new()
+                    .with_name("theme")
+                    .with_label(Lc::t("field-theme", &LOCALES_USER))
+                    .with_selected(self.theme()),
             );
-        }
-        form = form.with_child(
-            form::SelectTheme::new()
-                .with_name("theme")
-                .with_label(Lc::t("field-theme", &LOCALES_USER))
-                .with_selected(self.theme()),
-        );
 
         if *self.mode() == UserFormMode::New {
             form = form.with_child(PasswordConfirm::new());
diff --git a/extensions/pagetop-user/src/config.rs b/extensions/pagetop-user/src/config.rs
index 5975c638..f1922d86 100644
--- a/extensions/pagetop-user/src/config.rs
+++ b/extensions/pagetop-user/src/config.rs
@@ -134,17 +134,3 @@ impl Default for AdminConfig {
         AdminConfig { list_page_size: 20 }
     }
 }
-
-// **< Preferencias del usuario >*******************************************************************
-
-// Si se aplica el idioma propio del usuario: no con `lang_negotiation = "ConfigOnly"`, que usa
-// siempre el de la configuración. Si no se aplica, no se ofrece elegirlo ni se borra el guardado.
-pub(crate) fn user_language_applies() -> bool {
-    global::SETTINGS.app.lang_negotiation != global::LangNegotiation::ConfigOnly
-}
-
-// Si se aplica la zona horaria propia del usuario (`app.timezone_per_user`). Si no se aplica, no se
-// ofrece elegirla ni se borra la guardada.
-pub(crate) fn user_timezone_applies() -> bool {
-    global::SETTINGS.app.timezone_per_user
-}
diff --git a/extensions/pagetop-user/src/handlers/account.rs b/extensions/pagetop-user/src/handlers/account.rs
index 241db472..d92876d9 100644
--- a/extensions/pagetop-user/src/handlers/account.rs
+++ b/extensions/pagetop-user/src/handlers/account.rs
@@ -9,7 +9,6 @@ use crate::account::{Account, UserStatus};
 use crate::auth;
 use crate::component::admin::{UserForm, UserFormMode, status_key};
 use crate::component::{ChangePasswordForm, language_name, multiline_text, theme_name};
-use crate::config::{user_language_applies, user_timezone_applies};
 use crate::entity::{role, user};
 use crate::error::AuthError;
 use crate::handlers::admin::map_auth_error;
@@ -120,23 +119,17 @@ async fn profile_details(user: &user::Model, status: UserStatus, cx: &mut Contex
                 .with_cell(multiline_text(
                     user.about.clone().unwrap_or_else(|| "-".into()),
                 )),
-        );
-    // Sólo se muestran si se aplican, igual que en el formulario de edición.
-    if user_language_applies() {
-        table = table.with_row(
+        )
+        .with_row(
             table::Row::new()
                 .with_cell(Lc::t("field-language", &LOCALES_USER))
                 .with_cell(language_name(user.language.as_deref())),
-        );
-    }
-    if user_timezone_applies() {
-        table = table.with_row(
+        )
+        .with_row(
             table::Row::new()
                 .with_cell(Lc::t("field-timezone", &LOCALES_USER))
                 .with_cell(user.timezone.as_deref().unwrap_or("-")),
-        );
-    }
-    table = table
+        )
         .with_row(
             table::Row::new()
                 .with_cell(Lc::t("field-theme", &LOCALES_USER))
diff --git a/extensions/pagetop-user/src/handlers/admin/users.rs b/extensions/pagetop-user/src/handlers/admin/users.rs
index ce8fbeda..dfee0f98 100644
--- a/extensions/pagetop-user/src/handlers/admin/users.rs
+++ b/extensions/pagetop-user/src/handlers/admin/users.rs
@@ -14,7 +14,7 @@ use crate::component::admin::{
     AdminPasswordForm, USER_ADMIN_FORM_ID, UserForm, UserFormMode, UserTable, status_key,
 };
 use crate::component::{language_name, multiline_text, theme_name};
-use crate::config::{SETTINGS, user_language_applies, user_timezone_applies};
+use crate::config::SETTINGS;
 use crate::entity::{role, user};
 use crate::error::AuthError;
 use crate::handlers::admin::{back_link, frame, map_auth_error};
@@ -589,23 +589,17 @@ async fn user_view_details(user: &user::Model, status: UserStatus, cx: &mut Cont
                 .with_cell(multiline_text(
                     user.about.clone().unwrap_or_else(|| "-".into()),
                 )),
-        );
-    // Sólo se muestran si se aplican, igual que en el formulario de edición.
-    if user_language_applies() {
-        table = table.with_row(
+        )
+        .with_row(
             table::Row::new()
                 .with_cell(Lc::t("field-language", &LOCALES_USER))
                 .with_cell(language_name(user.language.as_deref())),
-        );
-    }
-    if user_timezone_applies() {
-        table = table.with_row(
+        )
+        .with_row(
             table::Row::new()
                 .with_cell(Lc::t("field-timezone", &LOCALES_USER))
                 .with_cell(user.timezone.as_deref().unwrap_or("-")),
-        );
-    }
-    table = table
+        )
         .with_row(
             table::Row::new()
                 .with_cell(Lc::t("field-theme", &LOCALES_USER))
diff --git a/extensions/pagetop-user/src/service/user_admin.rs b/extensions/pagetop-user/src/service/user_admin.rs
index 1dde30a9..d2520f4f 100644
--- a/extensions/pagetop-user/src/service/user_admin.rs
+++ b/extensions/pagetop-user/src/service/user_admin.rs
@@ -10,7 +10,6 @@ use pagetop_seaorm::db::{
 };
 
 use crate::account::UserStatus;
-use crate::config::{user_language_applies, user_timezone_applies};
 use crate::entity::{role, user, user_role};
 use crate::error::AuthError;
 use crate::password;
@@ -175,18 +174,8 @@ pub(crate) struct NewUserData<'a> {
 pub(crate) async fn create_user(data: NewUserData<'_>) -> Result<i32, AuthError> {
     password::validate_strength(data.password)?;
     password::passwords_match(data.password, data.confirm_password)?;
-    // El idioma y la zona horaria que no se aplican no se ofrecen en el formulario: se ignora lo
-    // que pudiera llegar y el usuario se crea sin ellos.
-    let language = if user_language_applies() {
-        validate_language(data.language)?
-    } else {
-        None
-    };
-    let timezone = if user_timezone_applies() {
-        validate_timezone(data.timezone)?
-    } else {
-        None
-    };
+    let language = validate_language(data.language)?;
+    let timezone = validate_timezone(data.timezone)?;
     let theme = validate_theme(data.theme)?;
     ensure_username_available(data.username, None).await?;
     ensure_email_available(data.email, None).await?;
@@ -241,24 +230,8 @@ pub(crate) struct UserUpdateData<'a> {
 }
 
 pub(crate) async fn update_user(user_id: i32, data: UserUpdateData<'_>) -> Result<(), AuthError> {
-    // El idioma y la zona horaria que no se aplican tampoco se ofrecen en el formulario, así que no
-    // llegan: se conserva lo guardado por si se vuelven a aplicar.
-    let language = if user_language_applies() {
-        Set(validate_language(data.language)?.map(str::to_owned))
-    } else {
-        ActiveValue::NotSet
-    };
-    let timezone = if user_timezone_applies() {
-        let timezone = match validate_timezone(data.timezone) {
-            Err(AuthError::InvalidTimezone) => {
-                keep_current_timezone(user_id, data.timezone).await?
-            }
-            result => result?,
-        };
-        Set(timezone.map(str::to_owned))
-    } else {
-        ActiveValue::NotSet
-    };
+    let language = validate_language(data.language)?;
+    let timezone = validate_timezone(data.timezone)?;
     let theme = validate_theme(data.theme)?;
     // El navegador envía los saltos de línea de un `<textarea>` como `\r\n`, pero `maxlength` puede
     // contarlos como un único carácter: se normalizan antes de medir para no rechazar un texto que
@@ -281,8 +254,8 @@ pub(crate) async fn update_user(user_id: i32, data: UserUpdateData<'_>) -> Resul
         email: Set(data.email.to_owned()),
         display_name: Set(data.display_name.map(str::to_owned)),
         about: Set(about),
-        language,
-        timezone,
+        language: Set(language.map(str::to_owned)),
+        timezone: Set(timezone.map(str::to_owned)),
         theme: Set(theme.map(str::to_owned)),
         updated_at: Set(now),
         ..Default::default()
@@ -475,22 +448,6 @@ fn validate_timezone(timezone: Option<&str>) -> Result<Option<&str>, AuthError>
     Ok(timezone)
 }
 
-// Acepta una zona que ya no se ofrece si es la que el usuario tenía guardada: el selector la sigue
-// mostrando para que volver a guardar el formulario sin tocarla no la descarte. Sólo se consulta la
-// base de datos cuando la zona recibida no se ofrece.
-async fn keep_current_timezone(
-    user_id: i32,
-    timezone: Option<&str>,
-) -> Result<Option<&str>, AuthError> {
-    let timezone = timezone.and_then(util::non_blank);
-    let current = find_user(user_id).await?.timezone;
-    if timezone.is_some() && timezone == current.as_deref() {
-        Ok(timezone)
-    } else {
-        Err(AuthError::InvalidTimezone)
-    }
-}
-
 async fn ensure_username_available(
     username: &str,
     exclude_id: Option<i32>,
diff --git a/src/app.rs b/src/app.rs
index 5f4ef938..061c1b2e 100644
--- a/src/app.rs
+++ b/src/app.rs
@@ -64,7 +64,7 @@ impl Application {
         // Inicializa el idioma predeterminado.
         Locale::init();
 
-        // Inicializa la zona horaria predeterminada y las regiones para elegir.
+        // Inicializa la zona horaria predeterminada.
         Timezone::init();
 
         // Registra las extensiones de la aplicación.
diff --git a/src/auth.rs b/src/auth.rs
index 30161f02..b748d1c8 100644
--- a/src/auth.rs
+++ b/src/auth.rs
@@ -22,7 +22,7 @@ use crate::datetime::{Timezone, Tz};
 use crate::locale::{LanguageIdentifier, Lc, Locale};
 use crate::response::ErrorPage;
 use crate::web::HttpRequest;
-use crate::{AutoDefault, CowStr, Getters, Weight, builder_impl, global};
+use crate::{AutoDefault, CowStr, Getters, Weight, builder_impl};
 
 use std::ops::ControlFlow;
 
@@ -149,21 +149,16 @@ impl CurrentUser {
 
     /// Devuelve la zona horaria efectiva del usuario.
     ///
-    /// Devuelve su zona horaria si tiene una y [`global::SETTINGS.app.timezone_per_user`] lo
-    /// permite; en otro caso, devuelve [`Timezone::default_tz()`].
+    /// Devuelve la suya si tiene una; en otro caso, devuelve [`Timezone::default_tz()`].
     ///
     /// Normalmente se resuelve una sola vez, al construir el [`Context`] de la petición. A partir
     /// de ese momento el renderizado del documento no vuelve a llamarlo porque usa el valor ya
     /// resuelto vía [`Contextual::timezone()`].
     ///
-    /// [`global::SETTINGS.app.timezone_per_user`]: crate::global::App::timezone_per_user
     /// [`Context`]: crate::core::component::Context
     /// [`Contextual::timezone()`]: crate::core::component::Contextual::timezone
     pub fn timezone(&self) -> Tz {
-        match self.timezone {
-            Some(tz) if global::SETTINGS.app.timezone_per_user => tz,
-            _ => Timezone::default_tz(),
-        }
+        self.timezone.unwrap_or_else(Timezone::default_tz)
     }
 }
 
diff --git a/src/base/component/form/select_language.rs b/src/base/component/form/select_language.rs
index 6f8b283a..f2743c1b 100644
--- a/src/base/component/form/select_language.rs
+++ b/src/base/component/form/select_language.rs
@@ -3,10 +3,8 @@ use crate::prelude::*;
 /// Componente para **elegir un idioma** de la lista de idiomas soportados por PageTop.
 ///
 /// Ofrece un elemento por cada idioma de [`Locale::supported_languages()`], con su identificador
-/// como valor (p. ej. `"es-ES"`) y su nombre escrito en ese mismo idioma como etiqueta (p. ej.
-/// *"Español (España)"* o *"English (United States)"*), sea cual sea el idioma de la página; así
-/// cualquiera reconoce el suyo aunque no entienda el de la página. Se ordenan por ese nombre, sin
-/// distinguir mayúsculas ni acentos. Se renderiza como cualquier [`form::select::Field`].
+/// como valor (p. ej. `"es-ES"`) y su nombre traducido como etiqueta, ordenados por ese nombre en
+/// el idioma de la página. Se renderiza como cualquier [`form::select::Field`].
 ///
 /// La primera opción, con valor vacío, depende de si el campo es obligatorio:
 ///
@@ -48,16 +46,8 @@ impl Component for SelectLanguage {
 
     async fn prepare(&self, cx: &mut Context) -> Result<Markup, ComponentError> {
         let mut field = self.field().clone();
-        let mut languages: Vec<_> = Locale::supported_languages()
-            .into_iter()
-            .map(|(langid, name)| {
-                let own = name
-                    .lookup(&Locale::Resolved(langid))
-                    .unwrap_or_else(|| langid.to_string());
-                (langid, own)
-            })
-            .collect();
-        languages.sort_by_cached_key(|(_, name)| Lc::n(name.clone()).collation_key(&*cx));
+        let mut languages = Locale::supported_languages();
+        languages.sort_by_cached_key(|(_, name)| name.collation_key(&*cx));
 
         let selected = Locale::resolve(self.selected()).as_option();
         let known = selected.is_some();
@@ -66,7 +56,8 @@ impl Component for SelectLanguage {
             let default_name = languages
                 .iter()
                 .find(|(langid, _)| *langid == default_langid)
-                .map_or_else(|| default_langid.to_string(), |(_, name)| name.clone());
+                .and_then(|(_, name)| name.lookup(cx))
+                .unwrap_or_else(|| default_langid.to_string());
             let label = Lc::l("select_language_site_default").with_arg("language", default_name);
             field.alter_item(form::select::Item::new("", label).with_selected(!known));
         } else if !known {
@@ -75,7 +66,7 @@ impl Component for SelectLanguage {
         }
 
         for (langid, name) in languages {
-            let item = form::select::Item::new(langid.to_string(), Lc::n(name));
+            let item = form::select::Item::new(langid.to_string(), name);
             field.alter_item(item.with_selected(selected == Some(langid)));
         }
         Ok(field.render(cx).await)
diff --git a/src/base/component/form/select_timezone.rs b/src/base/component/form/select_timezone.rs
index 3a75a3ce..5064d9b2 100644
--- a/src/base/component/form/select_timezone.rs
+++ b/src/base/component/form/select_timezone.rs
@@ -1,45 +1,21 @@
 use crate::prelude::*;
 
-use chrono::Offset;
-
 /// Componente para crear una **lista de selección de zonas horarias** IANA.
 ///
-/// Ofrece zonas horarias agrupadas por región, con el nombre de la región traducido (*"Europa"*,
-/// *"América"*, etc.). Cada opción tiene como valor el nombre IANA completo (p. ej.
-/// `"America/New_York"`) y como etiqueta ese mismo nombre con espacios en lugar de guiones bajos
-/// (p. ej. `"America/New York"`). No admite opciones libres. Se renderiza como cualquier
-/// [`form::select::Field`]. Con [`with_utc_offset(true)`] cada etiqueta añade además el desfase
-/// actual respecto a UTC (p. ej. `"America/New York (UTC-05:00)"`) y las zonas de cada región se
-/// ordenan por ese desfase y, a igual desfase, por nombre.
-///
-/// Por defecto ofrece las regiones y el orden de la configuración, los mismos que
-/// [`Timezone::supported_by_region()`]; [`with_regions()`] y [`with_order()`] permiten cambiarlos
-/// para este componente. Cuando las regiones se ordenan por nombre (con
-/// [`TimezoneOrder::Alphabetical`], o [`TimezoneOrder::Listed`] sin regiones), se ordenan por su
-/// nombre traducido al idioma de la página, sin distinguir mayúsculas ni acentos, y *"Otras"*
-/// (`Etc/UTC`) sigue al final.
+/// Ofrece las zonas horarias de [`Timezone::supported_by_region()`] agrupadas por región, con el
+/// nombre de la región traducido (*"Europa"*, *"América"*...) y el nombre IANA completo como valor
+/// y como etiqueta (p. ej. `"Europe/Madrid"`). No admite opciones libres. Se renderiza como
+/// cualquier [`form::select::Field`].
 ///
 /// La primera opción, con valor vacío, depende de si el campo es obligatorio:
 ///
 /// - Si no lo es (por defecto), siempre se incluye y propone usar la zona horaria del sitio.
 ///   Quedarse sin zona propia es válido y significa usar la predeterminada de la aplicación. Se
-///   selecciona cuando el valor elegido no es ninguna zona horaria válida.
-/// - Si lo es ([`with_required(true)`]), sólo se incluye cuando el valor seleccionado no es ninguna
-///   zona horaria válida, y pide elegir una; así el navegador no deja enviar el formulario sin
-///   elegir una zona horaria.
-///
-/// Si el valor seleccionado es una zona horaria válida que no se ofrece (p. ej. de una región que
-/// se ha dejado de ofrecer después de elegirla), se muestra igualmente, seleccionada, en un grupo
-/// *"Zona horaria actual"* antes de las regiones; así volver a guardar el formulario sin tocarla no
-/// la descarta.
-///
-/// El valor recibido debe validarse igualmente en el servidor: con
-/// [`Timezone::supported_by_region()`] si se usan las regiones de la configuración, o con
-/// [`Timezone::is_supported_in()`] si se han cambiado; y aceptando además, sin cambios, el valor
-/// que ya estuviera guardado aunque no se ofrezca.
-///
-/// Si [`global::SETTINGS.app.timezone_per_user`] es *false*, la zona horaria propia del usuario no
-/// se aplica y no conviene mostrar este campo.
+///   selecciona cuando el valor elegido no corresponde a ninguna zona de la lista.
+/// - Si lo es ([`with_required(true)`](Self::with_required)), sólo se incluye cuando el valor
+///   seleccionado no corresponde a ninguna zona de la lista, y pide elegir una; así el navegador no
+///   deja enviar el formulario sin elegir una zona horaria. El valor recibido debe validarse
+///   igualmente en el servidor.
 ///
 /// # Ejemplo
 ///
@@ -50,14 +26,6 @@ use chrono::Offset;
 ///     .with_label(Lc::n("Time zone"))
 ///     .with_selected("Europe/Madrid");
 /// ```
-///
-/// [`TimezoneOrder::Alphabetical`]: crate::global::TimezoneOrder::Alphabetical
-/// [`TimezoneOrder::Listed`]: crate::global::TimezoneOrder::Listed
-/// [`global::SETTINGS.app.timezone_per_user`]: crate::global::App::timezone_per_user
-/// [`with_utc_offset(true)`]: Self::with_utc_offset
-/// [`with_required(true)`]: Self::with_required
-/// [`with_regions()`]: Self::with_regions
-/// [`with_order()`]: Self::with_order
 #[derive(AutoDefault, Clone, Debug, Getters)]
 pub struct SelectTimezone {
     /// Devuelve la lista de selección interna con la configuración común (nombre, etiqueta, ayuda,
@@ -65,16 +33,6 @@ pub struct SelectTimezone {
     field: form::select::Field,
     /// Devuelve el nombre IANA de la zona horaria seleccionada.
     selected: String,
-    /// Devuelve si las etiquetas muestran el desfase actual respecto a UTC.
-    utc_offset: bool,
-    /// Devuelve las regiones que se ofrecen, junto a `Etc`, que se ofrece siempre; por defecto, las
-    /// de [`global::SETTINGS.app.timezone_regions`](crate::global::App::timezone_regions).
-    #[default(_code = "Timezone::configured_regions()")]
-    regions: Vec<TzRegion>,
-    /// Devuelve el orden de las regiones; por defecto, el de
-    /// [`global::SETTINGS.app.timezone_order`](crate::global::App::timezone_order).
-    #[default(_code = "global::SETTINGS.app.timezone_order")]
-    order: global::TimezoneOrder,
 }
 
 #[async_trait]
@@ -89,61 +47,37 @@ impl Component for SelectTimezone {
 
     async fn prepare(&self, cx: &mut Context) -> Result<Markup, ComponentError> {
         let mut field = self.field().clone();
-        let regions = Timezone::regions_with(*self.order(), self.regions());
-        let offered = regions
+        let regions = Timezone::supported_by_region();
+        let known = regions
             .iter()
             .any(|(_, names)| names.contains(&self.selected()));
-        // Una zona válida que no se ofrece (p. ej. de una región retirada después) se muestra igual
-        // para que guardar el formulario sin tocarla no la descarte.
-        let current = (!offered)
-            .then(|| self.selected().parse::<Tz>().ok())
-            .flatten();
-        let known = offered || current.is_some();
-        // El desfase se calcula en cada renderizado porque cambia con el horario de verano.
-        let now = Utc::now();
-        let offset = |name: &str| {
-            self.utc_offset()
-                .then(|| name.parse::<Tz>().ok())
-                .flatten()
-                .map(|tz| now.with_timezone(&tz).offset().fix().local_minus_utc())
-        };
         if !field.required() {
-            let site = Timezone::default_tz().name();
             let label = Lc::l("select_timezone_site_default")
-                .with_arg("timezone", zone_label(zone_name(site), offset(site)));
+                .with_arg("timezone", Timezone::default_tz().name());
             field.alter_item(form::select::Item::new("", label).with_selected(!known));
         } else if !known {
             let label = Lc::l("select_timezone_placeholder");
             field.alter_item(form::select::Item::new("", label).with_selected(true));
         }
-        if let Some(tz) = current {
-            let name = tz.name();
-            let mut group = form::select::Group::new(Lc::l("select_timezone_current"));
-            group.alter_item(
-                form::select::Item::new(name, Lc::n(zone_label(zone_name(name), offset(name))))
-                    .with_selected(true),
-            );
-            field.alter_group(group);
-        }
-        let mut groups: Vec<_> = regions
-            .iter()
-            .map(|(region, names)| (*region, region.label(), names))
-            .collect();
-        if Timezone::regions_by_name(*self.order(), self.regions()) {
-            sort_by_label(&mut groups, cx);
-        }
-        for (_, label, names) in groups {
-            let mut group = form::select::Group::new(label);
-            let mut zones: Vec<_> = names.iter().map(|name| (offset(name), *name)).collect();
-            // Ordenación estable: a igual desfase, se mantienen ordenadas por nombre.
-            if *self.utc_offset() {
-                zones.sort_by_key(|(offset, _)| *offset);
-            }
-            for (offset, name) in zones {
-                let selected = name == self.selected();
+        for (region, names) in regions {
+            let mut group = form::select::Group::new(match *region {
+                "Africa" => Lc::l("timezone_region_africa"),
+                "America" => Lc::l("timezone_region_america"),
+                "Antarctica" => Lc::l("timezone_region_antarctica"),
+                "Arctic" => Lc::l("timezone_region_arctic"),
+                "Asia" => Lc::l("timezone_region_asia"),
+                "Atlantic" => Lc::l("timezone_region_atlantic"),
+                "Australia" => Lc::l("timezone_region_australia"),
+                "Etc" => Lc::l("timezone_region_etc"),
+                "Europe" => Lc::l("timezone_region_europe"),
+                "Indian" => Lc::l("timezone_region_indian"),
+                "Pacific" => Lc::l("timezone_region_pacific"),
+                _ => Lc::n(*region),
+            });
+            for name in names {
+                let selected = *name == self.selected();
                 group.alter_item(
-                    form::select::Item::new(name, Lc::n(zone_label(zone_name(name), offset)))
-                        .with_selected(selected),
+                    form::select::Item::new(*name, Lc::n(*name)).with_selected(selected),
                 );
             }
             field.alter_group(group);
@@ -152,35 +86,6 @@ impl Component for SelectTimezone {
     }
 }
 
-// Ordena las regiones por su nombre traducido al idioma dado, sin distinguir mayúsculas ni acentos
-// (`Lc::collation_key()`); `Etc` sigue al final, como en `supported_by_region()`.
-fn sort_by_label<T>(groups: &mut [(TzRegion, Lc, T)], language: &impl LangId) {
-    groups.sort_by_cached_key(|(region, label, _)| {
-        (*region == TzRegion::Etc, label.collation_key(language))
-    });
-}
-
-// Nombre legible de una zona horaria usando espacios en lugar de guiones bajos (p. ej.
-// `"America/New York"` para `"America/New_York"`).
-fn zone_name(name: &'static str) -> CowStr {
-    if name.contains('_') {
-        name.replace('_', " ").into()
-    } else {
-        name.into()
-    }
-}
-
-// Etiqueta de una zona horaria: su nombre legible y, si se indica, su desfase en segundos respecto
-// a UTC (p. ej. `"Europe/Madrid (UTC+02:00)"`).
-fn zone_label(name: CowStr, offset: Option<i32>) -> CowStr {
-    let Some(offset) = offset else {
-        return name;
-    };
-    let sign = if offset < 0 { '-' } else { '+' };
-    let minutes = offset.abs() / 60;
-    format!("{name} (UTC{sign}{:02}:{:02})", minutes / 60, minutes % 60).into()
-}
-
 #[builder_impl]
 impl SelectTimezone {
     // **< SelectTimezone BUILDER >*****************************************************************
@@ -228,76 +133,10 @@ impl SelectTimezone {
         self
     }
 
-    /// Establece si las etiquetas muestran el desfase actual respecto a UTC, incluida la de la
-    /// opción de usar la zona horaria del sitio (p. ej. `"Europe/Madrid (UTC+02:00)"`), y ordenan
-    /// las zonas de cada región por ese desfase y, a igual desfase, por nombre. Por defecto sólo se
-    /// muestra el nombre de la zona y las zonas se ordenan por nombre.
-    pub fn with_utc_offset(mut self, utc_offset: bool) -> Self {
-        self.utc_offset = utc_offset;
-        self
-    }
-
-    /// Establece las regiones que se ofrecen (p. ej. `[TzRegion::Europe, TzRegion::America]`).
-    /// [`TzRegion::Etc`] (`Etc/UTC`) se ofrece siempre, se indique o no; una lista vacía ofrece
-    /// todas. Valida después el valor recibido con [`Timezone::is_supported_in()`] y la misma
-    /// lista.
-    pub fn with_regions(mut self, regions: impl IntoIterator<Item = TzRegion>) -> Self {
-        self.regions = regions.into_iter().collect();
-        self
-    }
-
-    /// Establece el orden de las regiones (ver [`TimezoneOrder`](crate::global::TimezoneOrder)).
-    pub fn with_order(mut self, order: global::TimezoneOrder) -> Self {
-        self.order = order;
-        self
-    }
-
     /// Establece el nombre IANA de la zona horaria seleccionada (p. ej. `"Europe/Madrid"`). Vacía,
-    /// o un nombre que no sea una zona horaria válida, selecciona la primera opción (ver
-    /// [`SelectTimezone`]).
+    /// o una que no esté en la lista, selecciona la primera opción (ver [`SelectTimezone`]).
     pub fn with_selected(mut self, selected: impl Into<String>) -> Self {
         self.selected = selected.into();
         self
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::sort_by_label;
-    use crate::datetime::TzRegion::{self, *};
-    use crate::locale::{Lc, Locale};
-
-    fn sorted(groups: &[(TzRegion, Lc)], language: &str) -> Vec<TzRegion> {
-        let mut groups: Vec<_> = groups
-            .iter()
-            .map(|(region, label)| (*region, label.clone(), ()))
-            .collect();
-        sort_by_label(&mut groups, &Locale::resolve(language));
-        groups.into_iter().map(|(region, _, _)| region).collect()
-    }
-
-    #[test]
-    fn regions_are_sorted_ignoring_accents_with_etc_last() {
-        let groups: Vec<_> = [Etc, Pacific, Asia, Arctic, Antarctica, Africa]
-            .into_iter()
-            .map(|region| (region, region.label()))
-            .collect();
-        assert_eq!(
-            sorted(&groups, "es-ES"),
-            [Africa, Antarctica, Arctic, Asia, Pacific, Etc]
-        );
-    }
-
-    // With the current translations the translated order matches the IANA names; these labels
-    // change it to check that regions are sorted by their translation.
-    #[test]
-    fn regions_are_sorted_by_translated_label_not_by_iana_name() {
-        let groups = [
-            (Atlantic, Lc::n("Océano Atlántico")),
-            (Etc, Lc::n("Alguna otra")),
-            (Europe, Lc::n("Europa")),
-            (Pacific, Lc::n("Pacífico")),
-        ];
-        assert_eq!(sorted(&groups, "es-ES"), [Europe, Atlantic, Pacific, Etc]);
-    }
-}
diff --git a/src/datetime.rs b/src/datetime.rs
index 89fdcb5d..ca1058f5 100644
--- a/src/datetime.rs
+++ b/src/datetime.rs
@@ -4,22 +4,15 @@
 //!
 //! Las fechas y horas se graban siempre en UTC y se muestran en la zona horaria efectiva del
 //! usuario actual ([`CurrentUser::timezone()`]), ya sea la suya propia si tiene una configurada y
-//! válida y [`timezone_per_user`] lo permite; y si no, la configurada para la aplicación
-//! ([`Timezone`]); o, en su defecto, UTC. La conversión sólo ocurre al mostrar
-//! ([`Contextual::format_datetime()`]), nunca al guardar.
-//!
-//! Las reglas de cada zona horaria (desfase respecto a UTC, horario de verano) son las de la base
-//! de datos de zonas horarias de la IANA que incluye [chrono-tz] al compilar. Como los países
-//! cambian sus reglas, una aplicación compilada sigue usando las reglas anteriores hasta que se
-//! recompila con una versión más reciente de `chrono-tz`; conviene hacerlo periódicamente. La traza
-//! de arranque indica la versión de la base de datos en uso (p. ej. `2025b`).
+//! válida; y si no, la configurada para la aplicación ([`Timezone`]); o, en su defecto, UTC. La
+//! conversión sólo ocurre al mostrar ([`Contextual::format_datetime()`]), nunca al guardar.
 //!
 //! [`DateFormat`] (fecha) y [`TimeFormat`] (hora) son tipos independientes: no existe un formato
 //! combinado de fecha y hora. Para mostrar ambas, [`Contextual::format_datetime()`] junta el
 //! resultado de cada uno (posiblemente con formatos distintos, p. ej. fecha larga con hora corta)
-//! mediante la clave Fluent `datetime_join` del idioma efectivo. El orden día/mes/año, el nombre
-//! del mes y el separador de fecha y hora son una propiedad del idioma, no de la configuración de
-//! la aplicación (a diferencia de la zona horaria). Se resuelven como claves Fluent normales
+//! mediante la clave Fluent `datetime_join` del idioma efectivo. El orden día/mes/año, el nombre del
+//! mes y el separador de fecha y hora son una propiedad del idioma, no de la configuración de la
+//! aplicación (a diferencia de la zona horaria). Se resuelven como claves Fluent normales
 //! (`src/locale/{lang}/datetime.ftl`), con el mismo mecanismo que cualquier otro texto traducido de
 //! PageTop.
 //!
@@ -34,7 +27,6 @@
 //! [chrono]: https://docs.rs/chrono
 //! [chrono-tz]: https://docs.rs/chrono-tz
 //! [`CurrentUser::timezone()`]: crate::auth::CurrentUser::timezone
-//! [`timezone_per_user`]: crate::global::App::timezone_per_user
 //! [`Contextual::format_datetime()`]: crate::core::component::Contextual::format_datetime
 //! [`Contextual::format_relative()`]: crate::core::component::Contextual::format_relative
 //! [`Contextual::format_since()`]: crate::core::component::Contextual::format_since
@@ -68,9 +60,6 @@ pub use chrono_tz::{TZ_VARIANTS, Tz};
 mod definition;
 pub use definition::Timezone;
 
-mod region;
-pub use region::TzRegion;
-
 mod format;
 pub use format::{DateFormat, TimeFormat};
 
diff --git a/src/datetime/definition.rs b/src/datetime/definition.rs
index cff51b57..b143ba49 100644
--- a/src/datetime/definition.rs
+++ b/src/datetime/definition.rs
@@ -1,271 +1,72 @@
-use crate::global::{self, TimezoneOrder};
-use crate::{trace, util};
+use crate::{global, trace, util};
 
-use super::{DateTime, TZ_VARIANTS, TimeZone, Tz, TzRegion};
-
-use chrono::Offset;
+use super::{TZ_VARIANTS, Tz};
 
 use std::collections::BTreeMap;
-use std::f64::consts::TAU;
 use std::sync::LazyLock;
 
-// Valor de `app.timezone` sin espacios al principio ni al final, si no está vacío.
-fn configured_raw() -> Option<&'static str> {
+// Identificador de zona horaria configurado para la aplicación, si es válido.
+static CONFIG_TZ: LazyLock<Option<Tz>> = LazyLock::new(|| {
     global::SETTINGS
         .app
         .timezone
         .as_deref()
         .and_then(util::non_blank)
-}
-
-// Zona horaria configurada para la aplicación, si es válida. El nombre se busca sin distinguir
-// mayúsculas y minúsculas, como las regiones de `app.timezone_regions`.
-static CONFIG_TZ: LazyLock<Option<Tz>> = LazyLock::new(|| {
-    configured_raw().and_then(|raw| {
-        TZ_VARIANTS
-            .iter()
-            .copied()
-            .find(|tz| tz.name().eq_ignore_ascii_case(raw))
-    })
+        .and_then(|raw| raw.parse().ok())
 });
 
 // Zona horaria de respaldo, garantizada incluso sin configuración válida.
 const FALLBACK_TZ: Tz = Tz::UTC;
 
-// Regiones válidas de `app.timezone_regions`; los nombres desconocidos se ignoran (ver `init()`).
-static CONFIG_REGIONS: LazyLock<Vec<TzRegion>> = LazyLock::new(|| {
-    global::SETTINGS
-        .app
-        .timezone_regions
-        .split(',')
-        .filter_map(TzRegion::from_name)
-        .collect()
-});
+// Regiones de la base IANA que sólo contienen alias heredados (fichero `backward`), todos con una
+// zona canónica equivalente en otra región (p. ej. `US/Eastern` es `America/New_York`).
+const LEGACY_REGIONS: [&str; 5] = ["Brazil", "Canada", "Chile", "Mexico", "US"];
 
-// Zonas horarias que se ofrecen para elegir según la configuración (ver `regions_by()`).
-static TZ_BY_REGION: LazyLock<Vec<(TzRegion, &'static [&'static str])>> =
-    LazyLock::new(|| Timezone::regions_with(global::SETTINGS.app.timezone_order, &CONFIG_REGIONS));
-
-// Alias de la base IANA que no se ofrecen porque repiten otra zona que sí se ofrece: nombres
-// antiguos (`Australia/NSW`), grafías alternativas (`Asia/Calcutta` es `Asia/Kolkata`) y lugares
-// que duplican a otro sin representar a ningún país (`America/Montreal` es `America/Toronto`).
-//
-// Son los enlaces de cuatro secciones del fichero `backward` de tzdata 2025b (el que incluye
-// `chrono-tz`): "Pre-1993 naming conventions", "Two-part names that were renamed...", "Non-zone.tab
-// locations..." y "Alternate names for the same location"; salvo `Asia/Istanbul` y
-// `Europe/Nicosia`, que la IANA mantiene para encontrar Turquía y Chipre en los dos continentes. Se
-// conservan los de la sección "Pre-2013 practice" (`Europe/Oslo`, `Africa/Accra`...); son zonas
-// fusionadas con otra porque coinciden desde 1970, pero cada una es la referencia de su país.
-//
-// Revisar al actualizar `chrono-tz`. Si quedara desfasada, reaparecería algún duplicado o se
-// ocultaría una zona que hubiera dejado de ser alias; el test avisa si alguno deja de existir.
-const ALIAS_ZONES: &[&str] = &[
-    "Africa/Asmera",
-    "Africa/Timbuktu",
-    "America/Argentina/ComodRivadavia",
-    "America/Atka",
-    "America/Buenos_Aires",
-    "America/Catamarca",
-    "America/Coral_Harbour",
-    "America/Cordoba",
-    "America/Ensenada",
-    "America/Fort_Wayne",
-    "America/Godthab",
-    "America/Indianapolis",
-    "America/Jujuy",
-    "America/Knox_IN",
-    "America/Louisville",
-    "America/Mendoza",
-    "America/Montreal",
-    "America/Nipigon",
-    "America/Pangnirtung",
-    "America/Porto_Acre",
-    "America/Rainy_River",
-    "America/Rosario",
-    "America/Santa_Isabel",
-    "America/Shiprock",
-    "America/Thunder_Bay",
-    "America/Virgin",
-    "America/Yellowknife",
-    "Antarctica/South_Pole",
-    "Asia/Ashkhabad",
-    "Asia/Calcutta",
-    "Asia/Choibalsan",
-    "Asia/Chongqing",
-    "Asia/Chungking",
-    "Asia/Dacca",
-    "Asia/Harbin",
-    "Asia/Kashgar",
-    "Asia/Katmandu",
-    "Asia/Macao",
-    "Asia/Rangoon",
-    "Asia/Saigon",
-    "Asia/Tel_Aviv",
-    "Asia/Thimbu",
-    "Asia/Ujung_Pandang",
-    "Asia/Ulan_Bator",
-    "Atlantic/Faeroe",
-    "Atlantic/Jan_Mayen",
-    "Australia/ACT",
-    "Australia/Canberra",
-    "Australia/Currie",
-    "Australia/LHI",
-    "Australia/NSW",
-    "Australia/North",
-    "Australia/Queensland",
-    "Australia/South",
-    "Australia/Tasmania",
-    "Australia/Victoria",
-    "Australia/West",
-    "Australia/Yancowinna",
-    "Europe/Belfast",
-    "Europe/Kiev",
-    "Europe/Tiraspol",
-    "Europe/Uzhgorod",
-    "Europe/Zaporozhye",
-    "Pacific/Enderbury",
-    "Pacific/Johnston",
-    "Pacific/Ponape",
-    "Pacific/Samoa",
-    "Pacific/Truk",
-    "Pacific/Yap",
-];
-
-// Región de zonas horarias con sus zonas ordenadas por nombre y el ángulo de su desfase medio en un
-// reloj de 24 horas (ver `angle()`).
-struct Region {
-    region: TzRegion,
-    zones: Vec<&'static str>,
-    center: f64,
-}
-
-// Todas las regiones que se pueden ofrecer, ordenadas por nombre. Sólo se conservan las zonas de
-// alguna región de `TzRegion`, lo que descarta los nombres sin región (alias heredados como `GB`,
-// `Japan` o `EST5EDT`) y las regiones formadas sólo por alias heredados (`US/Eastern` es
-// `America/New_York`). De `Etc` sólo se conserva `Etc/UTC`: el resto son alias de UTC
-// (`Etc/Zulu`...) o zonas de desfase fijo (`Etc/GMT+1`...) que no representan ningún lugar.
-// También se descartan los alias de `ALIAS_ZONES`: `chrono-tz` no distingue zonas canónicas de
-// enlaces.
-//
-// Sin coordenadas en `chrono-tz`, la posición de cada región es el desfase medio de sus zonas,
-// tratado como un ángulo (media circular) porque `Pacific` abarca de -11 a +14 horas y su centro
-// real está junto a la línea de cambio de fecha, no a medio camino entre ambos extremos.
-static ALL_REGIONS: LazyLock<Vec<Region>> = LazyLock::new(|| {
-    // Por región: nombres de sus zonas y suma de senos y cosenos de sus desfases.
-    let mut regions: BTreeMap<TzRegion, (Vec<&'static str>, f64, f64)> = BTreeMap::new();
+// Zonas horarias IANA agrupadas por región (lo anterior a la primera `/`), ordenadas por región y
+// nombre. Se descartan los nombres sin región (alias heredados como `GB`, `Japan` o `EST5EDT`) y
+// las regiones de `LEGACY_REGIONS`. De `Etc` sólo se conserva `Etc/UTC`, cuyo grupo va al final:
+// el resto son zonas de desfase fijo (`Etc/GMT+1`...) que no representan ningún lugar. Siguen
+// apareciendo los alias heredados que viven dentro de una región normal (p. ej. `Asia/Calcutta`
+// junto a `Asia/Kolkata`): `chrono-tz` no distingue zonas canónicas de enlaces y filtrarlos
+// exigiría mantener a mano una lista de casi 180 nombres.
+static TZ_BY_REGION: LazyLock<Vec<(&'static str, Vec<&'static str>)>> = LazyLock::new(|| {
+    let mut regions: BTreeMap<&'static str, Vec<&'static str>> = BTreeMap::new();
     for tz in TZ_VARIANTS.iter() {
         let name = tz.name();
-        let Some(region) = name
-            .split_once('/')
-            .and_then(|(region, _)| TzRegion::from_name(region))
-        else {
+        let Some((region, _)) = name.split_once('/') else {
             continue;
         };
-        if (region == TzRegion::Etc && name != "Etc/UTC")
-            || ALIAS_ZONES.binary_search(&name).is_ok()
-        {
+        if LEGACY_REGIONS.contains(&region) || (region == "Etc" && name != "Etc/UTC") {
             continue;
         }
-        let (zones, sin, cos) = regions.entry(region).or_default();
-        let a = angle(tz);
-        zones.push(name);
-        *sin += a.sin();
-        *cos += a.cos();
+        regions.entry(region).or_default().push(name);
     }
-    regions
-        .into_iter()
-        .map(|(region, (mut zones, sin, cos))| {
-            zones.sort_unstable();
-            Region {
-                region,
-                zones,
-                center: sin.atan2(cos),
-            }
-        })
-        .collect()
+    for names in regions.values_mut() {
+        names.sort_unstable();
+    }
+    let etc = regions.remove_entry("Etc");
+    regions.into_iter().chain(etc).collect()
 });
 
-// Desfase de una zona horaria respecto a UTC como ángulo de un reloj de 24 horas. Se toma en un
-// instante fijo (15/01/2026) para que el orden no dependa de la fecha; el horario de verano movería
-// los desfases normalmente una hora.
-fn angle(tz: &Tz) -> f64 {
-    let at = DateTime::from_timestamp(1_768_435_200, 0)
-        .unwrap_or_default()
-        .naive_utc();
-    let seconds = tz.offset_from_utc_datetime(&at).fix().local_minus_utc();
-    f64::from(seconds) / 86_400.0 * TAU
-}
-
-// Si la región se ofrece con la lista dada: con una lista vacía se ofrecen todas; si no, sólo las
-// indicadas y `Etc`, que se mantiene siempre porque `Etc/UTC` equivale a `UTC`, la zona horaria de
-// respaldo.
-fn is_offered(region: TzRegion, list: &[TzRegion]) -> bool {
-    list.is_empty() || region == TzRegion::Etc || list.contains(&region)
-}
-
-// Regiones que se ofrecen con la lista dada (ver `is_offered()`), ordenadas según `order`. `Etc` va
-// siempre al final. `site` es la referencia de `Nearest`, que mide la cercanía con media y
-// distancia circulares.
-fn regions_by(order: TimezoneOrder, list: &[TzRegion], site: Tz) -> Vec<&'static Region> {
-    let site_region = site
-        .name()
-        .split_once('/')
-        .and_then(|(region, _)| TzRegion::from_name(region));
-    let site_angle = angle(&site);
-    let mut sorted: Vec<_> = ALL_REGIONS
-        .iter()
-        .filter(|r| is_offered(r.region, list))
-        .map(|r| {
-            // Grupo (0 primero, 2 al final) y clave de orden dentro del grupo; empates por nombre.
-            let (rank, key) = match order {
-                _ if r.region == TzRegion::Etc => (2, 0.0),
-                TimezoneOrder::Nearest if Some(r.region) == site_region => (0, 0.0),
-                TimezoneOrder::Nearest => {
-                    let gap = (r.center - site_angle).rem_euclid(TAU);
-                    (1, gap.min(TAU - gap))
-                }
-                TimezoneOrder::Alphabetical => (1, 0.0),
-                TimezoneOrder::Listed => {
-                    let position = list.iter().position(|listed| *listed == r.region);
-                    (1, position.map_or(0.0, |p| p as f64))
-                }
-            };
-            (rank, key, r)
-        })
-        .collect();
-    sorted.sort_by(|a, b| {
-        a.0.cmp(&b.0)
-            .then(a.1.total_cmp(&b.1))
-            .then(a.2.region.as_str().cmp(b.2.region.as_str()))
-    });
-    sorted.into_iter().map(|(_, _, r)| r).collect()
-}
-
-/// Zona horaria configurada para la aplicación y zonas horarias para elegir.
+/// Zona horaria configurada para la aplicación.
 ///
-/// Resuelve [`global::SETTINGS.app.timezone`] contra la base IANA de zonas horarias. Si no se ha
-/// configurado o el valor no es válido, se aplica la zona horaria de respaldo (`UTC`). Ofrece
-/// además las zonas horarias que se pueden elegir ([`supported_by_region()`],
-/// [`is_supported_in()`]).
-///
-/// [`global::SETTINGS.app.timezone`]: crate::global::App::timezone
-/// [`supported_by_region()`]: Self::supported_by_region
-/// [`is_supported_in()`]: Self::is_supported_in
+/// Resuelve [`global::SETTINGS.app.timezone`](crate::global::App::timezone) contra la base IANA de
+/// zonas horarias. Si no se ha configurado o el valor no es válido, se aplica la zona horaria de
+/// respaldo (`UTC`).
 pub struct Timezone;
 
 impl Timezone {
-    // Inicializa la zona horaria por defecto y las regiones para elegir.
-    //
-    // Debe llamarse durante la inicialización para indicar si la zona horaria por defecto procede
-    // de la configuración, de una configuración no válida o de la zona horaria de respaldo, y para
-    // avisar de las regiones de `app.timezone_regions` que no existan. De paso, calcula al arrancar
-    // las zonas horarias que se ofrecen, en vez de esperar a la primera petición que las necesite.
+    /// Inicializa la zona horaria por defecto que utilizará la aplicación.
+    ///
+    /// Debe llamarse durante la inicialización para indicar si la zona horaria por defecto procede
+    /// de la configuración, de una configuración no válida o de la zona horaria de respaldo.
     pub(crate) fn init() {
-        trace::debug!(
-            "Timezone database: IANA tzdata {}",
-            chrono_tz::IANA_TZDB_VERSION
-        );
-        match configured_raw() {
+        match global::SETTINGS
+            .app
+            .timezone
+            .as_deref()
+            .and_then(util::non_blank)
+        {
             Some(raw) => {
                 if let Some(tz) = *CONFIG_TZ {
                     trace::debug!("Default timezone \"{tz}\" (from config: \"{raw}\")");
@@ -275,23 +76,8 @@ impl Timezone {
                     );
                 }
             }
-            None => trace::debug!("Default timezone \"{FALLBACK_TZ}\" (fallback, no config)"),
+            _ => trace::debug!("Default timezone \"{FALLBACK_TZ}\" (fallback, no config)"),
         }
-
-        for name in global::SETTINGS.app.timezone_regions.split(',') {
-            if !name.trim().is_empty() && TzRegion::from_name(name).is_none() {
-                trace::warn!("Ignored unknown timezone region \"{}\"", name.trim());
-            }
-        }
-        let regions: Vec<_> = Self::supported_by_region()
-            .iter()
-            .map(|(region, _)| region.as_str())
-            .collect();
-        let order = global::SETTINGS.app.timezone_order;
-        trace::debug!(
-            "Timezone regions offered ({order:?}): {}",
-            regions.join(", ")
-        );
     }
 
     /// Devuelve la zona horaria configurada explícitamente, si es válida.
@@ -317,25 +103,13 @@ impl Timezone {
 
     /// Devuelve las zonas horarias IANA que se ofrecen para elegir, agrupadas por región.
     ///
-    /// Cada grupo es la región ([`TzRegion`]) con los nombres completos de sus zonas (p. ej.
-    /// `"Europe/Madrid"`) ordenados por nombre. Las regiones siguen el orden de
-    /// [`global::SETTINGS.app.timezone_order`]: por defecto, primero la región de la zona horaria
-    /// del sitio, si la tiene, y luego el resto, de la más cercana a la más lejana; con
-    /// *"Alphabetical"*, o *"Listed"* sin regiones, se ordenan por su nombre IANA, y quien las
-    /// muestre traducidas debe reordenarlas por el nombre traducido, como hace
-    /// [`form::SelectTimezone`]. [`TzRegion::Etc`], sólo con `"Etc/UTC"`, va siempre al final.
-    ///
-    /// Se excluyen los nombres sin región (`"UTC"`, `"Japan"`...), las regiones formadas sólo por
-    /// alias heredados (`"US"`, `"Canada"`...), los alias que sólo repiten otra zona con otro
-    /// nombre (`"Asia/Calcutta"` es `"Asia/Kolkata"`), aunque se conservan las zonas de referencia
-    /// de cada país fusionadas con otra (`"Europe/Oslo"`), y las zonas de desfase fijo
-    /// (`"Etc/GMT+1"`...). Se limita a las regiones indicadas en
-    /// [`global::SETTINGS.app.timezone_regions`], si las hay, más [`TzRegion::Etc`], que se ofrece
-    /// siempre.
-    ///
-    /// Son las zonas horarias que ofrece por defecto [`form::SelectTimezone`], útiles también para
-    /// validar el valor recibido, aceptando además, sin cambios, el que ya estuviera guardado
-    /// aunque ya no se ofrezca.
+    /// Cada grupo es la región (lo anterior a la primera `/`, p. ej. `"Europe"`) con los nombres
+    /// completos de sus zonas (p. ej. `"Europe/Madrid"`), ordenados por región y nombre; el grupo
+    /// `"Etc"`, sólo con `"Etc/UTC"`, va al final. Se excluyen los nombres sin región (`"UTC"`,
+    /// `"Japan"`...), las regiones formadas sólo por alias heredados (`"US"`, `"Canada"`...) y las
+    /// zonas de desfase fijo (`"Etc/GMT+1"`...). Es la lista que ofrece
+    /// [`form::SelectTimezone`](crate::base::component::form::SelectTimezone), útil también para
+    /// validar el valor recibido.
     ///
     /// # Ejemplo
     ///
@@ -350,205 +124,7 @@ impl Timezone {
     /// assert!(is_supported("Europe/Madrid"));
     /// assert!(!is_supported("US/Eastern"));
     /// ```
-    ///
-    /// [`global::SETTINGS.app.timezone_order`]: crate::global::App::timezone_order
-    /// [`global::SETTINGS.app.timezone_regions`]: crate::global::App::timezone_regions
-    /// [`form::SelectTimezone`]: crate::base::component::form::SelectTimezone
-    pub fn supported_by_region() -> &'static [(TzRegion, &'static [&'static str])] {
+    pub fn supported_by_region() -> &'static [(&'static str, Vec<&'static str>)] {
         &TZ_BY_REGION
     }
-
-    /// Devuelve si `name` es una de las zonas horarias que se ofrecen para elegir con las regiones
-    /// indicadas: las de esas regiones más `Etc/UTC`, que se ofrece siempre, o las de todas si la
-    /// lista está vacía. `name` debe ser el nombre IANA exacto, sin espacios y con las mayúsculas
-    /// correctas.
-    ///
-    /// Sirve para validar el valor recibido de un [`form::SelectTimezone`] al que se le hayan
-    /// cambiado las regiones con `with_regions()`; con las de la configuración basta
-    /// [`supported_by_region()`]. En ambos casos debe aceptarse también, sin cambios, el valor que
-    /// ya estuviera guardado aunque ya no se ofrezca.
-    ///
-    /// # Ejemplo
-    ///
-    /// ```rust
-    /// # use pagetop::prelude::*;
-    /// let europe = [TzRegion::Europe];
-    /// assert!(Timezone::is_supported_in("Europe/Madrid", &europe));
-    /// assert!(Timezone::is_supported_in("Etc/UTC", &europe));
-    /// assert!(!Timezone::is_supported_in("Asia/Tokyo", &europe));
-    /// assert!(Timezone::is_supported_in("Asia/Tokyo", &[]));
-    /// ```
-    ///
-    /// [`form::SelectTimezone`]: crate::base::component::form::SelectTimezone
-    /// [`supported_by_region()`]: Self::supported_by_region
-    pub fn is_supported_in(name: impl AsRef<str>, regions: &[TzRegion]) -> bool {
-        let name = name.as_ref();
-        ALL_REGIONS
-            .iter()
-            .any(|r| is_offered(r.region, regions) && r.zones.binary_search(&name).is_ok())
-    }
-
-    // Regiones de `app.timezone_regions`, valor por defecto de `SelectTimezone::with_regions()`.
-    pub(crate) fn configured_regions() -> Vec<TzRegion> {
-        CONFIG_REGIONS.clone()
-    }
-
-    // Regiones que se ofrecen con el orden y la lista dados; `supported_by_region()` es el
-    // resultado con los de la configuración.
-    pub(crate) fn regions_with(
-        order: TimezoneOrder,
-        regions: &[TzRegion],
-    ) -> Vec<(TzRegion, &'static [&'static str])> {
-        regions_by(order, regions, Self::default_tz())
-            .into_iter()
-            .map(|r| (r.region, r.zones.as_slice()))
-            .collect()
-    }
-
-    // Si las regiones se ordenan por nombre: con `Alphabetical`, o con `Listed` sin lista. Se
-    // ordenan por su nombre IANA, pero quien las muestre traducidas debe reordenarlas por el nombre
-    // traducido.
-    pub(crate) fn regions_by_name(order: TimezoneOrder, regions: &[TzRegion]) -> bool {
-        match order {
-            TimezoneOrder::Nearest => false,
-            TimezoneOrder::Alphabetical => true,
-            TimezoneOrder::Listed => regions.is_empty(),
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    use TimezoneOrder::{Alphabetical, Listed, Nearest};
-    use TzRegion::*;
-
-    fn tz(name: &str) -> Tz {
-        name.parse().unwrap()
-    }
-
-    fn order(by: TimezoneOrder, list: &[TzRegion], site: &str) -> Vec<TzRegion> {
-        regions_by(by, list, tz(site))
-            .into_iter()
-            .map(|r| r.region)
-            .collect()
-    }
-
-    fn position(regions: &[TzRegion], region: TzRegion) -> usize {
-        regions.iter().position(|r| *r == region).unwrap()
-    }
-
-    #[test]
-    fn offers_every_region_with_sorted_zones_and_only_etc_utc() {
-        let regions = regions_by(Alphabetical, &[], tz("UTC"));
-        let names: Vec<_> = regions.iter().map(|r| r.region).collect();
-        assert_eq!(
-            names,
-            [
-                Africa, America, Antarctica, Arctic, Asia, Atlantic, Australia, Europe, Indian,
-                Pacific, Etc
-            ]
-        );
-        assert_eq!(
-            regions.last().map(|r| r.zones.as_slice()),
-            Some(&["Etc/UTC"][..])
-        );
-        for r in &regions {
-            assert!(
-                r.zones.is_sorted(),
-                "zones of {:?} are not sorted by name",
-                r.region
-            );
-        }
-    }
-
-    #[test]
-    fn filters_regions_and_keeps_etc_even_when_not_listed() {
-        assert_eq!(
-            order(Alphabetical, &[Europe, Asia], "UTC"),
-            [Asia, Europe, Etc]
-        );
-        assert_eq!(order(Alphabetical, &[Etc], "UTC"), [Etc]);
-        assert_eq!(order(Alphabetical, &[], "UTC").len(), 11);
-    }
-
-    #[test]
-    fn listed_follows_the_order_of_the_list() {
-        assert_eq!(
-            order(Listed, &[Pacific, Europe, Asia], "UTC"),
-            [Pacific, Europe, Asia, Etc]
-        );
-    }
-
-    #[test]
-    fn listed_keeps_etc_last_even_when_listed_first() {
-        assert_eq!(order(Listed, &[Etc, Europe], "UTC"), [Europe, Etc]);
-    }
-
-    #[test]
-    fn listed_without_list_is_alphabetical() {
-        assert_eq!(order(Listed, &[], "UTC"), order(Alphabetical, &[], "UTC"));
-    }
-
-    #[test]
-    fn nearest_puts_the_site_region_first_and_etc_last() {
-        let regions = order(Nearest, &[], "Europe/Madrid");
-        assert_eq!(regions.first(), Some(&Europe));
-        assert_eq!(regions.last(), Some(&Etc));
-        assert!(position(&regions, Africa) < position(&regions, Asia));
-        assert!(position(&regions, Asia) < position(&regions, Australia));
-    }
-
-    // `Pacific` spans from -11 to +14 hours: a linear mean would put its center around +5.7, far
-    // from `America`; the circular mean places it next to the date line (-11.5).
-    #[test]
-    fn nearest_averages_offsets_around_the_clock() {
-        assert_eq!(
-            order(Nearest, &[Europe, Pacific], "America/Mexico_City"),
-            [Pacific, Europe, Etc]
-        );
-    }
-
-    // From Auckland (+13), `America` (-4.9) is about 6 hours away across the date line; a linear
-    // distance would put it almost 18 hours away, farther than `Europe` (+1.5).
-    #[test]
-    fn nearest_measures_distances_around_the_clock() {
-        assert_eq!(
-            order(Nearest, &[Europe, America], "Pacific/Auckland"),
-            [America, Europe, Etc]
-        );
-    }
-
-    #[test]
-    fn nearest_without_site_region_sorts_every_region_by_distance() {
-        assert_eq!(
-            order(Nearest, &[Australia, Africa], "Europe/Madrid"),
-            [Africa, Australia, Etc]
-        );
-        // From UTC, `Pacific` (-11.5) is the farthest region, ahead of `Australia` (+10.1).
-        let regions = order(Nearest, &[], "UTC");
-        assert_eq!(regions[regions.len() - 2..], [Pacific, Etc]);
-    }
-
-    #[test]
-    fn alias_zones_exist_are_sorted_and_are_not_offered() {
-        assert!(ALIAS_ZONES.is_sorted(), "ALIAS_ZONES must be sorted");
-        for alias in ALIAS_ZONES {
-            assert!(
-                alias.parse::<Tz>().is_ok(),
-                "{alias} is not a chrono-tz zone"
-            );
-            assert!(!Timezone::is_supported_in(alias, &[]), "{alias} is offered");
-        }
-        // Canonical zones and zones merged since 2013 are still offered.
-        for zone in ["Asia/Kolkata", "Europe/Kyiv", "Europe/Oslo", "Africa/Accra"] {
-            assert!(
-                Timezone::is_supported_in(zone, &[]),
-                "{zone} is not offered"
-            );
-        }
-        assert!(Timezone::is_supported_in("Asia/Istanbul", &[]));
-        assert!(Timezone::is_supported_in("Europe/Nicosia", &[]));
-    }
 }
diff --git a/src/datetime/region.rs b/src/datetime/region.rs
deleted file mode 100644
index 8e633053..00000000
--- a/src/datetime/region.rs
+++ /dev/null
@@ -1,105 +0,0 @@
-use crate::locale::Lc;
-
-/// Regiones de la base de datos de zonas horarias de la IANA.
-///
-/// Cada región es el nombre que antecede la primera `/` del identificador de una zona horaria (p.
-/// ej. `Europe` en `"Europe/Madrid"`). [`Timezone::supported_by_region()`] agrupa por ellas las
-/// zonas horarias que se ofrecen para elegir, y [`form::SelectTimezone`] permite limitarlas.
-///
-/// `TzRegion::Etc` sólo contiene `Etc/UTC`, equivalente a `UTC`, la zona horaria de respaldo, y se
-/// ofrece siempre.
-///
-/// # Ejemplo
-///
-/// ```rust
-/// # use pagetop::prelude::*;
-/// assert_eq!(TzRegion::Europe.as_str(), "Europe");
-/// assert_eq!(TzRegion::from_name("europe"), Some(TzRegion::Europe));
-/// assert_eq!(TzRegion::from_name("US"), None);
-/// ```
-///
-/// [`Timezone::supported_by_region()`]: super::Timezone::supported_by_region
-/// [`form::SelectTimezone`]: crate::base::component::form::SelectTimezone
-#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub enum TzRegion {
-    /// África.
-    Africa,
-    /// América.
-    America,
-    /// Antártida.
-    Antarctica,
-    /// Ártico.
-    Arctic,
-    /// Asia.
-    Asia,
-    /// Océano Atlántico.
-    Atlantic,
-    /// Australia.
-    Australia,
-    /// Otras: sólo `Etc/UTC`.
-    Etc,
-    /// Europa.
-    Europe,
-    /// Océano Índico.
-    Indian,
-    /// Océano Pacífico.
-    Pacific,
-}
-
-impl TzRegion {
-    /// Devuelve el nombre IANA de la región (p. ej. `"Europe"`).
-    pub const fn as_str(&self) -> &'static str {
-        match self {
-            Self::Africa => "Africa",
-            Self::America => "America",
-            Self::Antarctica => "Antarctica",
-            Self::Arctic => "Arctic",
-            Self::Asia => "Asia",
-            Self::Atlantic => "Atlantic",
-            Self::Australia => "Australia",
-            Self::Etc => "Etc",
-            Self::Europe => "Europe",
-            Self::Indian => "Indian",
-            Self::Pacific => "Pacific",
-        }
-    }
-
-    /// Devuelve la región con el nombre IANA dado, sin distinguir mayúsculas ni tener en cuenta los
-    /// espacios del principio y del final; o `None` si no es ninguna de las regiones disponibles
-    /// (las que sólo agrupan alias heredados, como `"US"` o `"Canada"`, no lo son).
-    pub fn from_name(name: &str) -> Option<Self> {
-        let name = name.trim();
-        [
-            Self::Africa,
-            Self::America,
-            Self::Antarctica,
-            Self::Arctic,
-            Self::Asia,
-            Self::Atlantic,
-            Self::Australia,
-            Self::Etc,
-            Self::Europe,
-            Self::Indian,
-            Self::Pacific,
-        ]
-        .into_iter()
-        .find(|region| region.as_str().eq_ignore_ascii_case(name))
-    }
-
-    /// Devuelve el nombre traducido de la región (p. ej. *"Europa"* en español).
-    pub fn label(&self) -> Lc {
-        Lc::l(match self {
-            Self::Africa => "timezone_region_africa",
-            Self::America => "timezone_region_america",
-            Self::Antarctica => "timezone_region_antarctica",
-            Self::Arctic => "timezone_region_arctic",
-            Self::Asia => "timezone_region_asia",
-            Self::Atlantic => "timezone_region_atlantic",
-            Self::Australia => "timezone_region_australia",
-            Self::Etc => "timezone_region_etc",
-            Self::Europe => "timezone_region_europe",
-            Self::Indian => "timezone_region_indian",
-            Self::Pacific => "timezone_region_pacific",
-        })
-    }
-}
diff --git a/src/datetime/relative.rs b/src/datetime/relative.rs
index b54d9665..44d1fb61 100644
--- a/src/datetime/relative.rs
+++ b/src/datetime/relative.rs
@@ -171,8 +171,8 @@ mod tests {
 
     #[test]
     fn breakdown_clamps_month_end_across_a_leap_year() {
-        // Jan 31, 2024 (leap year) + 1 month = Feb 29 (checked_add_months clamps it); from there to
-        // Mar 1 there is 1 more day: 1 month and 1 day, not "1 month and -1 day" nor "2 months".
+        // 31 ene 2024 (bisiesto) + 1 mes = 29 feb (checked_add_months hace el *clamping*); de ahí
+        // a 1 mar queda 1 día más: 1 mes y 1 día, no "1 mes y -1 día" ni "2 meses".
         assert_eq!(breakdown(date(2024, 1, 31), date(2024, 3, 1)), (0, 1, 1));
     }
 
@@ -186,7 +186,7 @@ mod tests {
     #[test]
     fn apply_truncates_after_filtering_zero_components() {
         let today = date(2026, 6, 15);
-        let target = date(2024, 6, 12); // 2 years, 0 months, 3 days.
+        let target = date(2024, 6, 12); // 2 años, 0 meses, 3 días.
         let en = Locale::resolve("en-US");
 
         assert_eq!(
@@ -197,7 +197,7 @@ mod tests {
             RelativeFormat::Medium.apply(target, today, &en),
             "2 years and 3 days ago"
         );
-        // With no third component available (months = 0), `Long` matches `Medium`.
+        // Sin un tercer componente disponible (meses = 0), `Long` coincide con `Medium`.
         assert_eq!(
             RelativeFormat::Long.apply(target, today, &en),
             "2 years and 3 days ago"
@@ -207,7 +207,7 @@ mod tests {
     #[test]
     fn apply_shows_three_components_in_spanish() {
         let today = date(2026, 6, 15);
-        let target = date(2023, 4, 5); // 3 years, 2 months, 10 days.
+        let target = date(2023, 4, 5); // 3 años, 2 meses, 10 días.
         let es = Locale::resolve("es-ES");
 
         assert_eq!(
@@ -219,7 +219,7 @@ mod tests {
     #[test]
     fn apply_handles_future_dates_and_singular_units() {
         let today = date(2026, 6, 15);
-        let target = date(2026, 6, 16); // in 1 day.
+        let target = date(2026, 6, 16); // dentro de 1 día.
         let es = Locale::resolve("es-ES");
 
         assert_eq!(
diff --git a/src/global.rs b/src/global.rs
index 40481141..e8f7286e 100644
--- a/src/global.rs
+++ b/src/global.rs
@@ -10,9 +10,6 @@ pub use lang_negotiation::LangNegotiation;
 mod startup_banner;
 pub use startup_banner::StartupBanner;
 
-mod timezone_order;
-pub use timezone_order::TimezoneOrder;
-
 mod log_rolling;
 pub use log_rolling::LogRolling;
 
@@ -27,9 +24,6 @@ include_config!(SETTINGS: Settings => [
     "app.theme"              => "Basic",
     "app.lang_negotiation"   => "Full",
     "app.timezone"           => "UTC",
-    "app.timezone_regions"   => "",
-    "app.timezone_order"     => "Nearest",
-    "app.timezone_per_user"  => true,
     "app.startup_banner"     => "Slant",
 
     // [dev]
@@ -86,59 +80,13 @@ pub struct App {
     /// Zona horaria predeterminada de la aplicación (p. ej. *"UTC"* o *"Europe/Madrid"*).
     ///
     /// Se usa como zona horaria efectiva para las peticiones de usuarios anónimos o sin zona
-    /// horaria propia, y para todos si [`timezone_per_user`] es *false*. Ver [`Timezone`] y
-    /// [`CurrentUser::timezone()`].
+    /// horaria propia. Ver [`Timezone`] y [`CurrentUser::timezone()`].
     ///
     /// Si es `None` o no contiene un valor válido, se aplica `UTC`.
     ///
-    /// [`timezone_per_user`]: Self::timezone_per_user
     /// [`Timezone`]: crate::datetime::Timezone
     /// [`CurrentUser::timezone()`]: crate::auth::CurrentUser::timezone
     pub timezone: Option<String>,
-    /// Regiones de zonas horarias que se ofrecen para elegir, separadas por comas (p. ej.
-    /// *"Europe, America"*); da igual escribirlas en mayúsculas o minúsculas.
-    ///
-    /// Limita las zonas horarias de [`Timezone::supported_by_region()`] a las de esas regiones (ver
-    /// [`TzRegion`]): *"Africa"*, *"America"*, *"Antarctica"*, *"Arctic"*, *"Asia"*, *"Atlantic"*,
-    /// *"Australia"*, *"Europe"*, *"Indian"* y *"Pacific"*. Los nombres desconocidos se ignoran con
-    /// un aviso al arrancar. El grupo *"Etc"*, sólo con `Etc/UTC`, se ofrece siempre, se indique o
-    /// no; por eso *"Etc"* como único valor deja `Etc/UTC` como la única zona horaria disponible.
-    /// Si está vacío, o ninguna de las indicadas es válida, se ofrecen todas.
-    ///
-    /// Es el valor por defecto de [`form::SelectTimezone`], que puede cambiarse para un componente
-    /// concreto con `with_regions()`.
-    ///
-    /// Restringir las regiones no cambia las zonas horarias que los usuarios ya tengan asignadas:
-    /// se les siguen aplicando ([`CurrentUser::timezone()`]) aunque queden fuera, y
-    /// [`form::SelectTimezone`] las sigue mostrando como zona horaria actual para que volver a
-    /// guardar el formulario no las descarte. Sólo dejan de ofrecerse para nuevas elecciones; quien
-    /// valide el valor recibido contra [`Timezone::supported_by_region()`] debe aceptar también,
-    /// sin cambios, el que ya estuviera guardado.
-    ///
-    /// [`Timezone::supported_by_region()`]: crate::datetime::Timezone::supported_by_region
-    /// [`TzRegion`]: crate::datetime::TzRegion
-    /// [`CurrentUser::timezone()`]: crate::auth::CurrentUser::timezone
-    /// [`form::SelectTimezone`]: crate::base::component::form::SelectTimezone
-    pub timezone_regions: String,
-    /// Orden de las regiones de zonas horarias que se ofrecen para elegir: *"Nearest"*,
-    /// *"Alphabetical"* o *"Listed"*.
-    ///
-    /// Ver [`TimezoneOrder`] para los criterios disponibles. Es el valor por defecto de
-    /// [`form::SelectTimezone`], que puede cambiarse para un componente concreto con
-    /// `with_order()`.
-    ///
-    /// [`form::SelectTimezone`]: crate::base::component::form::SelectTimezone
-    pub timezone_order: TimezoneOrder,
-    /// Si cada usuario puede tener su propia zona horaria (*true*) o se usa siempre la de la
-    /// aplicación (*false*).
-    ///
-    /// Con *false*, [`CurrentUser::timezone()`] devuelve siempre la zona horaria de la aplicación
-    /// ([`timezone`](Self::timezone)), aunque el usuario tenga otra guardada, y las extensiones que
-    /// gestionan usuarios no deben ofrecer elegirla; la zona guardada se conserva por si se vuelve
-    /// a activar. Es el equivalente de [`LangNegotiation::ConfigOnly`] para el idioma.
-    ///
-    /// [`CurrentUser::timezone()`]: crate::auth::CurrentUser::timezone
-    pub timezone_per_user: bool,
     /// Banner ASCII mostrado al inicio: *"Off"* (desactivado), *"Slant"*, *"Small"*, *"Speed"* o
     /// *"Starwars"*.
     pub startup_banner: StartupBanner,
diff --git a/src/global/lang_negotiation.rs b/src/global/lang_negotiation.rs
index ef4b0b1a..a24ed7c2 100644
--- a/src/global/lang_negotiation.rs
+++ b/src/global/lang_negotiation.rs
@@ -30,9 +30,6 @@ pub enum LangNegotiation {
     /// Usa sólo la configuración o, en su defecto, el idioma de respaldo; ignora el idioma del
     /// usuario, la cabecera `Accept-Language` y el parámetro de la URL. Este modo proporciona un
     /// comportamiento estable con idioma fijo.
-    ///
-    /// Las extensiones que gestionan usuarios no deben ofrecer elegir idioma en este modo; el
-    /// idioma que el usuario tenga guardado se conserva por si se cambia de modo.
     ConfigOnly,
 }
 
diff --git a/src/global/timezone_order.rs b/src/global/timezone_order.rs
deleted file mode 100644
index 51da7ba0..00000000
--- a/src/global/timezone_order.rs
+++ /dev/null
@@ -1,57 +0,0 @@
-use crate::AutoDefault;
-
-use serde::{Deserialize, Deserializer};
-
-/// Criterios para ordenar las regiones de zonas horarias que se ofrecen para elegir.
-///
-/// Se obtiene de [`global::SETTINGS.app.timezone_order`](crate::global::App::timezone_order) y
-/// determina el orden de los grupos de [`Timezone::supported_by_region()`]. Es también el orden
-/// por defecto de [`form::SelectTimezone`], que puede cambiarse con `with_order()`. En todos los
-/// casos el grupo *"Etc"* (`Etc/UTC`) va siempre al final.
-///
-/// [`Timezone::supported_by_region()`]: crate::datetime::Timezone::supported_by_region
-/// [`form::SelectTimezone`]: crate::base::component::form::SelectTimezone
-#[derive(AutoDefault, Clone, Copy, Debug, Eq, PartialEq)]
-pub enum TimezoneOrder {
-    /// Primero la región de la zona horaria del sitio y luego el resto, de la más cercana a la más
-    /// lejana según su desfase horario. Es el comportamiento por defecto.
-    #[default]
-    Nearest,
-    /// Por nombre de la región. [`form::SelectTimezone`] las ordena por su nombre traducido al
-    /// idioma de la página, sin distinguir mayúsculas ni acentos;
-    /// `Timezone::supported_by_region()`, que no depende del idioma, por su nombre IANA.
-    ///
-    /// [`form::SelectTimezone`]: crate::base::component::form::SelectTimezone
-    Alphabetical,
-    /// En el orden en que se indican las regiones, en
-    /// [`global::SETTINGS.app.timezone_regions`](crate::global::App::timezone_regions) o con
-    /// `SelectTimezone::with_regions()`; si no se indica ninguna región válida, por nombre, como
-    /// `TimezoneOrder::Alphabetical`.
-    Listed,
-}
-
-impl<'de> Deserialize<'de> for TimezoneOrder {
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        let raw = String::deserialize(deserializer)?;
-        let result = match raw.trim().to_ascii_lowercase().as_str() {
-            "nearest" => Self::Nearest,
-            "alphabetical" => Self::Alphabetical,
-            "listed" => Self::Listed,
-            _ => {
-                let default = Self::default();
-                println!(
-                    concat!(
-                        "\nInvalid value \"{}\" for [app].timezone_order. ",
-                        "Using \"{:?}\". Check settings.",
-                    ),
-                    raw, default,
-                );
-                default
-            }
-        };
-        Ok(result)
-    }
-}
diff --git a/src/locale/en-US/base.ftl b/src/locale/en-US/base.ftl
index c5afff7a..a4935e9d 100644
--- a/src/locale/en-US/base.ftl
+++ b/src/locale/en-US/base.ftl
@@ -19,7 +19,6 @@ select_theme_placeholder = Choose a theme...
 
 select_timezone_site_default = Use the site time zone: { $timezone }
 select_timezone_placeholder = Choose a time zone...
-select_timezone_current = Current time zone
 
 timezone_region_africa = Africa
 timezone_region_america = America
diff --git a/src/locale/es-ES/base.ftl b/src/locale/es-ES/base.ftl
index 151076f0..ce914366 100644
--- a/src/locale/es-ES/base.ftl
+++ b/src/locale/es-ES/base.ftl
@@ -19,7 +19,6 @@ select_theme_placeholder = Elige un tema...
 
 select_timezone_site_default = Usar la zona horaria del sitio: { $timezone }
 select_timezone_placeholder = Elige una zona horaria...
-select_timezone_current = Zona horaria actual
 
 timezone_region_africa = África
 timezone_region_america = América
@@ -29,7 +28,7 @@ timezone_region_asia = Asia
 timezone_region_atlantic = Atlántico
 timezone_region_australia = Australia
 timezone_region_europe = Europa
-timezone_region_indian = Índico
+timezone_region_indian = Océano Índico
 timezone_region_pacific = Pacífico
 timezone_region_etc = Otras
 
diff --git a/tests/component_form_select_language.rs b/tests/component_form_select_language.rs
index e3149011..db9fd091 100644
--- a/tests/component_form_select_language.rs
+++ b/tests/component_form_select_language.rs
@@ -75,32 +75,27 @@ async fn unknown_selected_value_falls_back_to_the_empty_option() {
     assert!(html.contains(r#"<option value="" selected>Choose a language...</option>"#));
 }
 
-// Languages are sorted by their own name, so the order is the same for every page language.
 #[pagetop::test]
-async fn languages_are_sorted_by_their_own_name() {
+async fn languages_are_sorted_by_their_translated_name() {
     let mut field = form::SelectLanguage::new();
-    for page in ["en-US", "es-ES"] {
-        let mut cx = Context::default().with_langid(&Locale::resolve(page));
-        let html = field.render(&mut cx).await.into_string();
-        let english = html
-            .find(">English (United States)</option>")
-            .expect("English name");
-        let spanish = html
-            .find(">Español (España)</option>")
-            .expect("Spanish name");
-        assert!(english < spanish);
-    }
-}
 
-// Each language is labelled in its own language, whatever the language of the page.
-#[pagetop::test]
-async fn languages_are_labelled_in_their_own_language() {
-    for page in ["en-US", "es-ES"] {
-        let mut field = form::SelectLanguage::new();
-        let mut cx = Context::default().with_langid(&Locale::resolve(page));
-        let html = field.render(&mut cx).await.into_string();
+    let mut cx = Context::default().with_langid(&Locale::resolve("es-ES"));
+    let html = field.render(&mut cx).await.into_string();
+    let spanish = html
+        .find(">Español (España)</option>")
+        .expect("Spanish name");
+    let english = html
+        .find(">Inglés (Estados Unidos)</option>")
+        .expect("English name");
+    assert!(spanish < english);
 
-        assert!(html.contains(r#"<option value="es-ES">Español (España)</option>"#));
-        assert!(html.contains(r#"<option value="en-US">English (United States)</option>"#));
-    }
+    let mut cx = Context::default().with_langid(&Locale::resolve("en-US"));
+    let html = field.render(&mut cx).await.into_string();
+    let spanish = html
+        .find(">Spanish (Spain)</option>")
+        .expect("Spanish name");
+    let english = html
+        .find(">English (United States)</option>")
+        .expect("English name");
+    assert!(english < spanish);
 }
diff --git a/tests/component_form_select_timezone.rs b/tests/component_form_select_timezone.rs
index 4b08fc4b..04cc35e3 100644
--- a/tests/component_form_select_timezone.rs
+++ b/tests/component_form_select_timezone.rs
@@ -61,175 +61,3 @@ async fn required_field_asks_to_choose_only_when_nothing_valid_is_selected() {
     let html = chosen.render(&mut Context::default()).await.into_string();
     assert!(!html.contains(r#"value="""#));
 }
-
-// Zones without daylight saving time keep the expected labels stable all year round.
-#[pagetop::test]
-async fn utc_offset_is_shown_only_when_enabled() {
-    let mut plain = form::SelectTimezone::new();
-    let html = plain.render(&mut Context::default()).await.into_string();
-    assert!(html.contains(r#"<option value="Asia/Kolkata">Asia/Kolkata</option>"#));
-    assert!(!html.contains("(UTC"));
-
-    let mut with_offset = form::SelectTimezone::new().with_utc_offset(true);
-    let html = with_offset
-        .render(&mut Context::default())
-        .await
-        .into_string();
-    assert!(html.contains(r#"<option value="Asia/Kolkata">Asia/Kolkata (UTC+05:30)</option>"#));
-    assert!(html.contains(r#"<option value="America/Bogota">America/Bogota (UTC-05:00)</option>"#));
-    assert!(html.contains(r#"<option value="Etc/UTC">Etc/UTC (UTC+00:00)</option>"#));
-}
-
-// Zones of a region are sorted by name, or by offset and then by name when offsets are shown:
-// Kathmandu (+05:45) comes after Kolkata (+05:30), and Seoul precedes Tokyo (both +09:00).
-#[pagetop::test]
-async fn zones_are_sorted_by_offset_and_then_by_name_when_offsets_are_shown() {
-    let positions = |html: &str| -> Vec<usize> {
-        [
-            "Asia/Dubai",
-            "Asia/Kathmandu",
-            "Asia/Kolkata",
-            "Asia/Seoul",
-            "Asia/Tokyo",
-        ]
-        .iter()
-        .map(|zone| html.find(&format!(r#"value="{zone}""#)).unwrap())
-        .collect()
-    };
-
-    let mut plain = form::SelectTimezone::new();
-    let html = plain.render(&mut Context::default()).await.into_string();
-    let [dubai, kathmandu, kolkata, seoul, tokyo] = positions(&html)[..] else {
-        unreachable!()
-    };
-    assert!(dubai < kathmandu && kathmandu < kolkata && kolkata < seoul && seoul < tokyo);
-
-    let mut with_offset = form::SelectTimezone::new().with_utc_offset(true);
-    let html = with_offset
-        .render(&mut Context::default())
-        .await
-        .into_string();
-    let [dubai, kathmandu, kolkata, seoul, tokyo] = positions(&html)[..] else {
-        unreachable!()
-    };
-    assert!(dubai < kolkata && kolkata < kathmandu && kathmandu < seoul && seoul < tokyo);
-}
-
-fn group_labels(html: &str) -> Vec<&str> {
-    html.split(r#"<optgroup label=""#)
-        .skip(1)
-        .map(|group| group.split('"').next().unwrap())
-        .collect()
-}
-
-#[pagetop::test]
-async fn defaults_come_from_the_global_settings() {
-    let field = form::SelectTimezone::new();
-    assert_eq!(*field.order(), global::SETTINGS.app.timezone_order);
-    let regions: Vec<TzRegion> = global::SETTINGS
-        .app
-        .timezone_regions
-        .split(',')
-        .filter_map(TzRegion::from_name)
-        .collect();
-    assert_eq!(field.regions(), &regions);
-}
-
-#[pagetop::test]
-async fn with_regions_limits_the_offered_regions_and_keeps_etc() {
-    let mut field = form::SelectTimezone::new().with_regions([TzRegion::Europe]);
-    let html = field.render(&mut Context::default()).await.into_string();
-
-    assert_eq!(group_labels(&html), ["Europe", "Other"]);
-    assert!(html.contains(r#"value="Europe/Madrid""#));
-    assert!(!html.contains(r#"value="America/Bogota""#));
-}
-
-#[pagetop::test]
-async fn with_order_listed_follows_the_given_regions() {
-    let mut field = form::SelectTimezone::new()
-        .with_order(global::TimezoneOrder::Listed)
-        .with_regions([TzRegion::Pacific, TzRegion::Europe, TzRegion::Asia]);
-    let html = field.render(&mut Context::default()).await.into_string();
-
-    assert_eq!(group_labels(&html), ["Pacific", "Europe", "Asia", "Other"]);
-}
-
-#[pagetop::test]
-async fn with_order_alphabetical_sorts_by_translated_name() {
-    let mut field = form::SelectTimezone::new()
-        .with_order(global::TimezoneOrder::Alphabetical)
-        .with_regions([
-            TzRegion::Pacific,
-            TzRegion::Arctic,
-            TzRegion::Indian,
-            TzRegion::Europe,
-            TzRegion::Asia,
-        ]);
-    let mut cx = Context::default().with_langid(&Locale::resolve("es-ES"));
-    let html = field.render(&mut cx).await.into_string();
-
-    assert_eq!(
-        group_labels(&html),
-        ["Ártico", "Asia", "Europa", "Índico", "Pacífico", "Otras"]
-    );
-}
-
-// A valid zone that is no longer offered stays selectable, so saving the form keeps it.
-#[pagetop::test]
-async fn a_valid_but_unoffered_selected_zone_is_kept_in_its_own_group() {
-    let mut field = form::SelectTimezone::new()
-        .with_regions([TzRegion::Europe])
-        .with_selected("America/Bogota");
-    let html = field.render(&mut Context::default()).await.into_string();
-
-    assert_eq!(
-        group_labels(&html),
-        ["Current time zone", "Europe", "Other"]
-    );
-    assert!(html.contains(r#"<option value="America/Bogota" selected>America/Bogota</option>"#));
-    assert!(!html.contains(r#"<option value="" selected>"#));
-
-    let mut legacy = form::SelectTimezone::new().with_selected("US/Eastern");
-    let html = legacy.render(&mut Context::default()).await.into_string();
-    assert_eq!(group_labels(&html).first(), Some(&"Current time zone"));
-    assert!(html.contains(r#"<option value="US/Eastern" selected>US/Eastern</option>"#));
-
-    let mut required = form::SelectTimezone::new()
-        .with_required(true)
-        .with_regions([TzRegion::Europe])
-        .with_selected("America/Bogota");
-    let html = required.render(&mut Context::default()).await.into_string();
-    assert!(!html.contains(r#"value="""#));
-}
-
-#[pagetop::test]
-async fn an_invalid_selected_zone_is_not_offered() {
-    let mut field = form::SelectTimezone::new().with_selected("Mars/Olympus");
-    let html = field.render(&mut Context::default()).await.into_string();
-
-    assert!(!html.contains("Current time zone"));
-    assert!(!html.contains("Mars/Olympus"));
-    assert!(html.contains(r#"<option value="" selected>"#));
-}
-
-// Labels replace underscores with spaces; values keep the IANA name.
-#[pagetop::test]
-async fn labels_are_readable_while_values_keep_the_iana_name() {
-    let mut field = form::SelectTimezone::new();
-    let html = field.render(&mut Context::default()).await.into_string();
-
-    assert!(html.contains(r#"<option value="America/New_York">America/New York</option>"#));
-    assert!(html.contains(
-        r#"<option value="America/Argentina/Buenos_Aires">America/Argentina/Buenos Aires</option>"#
-    ));
-    assert!(html.contains(r#"<option value="Etc/UTC">Etc/UTC</option>"#));
-
-    let mut current = form::SelectTimezone::new()
-        .with_regions([TzRegion::Europe])
-        .with_selected("America/New_York");
-    let html = current.render(&mut Context::default()).await.into_string();
-    assert!(
-        html.contains(r#"<option value="America/New_York" selected>America/New York</option>"#)
-    );
-}
diff --git a/tests/datetime.rs b/tests/datetime.rs
index c2423b76..6f8552f7 100644
--- a/tests/datetime.rs
+++ b/tests/datetime.rs
@@ -319,58 +319,3 @@ async fn format_until_is_symmetric_to_format_since() {
         "hasta el 3 de junio de 2026"
     );
 }
-
-// **< TzRegion::from_name() >**********************************************************************
-
-#[pagetop::test]
-async fn region_names_are_parsed_ignoring_case_and_blanks() {
-    assert_eq!(TzRegion::from_name(" europe "), Some(TzRegion::Europe));
-    assert_eq!(TzRegion::from_name("PACIFIC"), Some(TzRegion::Pacific));
-    assert_eq!(TzRegion::from_name("US"), None);
-    assert_eq!(TzRegion::from_name("Mars"), None);
-    assert_eq!(TzRegion::from_name(""), None);
-}
-
-// **< Timezone::supported_by_region() >************************************************************
-
-#[pagetop::test]
-async fn supported_regions_put_the_site_first_and_etc_last() {
-    setup().await;
-
-    let regions = Timezone::supported_by_region();
-    let site = Timezone::default_tz();
-    if global::SETTINGS.app.timezone_order == global::TimezoneOrder::Nearest
-        && let Some(site_region) = site
-            .name()
-            .split_once('/')
-            .and_then(|(region, _)| TzRegion::from_name(region))
-        && site_region != TzRegion::Etc
-    {
-        assert_eq!(
-            regions.first().map(|(region, _)| *region),
-            Some(site_region)
-        );
-    }
-    assert_eq!(regions.last(), Some(&(TzRegion::Etc, &["Etc/UTC"][..])));
-    for (region, names) in regions {
-        assert!(
-            names.is_sorted(),
-            "zones of {region:?} are not sorted by name"
-        );
-    }
-}
-
-// **< Timezone::is_supported_in() >****************************************************************
-
-#[pagetop::test]
-async fn is_supported_in_applies_the_same_rules_as_the_offered_list() {
-    let europe = [TzRegion::Europe];
-    assert!(Timezone::is_supported_in("Europe/Madrid", &europe));
-    assert!(Timezone::is_supported_in("Etc/UTC", &europe));
-    assert!(!Timezone::is_supported_in("Asia/Tokyo", &europe));
-    assert!(Timezone::is_supported_in("Asia/Tokyo", &[]));
-    assert!(!Timezone::is_supported_in("US/Eastern", &[]));
-    assert!(!Timezone::is_supported_in("Etc/GMT+1", &[]));
-    assert!(!Timezone::is_supported_in("Europe/Atlantis", &[]));
-    assert!(!Timezone::is_supported_in("UTC", &[]));
-}