Rip out the `Component` bits. It doesn’t work, so: try something else.

lx/src/archive.rs

···
 use chrono::{Datelike, Month};
 use indexmap::{IndexMap, IndexSet};
-use minijinja::Environment;
 use serde::Serialize;
 use thiserror::Error;
 
-use crate::{
-   page::{Item, PostLink},
-   templates::component::Component,
-};
+use crate::page::{Item, PostLink};
 
 /// A data structure that maps each post to Y -> M -> D -> posts, preserving the order of
 /// the posts.
···
 
       Ok(Archive(year_map))
    }
-}
-
-impl<'e> Component for Archive<'e> {
-   const VIEW_NAME: &'static str = "archive";
 }
 
 #[allow(dead_code)]

lx/src/data/config.rs

···
 pub use serial::NavItem;
 
 pub mod serial {
-   use std::{collections::HashMap, fmt::Display, sync::Arc};
+   use std::{collections::HashMap, fmt::Display};
 
    use camino::{Utf8Path, Utf8PathBuf};
-   use minijinja::{Environment, State, Value, value::Object};
    use normalize_path::NormalizePath as _;
    use serde::{Deserialize, Serialize};
    use thiserror::Error;
 
-   use crate::{data::email::Email, templates::component::Component};
+   use crate::data::email::Email;
 
    #[derive(Serialize, Deserialize, Debug)]
    pub struct Config {
···
    pub enum NavItem {
       Separator,
       Page { title: String, path: String },
-   }
-
-   // NOTE(2025-10-09): this currently never gets hit when accessing via a template
-   //    invocation that goes through `Config`, because `Config` and `NavItem` both
-   //    implement `Serialize`, and so by the time the renderer is working with the
-   //    `Config::nav` data, it is working with it as the *serialized* version of it,
-   //    which means it never actually has a chance to see the `Component` version of it.
-   //    In practice, this likely means that I need to get rid of the `Serialize` bound on
-   //    `Component` and require custom rendering at each site (ugh) or find some other
-   //    way to express these kinds of relations. _Le sigh_.
-   //
-   // TODO: also maybe move this elsewhere?
-   impl Component for NavItem {
-      const VIEW_NAME: &'static str = "nav-item";
-   }
-
-   impl Object for NavItem {
-      fn call(
-         self: &Arc<Self>,
-         state: &State<'_, '_>,
-         _args: &[Value],
-      ) -> Result<Value, minijinja::Error> {
-         println!("got here?");
-         self.view(state.env()).map(Value::from)
-      }
    }
 
    #[derive(Error, Debug)]

lx/src/data/item/mod.rs

···
 use camino::{Utf8Path, Utf8PathBuf};
 use chrono::{DateTime, FixedOffset};
 use lx_md::Markdown;
-use minijinja::Environment;
 use serde::{Deserialize, Serialize};
 use slug::slugify;
 use thiserror::Error;
···
 use crate::{
    archive::Archive,
    page::{self, Item},
-   templates::component::Component,
 };
 
 use self::cascade::Cascade;
···
    }
 }
 
-impl Component for Qualifiers {
-   const VIEW_NAME: &'static str = "qualifiers";
-
-   fn view(&self, env: &Environment) -> Result<String, minijinja::Error> {
-      env.get_template(&Self::template())?.render(self)
-   }
-}
-
 #[derive(Debug, Serialize, Deserialize, PartialEq)]
 pub struct Book {
    title: Option<String>,
···
 struct BookView<'a> {
    book: &'a Book,
    archive: Archive<'a>,
-}
-
-impl<'a> Component for BookView<'a> {
-   const VIEW_NAME: &'static str = "book";
-
-   fn view(&self, env: &Environment) -> Result<String, minijinja::Error> {
-      let rendered_archive = self.archive.view(env)?;
-
-      let rendered = env
-         .get_template(Self::VIEW_NAME)?
-         .render(minijinja::context! {
-            book => self.book,
-            archive => rendered_archive,
-         })?;
-
-      Ok(rendered)
-   }
 }
 
 #[derive(Debug, Serialize, Deserialize)]

lx/src/data/item/serial.rs

···
 use serde::{Deserialize, Serialize};
 use thiserror::Error;
 
-use crate::{
-   data::{image::serial::Image, item::nice_list},
-   templates::component::Component,
-};
+use crate::data::{image::serial::Image, item::nice_list};
 
 #[derive(Deserialize, Debug, Default)]
 pub struct Item {
···
    pub discusses: Vec<String>,
    pub disclosure: Option<String>,
    pub retraction: Option<Retraction>,
-}
-
-impl Component for Qualifiers {
-   const VIEW_NAME: &'static str = "qualifiers";
 }
 
 #[derive(Serialize, Deserialize, Clone, Debug)]

lx/src/page.rs

···
-use crate::{
-   data::{
-      config::Config,
-      item::{self, Metadata, Slug, cascade::Cascade, serial},
-   },
-   templates::component::Component,
+use crate::data::{
+   config::Config,
+   item::{self, Metadata, Slug, cascade::Cascade, serial},
 };
 use camino::{Utf8Path, Utf8PathBuf};
 use chrono::{DateTime, FixedOffset};
 use json_feed::Author;
 use lx_md::{self, Markdown, RenderError, ToRender};
-use minijinja::{Environment, State, Value, context, value::Object};
 use serde::{Deserialize, Serialize};
-use std::{cmp::Ordering, sync::Arc};
+use std::cmp::Ordering;
 use std::{collections::HashMap, fmt, hash::Hash, os::unix::prelude::OsStrExt};
 use thiserror::Error;
 use uuid::Uuid;
···
          slug: &value.page.data.slug,
       }
    }
-}
-
-impl Object for PostLink<'_> {
-   fn call(
-      self: &Arc<Self>,
-      state: &State<'_, '_>,
-      _args: &[Value],
-   ) -> Result<Value, minijinja::Error> {
-      self.view(state.env()).map(Value::from)
-   }
-}
-
-impl<'e> Component for PostLink<'e> {
-   const VIEW_NAME: &'static str = "post-link";
 }
 
 #[derive(Error, Debug)]

lx/src/templates/component.rs

···
-use minijinja::Environment;
-use serde::Serialize;
-
-pub(crate) trait Component: Serialize + Sized {
-   const VIEW_NAME: &'static str;
-
-   fn view(&self, env: &Environment) -> Result<String, minijinja::Error> {
-      env.get_template(&Self::template())?.render(self)
-   }
-
-   fn template() -> String {
-      format!("components/{}.jinja", Self::VIEW_NAME)
-   }
-}

lx/src/templates/functions.rs

···
 use std::{fmt, sync::Arc};
 
 use minijinja::{
-   State, Value, context,
+   State, Value,
    value::{Object, Rest, ViaDeserialize},
 };
-use simplelog::debug;
 
 use crate::{
    data::{config::Config, image::Image, item::Metadata},
-   page::{self, RootedPath},
-   templates::component::{self, Component},
+   page::RootedPath,
 };
 
 pub(crate) fn add_all(env: &mut minijinja::Environment<'_>) {
···
 }
 
 /// Data for the `twitter:(label|data)(1|2)` meta tags.
-#[derive(Debug, serde::Serialize)]
+#[derive(Debug, serde::Serialize, serde::Deserialize)]
 enum Label {
    Post {
       tags: Vec<String>,
···
    // here given it’s pretty obviously just me on my own site?
    pub fn label1(&self) -> &str {
       match self {
-         Label::Post { .. } => "Author",
+         Label::Post { .. } => "Tags",
          Label::Work { .. } => "Instrumentation",
          Label::Custom { label1, .. } => label1.as_str(),
       }
···
    }
 }
 
-impl From<Label> for Value {
-   fn from(val: Label) -> Self {
-      Value::from_object(val)
-   }
-}
-
-impl Component for Label {
-   const VIEW_NAME: &'static str = "twitter-label";
-
-   fn view(&self, env: &minijinja::Environment) -> Result<String, minijinja::Error> {
-      env.get_template(&Self::template())?.render(context! {
-         label1 => self.label1(),
-         label2 => self.label2(),
-         data1 => self.data1(),
-         data2 => self.data2(),
-      })
-   }
-}
-
 impl Object for Label {
-   fn call(
-      self: &Arc<Self>,
-      state: &State<'_, '_>,
+   fn call_method(
+      self: &Arc<Label>,
+      _state: &State,
+      name: &str,
       _args: &[Value],
    ) -> Result<Value, minijinja::Error> {
-      self.view(state.env()).map(Value::from)
+      match name {
+         "label1" => Ok(self.label1().into()),
+         "data1" => Ok(self.data1().into()),
+         "label2" => Ok(self.label2().into()),
+         "data2" => Ok(self.data2().into()),
+         _ => Err(minijinja::Error::new(
+            minijinja::ErrorKind::UnknownMethod,
+            name.to_owned(),
+         )),
+      }
    }
 }
 
-#[derive(Debug, serde::Serialize)]
+#[derive(Debug, serde::Serialize, serde::Deserialize)]
 struct ApproximateLength {
    rounded: u64,
 }

lx/src/templates/mod.rs

···
-pub mod component;
 mod filters;
 mod functions;