refactor: bootstrap crate, thin server/worker binaries

crates/adapters/sqlite/src/lib.rs

@@ -75,6 +75,13 @@ pub async fn wire(database_url: &str) -> anyhow::Result<SqliteWireOutput> {
         .await
         .context("Failed to connect to SQLite database")?;
 
+    wire_pool(pool).await
+}
+
+/// Migrates an already-connected pool and builds every repository on it.
+pub async fn wire_pool(pool: SqlitePool) -> anyhow::Result<SqliteWireOutput> {
+    use anyhow::Context;
+
     migrate(&pool)
         .await
         .map_err(|e| anyhow::anyhow!("{e}"))

crates/application/Cargo.toml

@@ -6,7 +6,7 @@ edition.workspace = true
 [dependencies]
 async-trait = { workspace = true }
 domain = { workspace = true }
-infra-wiring = { workspace = true }
+config = { workspace = true }
 uuid = { workspace = true }
 chrono = { workspace = true }
 tracing = { workspace = true }

crates/application/src/config.rs

@@ -1 +1,41 @@
-pub use infra_wiring::{AppConfig, WrapUpConfig};
+#[derive(Clone)]
+pub struct AppConfig {
+    pub allow_registration: bool,
+    pub base_url: String,
+    pub rate_limit: u64,
+    pub refresh_ttl_seconds: u64,
+    pub secure_cookies: bool,
+    pub cors_origins: String,
+    pub wrapup: WrapUpConfig,
+}
+
+#[derive(Clone)]
+pub struct WrapUpConfig {
+    pub font_path: Option<String>,
+    pub logo_path: Option<String>,
+    pub bg_dir: Option<String>,
+}
+
+impl From<&::config::AppConfig> for AppConfig {
+    fn from(config: &::config::AppConfig) -> Self {
+        Self {
+            allow_registration: config.server.allow_registration,
+            base_url: config.server.base_url.clone(),
+            rate_limit: config.server.rate_limit,
+            refresh_ttl_seconds: config.auth.refresh_ttl_seconds,
+            secure_cookies: config.server.secure_cookies,
+            cors_origins: config.server.cors_origins.clone(),
+            wrapup: WrapUpConfig::from(&config.wrapup),
+        }
+    }
+}
+
+impl From<&::config::WrapUpConfig> for WrapUpConfig {
+    fn from(config: &::config::WrapUpConfig) -> Self {
+        Self {
+            font_path: config.font_path.clone(),
+            logo_path: config.logo_path.clone(),
+            bg_dir: config.bg_dir.clone(),
+        }
+    }
+}

crates/application/src/deps.rs

@@ -153,10 +153,10 @@ pub struct WrapupGroup {
 /// Every deps struct a handler can need, built once by the composition root.
 /// Use cases still receive only their own narrow struct — nothing takes `&Deps`.
 ///
-/// `composition::build_deps` is called only from `crates/presentation/src/main.rs`.
+/// `bootstrap::build_deps` is called only from `bootstrap::build_server`.
 /// The worker-only groups this used to also carry now live in `WorkerDeps`, built by
-/// `composition::build_worker_deps` and consumed by `crates/worker/src/main.rs` —
-/// `crates/worker` no longer wires its own deps (its former `db.rs` is gone). Nothing
+/// `bootstrap::build_worker_deps` and consumed by `bootstrap::build_worker` —
+/// the worker binary no longer wires anything itself. Nothing
 /// in `Deps` below is worker-only anymore, except one field with no consumer anywhere
 /// in the workspace — see its comment.
 pub struct Deps {
@@ -188,7 +188,7 @@ pub struct WorkerServices {
     pub person_enrichment: Option<Arc<dyn PersonEnrichmentClient>>,
 }
 
-/// The deps structs the worker binary needs, built by `composition::build_worker_deps`.
+/// The deps structs the worker binary needs, built by `bootstrap::build_worker_deps`.
 /// These are the five groups that moved out of `Deps` during worker unification —
 /// they have no consumer the server binary can ever reach.
 pub struct WorkerDeps {

crates/bootstrap/Cargo.toml

@@ -1,36 +1,49 @@
 [package]
-name = "composition"
+name = "bootstrap"
 version = "0.1.0"
 edition.workspace = true
 
 [features]
 default = []
-nats = ["dep:nats", "infra-wiring/nats"]
-federation = ["application/federation", "dep:sqlite-federation", "dep:activitypub"]
+nats = ["dep:nats"]
+federation = [
+    "application/federation",
+    "presentation/federation",
+    "dep:sqlite-federation",
+    "dep:activitypub",
+]
 
 [dependencies]
 config = { workspace = true }
 domain = { workspace = true }
 application = { workspace = true }
-infra-wiring = { workspace = true }
+presentation = { path = "../presentation", default-features = false }
 auth = { workspace = true }
 metadata = { workspace = true }
 poster-fetcher = { workspace = true }
 object-storage = { workspace = true }
+poster-sync = { workspace = true }
+tmdb-enrichment = { workspace = true }
+image-converter = { workspace = true }
+export = { workspace = true }
+importer = { workspace = true }
+rss = { workspace = true }
 jellyfin = { workspace = true }
 plex = { workspace = true }
-anyhow = { workspace = true }
-tracing = { workspace = true }
-
 sqlite = { workspace = true }
+sqlx = { workspace = true }
+anyhow = { workspace = true }
+async-trait = { workspace = true }
+axum = { workspace = true }
+tokio = { workspace = true }
+tracing = { workspace = true }
+tracing-subscriber = { workspace = true }
+
 nats = { workspace = true, optional = true }
 activitypub = { workspace = true, optional = true }
 sqlite-federation = { workspace = true, optional = true }
 
 [dev-dependencies]
-async-trait = { workspace = true }
 chrono = { workspace = true }
 domain = { workspace = true, features = ["test-helpers"] }
-sqlx = { workspace = true }
-tokio = { workspace = true }
 uuid = { workspace = true }

crates/bootstrap/src/database.rs

@@ -8,7 +8,9 @@ use domain::ports::{
     WebhookTokenRepository,
 };
 
-pub use infra_wiring::DbPool;
+pub enum DbPool {
+    Sqlite(sqlx::SqlitePool),
+}
 
 pub struct DatabaseOutput {
     pub movie_command: Arc<dyn domain::ports::MovieCommand>,
@@ -54,6 +56,25 @@ pub async fn build_database_adapters(
     let w = sqlite::wire(url)
         .await
         .context("SQLite connection failed")?;
+    assemble(w, instance)
+}
+
+/// Like [`build_database_adapters`], on a pool the caller already connected
+/// (migrations still run). Lets tests drive the real wiring on an in-memory pool.
+pub async fn build_database_adapters_on(
+    pool: sqlx::SqlitePool,
+    instance: &domain::value_objects::InstanceIdentity,
+) -> anyhow::Result<DatabaseOutput> {
+    let w = sqlite::wire_pool(pool)
+        .await
+        .context("SQLite wiring failed")?;
+    assemble(w, instance)
+}
+
+fn assemble(
+    w: sqlite::SqliteWireOutput,
+    instance: &domain::value_objects::InstanceIdentity,
+) -> anyhow::Result<DatabaseOutput> {
     let (image_ref_command, image_ref_query) = sqlite::create_image_ref(w.pool.clone());
     let (pc, pq) = sqlite::create_person_adapter(w.pool.clone());
     let (sc, sp) = sqlite::create_search_adapter(w.pool.clone());

crates/bootstrap/src/event_bus.rs

@@ -0,0 +1,77 @@
+use std::sync::Arc;
+
+#[cfg(feature = "nats")]
+use anyhow::Context;
+use domain::ports::{EventConsumer, EventPublisher};
+
+use crate::database::DbPool;
+
+#[derive(Clone, Copy)]
+pub enum EventBusBackend {
+    Db,
+    #[cfg(feature = "nats")]
+    Nats,
+}
+
+impl EventBusBackend {
+    pub fn from_config(config: &config::EventsConfig) -> anyhow::Result<Self> {
+        match config.bus_backend.as_str() {
+            "db" => Ok(Self::Db),
+            #[cfg(feature = "nats")]
+            "nats" => Ok(Self::Nats),
+            #[cfg(not(feature = "nats"))]
+            "nats" => {
+                anyhow::bail!("EVENT_BUS_BACKEND=nats requires the nats feature to be compiled in")
+            }
+            other => anyhow::bail!("unknown EVENT_BUS_BACKEND={other}, expected 'db' or 'nats'"),
+        }
+    }
+}
+
+pub async fn create_publisher(
+    db_pool: &DbPool,
+    config: &config::AppConfig,
+) -> anyhow::Result<Arc<dyn EventPublisher>> {
+    match EventBusBackend::from_config(&config.events)? {
+        EventBusBackend::Db => {
+            tracing::info!("event bus: DB queue");
+            Ok(match db_pool {
+                DbPool::Sqlite(pool) => {
+                    sqlite::SqliteEventQueue::create_publisher(pool.clone(), &config.events).await?
+                }
+            })
+        }
+        #[cfg(feature = "nats")]
+        EventBusBackend::Nats => {
+            let cfg = nats::NatsConfig::from_config(&config.nats)
+                .context("EVENT_BUS_BACKEND=nats requires NATS_URL to be set")?;
+            tracing::info!("event bus: NATS ({})", cfg.url);
+            Ok(nats::create_publisher(cfg).await?)
+        }
+    }
+}
+
+pub async fn create_channel(
+    db_pool: &DbPool,
+    config: &config::AppConfig,
+) -> anyhow::Result<(Arc<dyn EventPublisher>, Arc<dyn EventConsumer>)> {
+    match EventBusBackend::from_config(&config.events)? {
+        EventBusBackend::Db => {
+            tracing::info!("event bus: DB queue");
+            match db_pool {
+                DbPool::Sqlite(pool) => Ok(sqlite::SqliteEventQueue::create_channel(
+                    pool.clone(),
+                    &config.events,
+                )
+                .await?),
+            }
+        }
+        #[cfg(feature = "nats")]
+        EventBusBackend::Nats => {
+            let cfg = nats::NatsConfig::from_config(&config.nats)
+                .context("EVENT_BUS_BACKEND=nats requires NATS_URL to be set")?;
+            tracing::info!("event bus: NATS ({})", cfg.url);
+            Ok(nats::create_channel(cfg).await?)
+        }
+    }
+}

crates/bootstrap/src/federation.rs

@@ -0,0 +1,170 @@
+//! Social and federation wiring for the server and worker.
+//!
+//! Federation off still wires real local social behaviour (`LocalSocialService`):
+//! the follow graph and block queries must never silently report empty.
+
+use std::sync::Arc;
+
+use domain::ports::{
+    BlockQuery, EventPublisher, FederatedProfileQuery, FederationAdminQuery, FollowGraphQuery,
+    RemoteWatchlistRepository, SocialCommand,
+};
+use domain::value_objects::InstanceIdentity;
+
+use crate::database::DatabaseOutput;
+
+pub struct ServerSocial {
+    pub ap_router: axum::Router,
+    #[cfg(feature = "federation")]
+    pub ap_document: Arc<dyn domain::ports::ApDocumentPort>,
+    #[cfg(feature = "federation")]
+    pub ap_blocklist: Arc<dyn domain::ports::InstanceBlocklistPort>,
+    pub social_command: Arc<dyn SocialCommand>,
+    pub follow_graph: Arc<dyn FollowGraphQuery>,
+    pub block_query: Arc<dyn BlockQuery>,
+    pub remote_watchlist: Arc<dyn RemoteWatchlistRepository>,
+    pub federation_admin: Arc<dyn FederationAdminQuery>,
+    pub federated_profile: Option<Arc<dyn FederatedProfileQuery>>,
+}
+
+#[cfg(not(feature = "federation"))]
+pub async fn wire_server_social(
+    db: &DatabaseOutput,
+    instance: &InstanceIdentity,
+    _config: &config::AppConfig,
+    _event_publisher: &Arc<dyn EventPublisher>,
+) -> anyhow::Result<ServerSocial> {
+    let local = Arc::new(application::social::local_service::LocalSocialService::new(
+        Arc::clone(&db.user),
+        Arc::clone(&db.follow_command),
+        Arc::clone(&db.follow_query),
+        instance.clone(),
+    ));
+    Ok(ServerSocial {
+        ap_router: axum::Router::new(),
+        social_command: Arc::clone(&local) as Arc<dyn SocialCommand>,
+        follow_graph: Arc::clone(&local) as Arc<dyn FollowGraphQuery>,
+        block_query: local as Arc<dyn BlockQuery>,
+        remote_watchlist: Arc::new(domain::ports::noop::NoopRemoteWatchlistRepository),
+        // The empty list this noop returns is an invariant, not an approximation:
+        // federation-off, `LocalSocialService::follow_resolved` hard-errors on any
+        // non-Local target and block/unblock always error, so no remote follow can
+        // ever be persisted through this wiring. (Stale rows from an instance
+        // previously built federation-ON are the one exception — display staleness
+        // only; see ADR-0009.)
+        federation_admin: Arc::new(domain::ports::noop::NoopFederationAdminQuery),
+        federated_profile: None,
+    })
+}
+
+#[cfg(feature = "federation")]
+pub async fn wire_server_social(
+    db: &DatabaseOutput,
+    instance: &InstanceIdentity,
+    config: &config::AppConfig,
+    event_publisher: &Arc<dyn EventPublisher>,
+) -> anyhow::Result<ServerSocial> {
+    let crate::database::DbPool::Sqlite(pool) = &db.db_pool;
+    let fed_repos = sqlite_federation::wire(pool.clone(), instance.clone());
+
+    let ap = activitypub::wire(activitypub::ActivityPubDeps {
+        activity_repo: fed_repos.activity,
+        follow_repo: fed_repos.follow,
+        actor_repo: fed_repos.actor,
+        blocklist_repo: fed_repos.blocklist,
+        review_store: fed_repos.review_store,
+        remote_watchlist_repo: fed_repos.remote_watchlist.clone(),
+        remote_goal_repo: Arc::clone(&db.remote_goal),
+        local_ap_content: Arc::clone(&db.ap_content),
+        movie_repo: Arc::clone(&db.movie_query),
+        review_repo: Arc::clone(&db.review),
+        diary_repo: Arc::clone(&db.diary),
+        goal_repo: Arc::clone(&db.goal_query),
+        stats_repo: Arc::clone(&db.stats),
+        user_repo: Arc::clone(&db.user),
+        federation_settings: Arc::clone(&db.federation_settings),
+        follow_command: Arc::clone(&fed_repos.follow_command),
+        follow_query: Arc::clone(&fed_repos.follow_query),
+        instance: instance.clone(),
+        allow_registration: config.server.allow_registration,
+        federation: config.federation.clone(),
+        event_publisher: Arc::clone(event_publisher),
+    })
+    .await?;
+
+    let local_social: Arc<dyn domain::ports::LocalSocial> =
+        Arc::new(application::social::local_service::LocalSocialService::new(
+            Arc::clone(&db.user),
+            Arc::clone(&db.follow_command),
+            Arc::clone(&db.follow_query),
+            instance.clone(),
+        ));
+
+    let composite_social = Arc::new(activitypub::CompositeSocialAdapter::new(
+        local_social,
+        ap.service,
+        Arc::clone(&db.user),
+        instance.clone(),
+    ));
+
+    Ok(ServerSocial {
+        ap_router: ap.router,
+        ap_document: ap.document,
+        ap_blocklist: ap.blocklist,
+        social_command: composite_social.clone() as Arc<dyn SocialCommand>,
+        follow_graph: composite_social.clone() as Arc<dyn FollowGraphQuery>,
+        block_query: composite_social as Arc<dyn BlockQuery>,
+        remote_watchlist: fed_repos.remote_watchlist,
+        federation_admin: fed_repos.admin_query,
+        federated_profile: Some(sqlite::create_federated_profile_query(
+            pool.clone(),
+            instance.clone(),
+        )),
+    })
+}
+
+/// The worker's federation event handlers: the ActivityPub delivery handler and
+/// the follow-accepted outbox backfill.
+#[cfg(feature = "federation")]
+pub async fn wire_worker_handlers(
+    db: &DatabaseOutput,
+    instance: &InstanceIdentity,
+    config: &config::AppConfig,
+    event_publisher: &Arc<dyn EventPublisher>,
+) -> anyhow::Result<Vec<Arc<dyn domain::ports::EventHandler>>> {
+    let crate::database::DbPool::Sqlite(pool) = &db.db_pool;
+    let fed_repos = sqlite_federation::wire(pool.clone(), instance.clone());
+
+    let ap_wire = activitypub::wire(activitypub::ActivityPubDeps {
+        activity_repo: fed_repos.activity,
+        follow_repo: fed_repos.follow,
+        actor_repo: fed_repos.actor,
+        blocklist_repo: fed_repos.blocklist,
+        review_store: fed_repos.review_store,
+        remote_watchlist_repo: fed_repos.remote_watchlist,
+        remote_goal_repo: Arc::clone(&db.remote_goal),
+        local_ap_content: Arc::clone(&db.ap_content),
+        movie_repo: Arc::clone(&db.movie_query),
+        review_repo: Arc::clone(&db.review),
+        diary_repo: Arc::clone(&db.diary),
+        goal_repo: Arc::clone(&db.goal_query),
+        stats_repo: Arc::clone(&db.stats),
+        user_repo: Arc::clone(&db.user),
+        follow_command: fed_repos.follow_command,
+        follow_query: fed_repos.follow_query,
+        instance: instance.clone(),
+        allow_registration: config.server.allow_registration,
+        federation: config.federation.clone(),
+        event_publisher: Arc::clone(event_publisher),
+        federation_settings: Arc::clone(&db.federation_settings),
+    })
+    .await?;
+
+    tracing::info!("federation event handler registered");
+    Ok(vec![
+        ap_wire.event_handler,
+        Arc::new(crate::follow_backfill_handler::FollowBackfillHandler {
+            backfill: ap_wire.backfill,
+        }),
+    ])
+}

crates/bootstrap/src/lib.rs

@@ -0,0 +1,28 @@
+//! The composition root: the only crate that names concrete adapters.
+//!
+//! `server` and `worker` are thin binaries over [`build_server`] and
+//! [`build_worker`]; everything between configuration and a running service is
+//! assembled here (ADR-0005, ADR-0013).
+
+pub mod build;
+pub mod database;
+mod event_bus;
+mod federation;
+#[cfg(feature = "federation")]
+mod follow_backfill_handler;
+pub mod repositories;
+mod server;
+mod tracing_setup;
+mod worker;
+
+pub use build::{build_deps, build_worker_deps};
+pub use database::{DatabaseOutput, DbPool};
+pub use event_bus::EventBusBackend;
+pub use repositories::Repositories;
+pub use server::{ServerApp, build_server, build_server_on};
+pub use tracing_setup::init_tracing;
+pub use worker::{WorkerApp, build_worker};
+
+#[cfg(test)]
+#[path = "tests/build.rs"]
+mod build_tests;

crates/bootstrap/src/server.rs

@@ -0,0 +1,147 @@
+use std::net::SocketAddr;
+use std::sync::Arc;
+
+use anyhow::Context;
+use application::config::AppConfig as AppSettings;
+use domain::ports::{DiaryExporter, DocumentParser, EventPublisher};
+use domain::value_objects::InstanceIdentity;
+use export::ExportAdapter;
+use importer::ImporterDocumentParser;
+use presentation::context::AppContext;
+use presentation::{openapi, routes, state::AppState};
+use rss::RssAdapter;
+
+use crate::database::{self, DatabaseOutput};
+use crate::{Repositories, event_bus, federation};
+
+pub struct ServerApp {
+    pub router: axum::Router,
+    pub addr: SocketAddr,
+}
+
+/// Wires the whole HTTP application from configuration.
+pub async fn build_server(config: &config::AppConfig) -> anyhow::Result<ServerApp> {
+    database::warn_if_database_backend_set();
+    let instance = InstanceIdentity::new(config.server.base_url.clone());
+    let db = database::build_database_adapters(&config.database.url, &instance).await?;
+    let router = assemble(config, db, instance)
+        .await
+        .context("Failed to wire dependencies")?;
+
+    // Resolved like `TcpListener::bind(&str)` would, so a hostname HOST keeps working.
+    let bind = format!("{}:{}", config.server.host, config.server.port);
+    let addr = tokio::net::lookup_host(&bind)
+        .await
+        .with_context(|| format!("Invalid HOST/PORT {bind}"))?
+        .next()
+        .with_context(|| format!("HOST/PORT {bind} resolved to no address"))?;
+    Ok(ServerApp { router, addr })
+}
+
+/// Builds the same router as [`build_server`] on a caller-provided pool.
+/// Migrations run on it exactly as they do for the normal path.
+pub async fn build_server_on(
+    config: &config::AppConfig,
+    pool: sqlx::SqlitePool,
+) -> anyhow::Result<axum::Router> {
+    let instance = InstanceIdentity::new(config.server.base_url.clone());
+    let db = database::build_database_adapters_on(pool, &instance).await?;
+    assemble(config, db, instance).await
+}
+
+async fn assemble(
+    config: &config::AppConfig,
+    db: DatabaseOutput,
+    instance: InstanceIdentity,
+) -> anyhow::Result<axum::Router> {
+    let app_config = AppSettings::from(config);
+
+    let (auth_service, password_hasher) = database::build_auth_adapters(&config.auth)?;
+    let metadata_client = database::build_metadata_client(&config.metadata)?;
+    let poster_fetcher = database::build_poster_fetcher(&config.metadata)?;
+    let object_storage = database::build_object_storage(&config.storage)?;
+
+    let event_publisher: Arc<dyn EventPublisher> =
+        event_bus::create_publisher(&db.db_pool, config).await?;
+
+    let social = federation::wire_server_social(&db, &instance, config, &event_publisher).await?;
+
+    let review_logger = Arc::new(application::diary::review_logger::DefaultReviewLogger::new(
+        Arc::clone(&db.movie_command),
+        Arc::clone(&db.movie_query),
+        Arc::clone(&db.review),
+        Arc::clone(&db.watchlist),
+        Arc::clone(&metadata_client),
+        Arc::clone(&event_publisher),
+    ));
+
+    let repos = Repositories {
+        movie_command: db.movie_command,
+        movie_query: db.movie_query,
+        review: db.review,
+        diary: db.diary,
+        stats: db.stats,
+        user: db.user,
+        import_session: db.import_session,
+        import_profile: db.import_profile,
+        movie_profile: db.movie_profile,
+        watchlist: db.watchlist,
+        watch_event_command: db.watch_event_command,
+        watch_event_query: db.watch_event_query,
+        webhook_token: db.webhook_token,
+        person_command: db.person_command,
+        person_query: db.person_query,
+        search_port: db.search_port,
+        search_command: db.search_command,
+        profile_fields: db.profile_fields,
+        remote_watchlist: social.remote_watchlist,
+        social_command: social.social_command,
+        follow_graph: social.follow_graph,
+        block_query: social.block_query,
+        federation_admin: social.federation_admin,
+        wrapup_stats: db.wrapup_stats,
+        wrapup_repo: db.wrapup_repo,
+        insights: db.insights,
+        goal_command: db.goal_command,
+        goal_query: db.goal_query,
+        user_settings: db.user_settings,
+        remote_goal: db.remote_goal,
+        refresh_session: db.refresh_session,
+        federated_profile: social.federated_profile,
+    };
+
+    let services = application::Services {
+        auth: auth_service,
+        password_hasher,
+        metadata: metadata_client,
+        poster_fetcher,
+        object_storage,
+        event_publisher,
+        diary_exporter: Arc::new(ExportAdapter) as Arc<dyn DiaryExporter>,
+        document_parser: Arc::new(ImporterDocumentParser) as Arc<dyn DocumentParser>,
+        review_logger,
+        person_enrichment: None,
+    };
+
+    let deps = Arc::new(crate::build_deps(&repos, &services, &app_config, &instance));
+
+    let app_ctx = AppContext {
+        deps,
+        services,
+        config: app_config,
+        instance,
+        #[cfg(feature = "federation")]
+        ap_document: social.ap_document,
+        #[cfg(feature = "federation")]
+        ap_blocklist: social.ap_blocklist,
+    };
+
+    let state = AppState {
+        app_ctx,
+        rss_renderer: Arc::new(RssAdapter::new(config.server.base_url.clone())),
+    };
+    Ok(openapi::serve(routes::build_router(
+        state,
+        social.ap_router,
+    )))
+}

crates/bootstrap/src/tests/build.rs

@@ -266,11 +266,11 @@ fn test_repositories() -> Repositories {
 
 /// A lazily-connected in-memory sqlite pool — never actually opened in this test,
 /// just a value to satisfy `DatabaseOutput::db_pool`.
-fn test_db_pool() -> infra_wiring::DbPool {
+fn test_db_pool() -> crate::DbPool {
     let pool = sqlx::sqlite::SqlitePoolOptions::new()
         .connect_lazy("sqlite::memory:")
         .expect("lazy sqlite pool");
-    infra_wiring::DbPool::Sqlite(pool)
+    crate::DbPool::Sqlite(pool)
 }
 
 fn test_database_output() -> DatabaseOutput {
@@ -348,7 +348,7 @@ fn test_config() -> AppConfig {
         refresh_ttl_seconds: 2_592_000,
         secure_cookies: false,
         cors_origins: String::new(),
-        wrapup: infra_wiring::WrapUpConfig {
+        wrapup: application::config::WrapUpConfig {
             font_path: None,
             logo_path: None,
             bg_dir: None,

crates/bootstrap/src/tracing_setup.rs

@@ -0,0 +1,25 @@
+use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt};
+
+/// Installs the global subscriber. `RUST_LOG` overrides `default_directives`.
+pub fn init_tracing(default_directives: &str) {
+    tracing_subscriber::registry()
+        .with(log_filter(default_directives))
+        .with(tracing_subscriber::fmt::layer())
+        .init();
+}
+
+/// `RUST_LOG` names the crates to trace in detail; anything it doesn't name
+/// still reports warnings and errors. Without a baseline, a filter like
+/// `presentation=debug` silently drops adapter errors (e.g. the sqlx detail
+/// behind "Database operation failed").
+fn log_filter(default: &str) -> tracing_subscriber::EnvFilter {
+    let directives = std::env::var("RUST_LOG").unwrap_or_else(|_| default.to_string());
+    let has_baseline = directives
+        .split(',')
+        .any(|d| !d.trim().is_empty() && !d.contains('='));
+    if has_baseline {
+        tracing_subscriber::EnvFilter::new(directives)
+    } else {
+        tracing_subscriber::EnvFilter::new(format!("warn,{directives}"))
+    }
+}

crates/bootstrap/src/worker.rs

@@ -0,0 +1,231 @@
+use std::sync::Arc;
+
+use application::config::AppConfig as AppSettings;
+use application::{
+    MovieDiscoveryIndexer, SearchCleanupHandler, SearchReindexHandler, worker::WorkerService,
+};
+use domain::ports::{EventHandler, MovieEnrichmentClient, PeriodicJob, PersonEnrichmentClient};
+use domain::value_objects::InstanceIdentity;
+
+use crate::{database, event_bus};
+
+pub struct WorkerApp {
+    pub service: WorkerService,
+}
+
+/// Wires the background worker: event handlers, periodic jobs (already
+/// spawned) and the consumer. Run it with `service.run(shutdown)`.
+pub async fn build_worker(config: &config::AppConfig) -> anyhow::Result<WorkerApp> {
+    database::warn_if_database_backend_set();
+    let app_config = AppSettings::from(config);
+    let instance = InstanceIdentity::new(app_config.base_url.clone());
+
+    let metadata_client = metadata::create(&config.metadata)?;
+    let poster_fetcher = poster_fetcher::create(&config.metadata)?;
+    let object_storage = object_storage::create(&config.storage)?;
+
+    // TMDb client detection happens before `build_worker_deps` so the optional
+    // person-enrichment port can be handed to `WorkerServices` up front.
+    let tmdb_client = match tmdb_enrichment::TmdbEnrichmentClient::from_config(&config.metadata) {
+        Ok(client) => {
+            tracing::info!("TMDb enrichment enabled");
+            Some(Arc::new(client))
+        }
+        Err(e) => {
+            tracing::warn!("TMDb enrichment disabled: {e}");
+            None
+        }
+    };
+    let person_enrichment: Option<Arc<dyn PersonEnrichmentClient>> = tmdb_client
+        .clone()
+        .map(|c| c as Arc<dyn PersonEnrichmentClient>);
+
+    let db = database::build_database_adapters(&config.database.url, &instance).await?;
+    let (event_publisher_arc, consumer_arc) =
+        event_bus::create_channel(&db.db_pool, config).await?;
+
+    let worker_services = application::WorkerServices {
+        object_storage: Arc::clone(&object_storage),
+        event_publisher: Arc::clone(&event_publisher_arc),
+        person_enrichment,
+    };
+    let worker_deps = crate::build_worker_deps(&db, &worker_services);
+
+    let image_ref_command = Arc::clone(&db.image_ref_command);
+    let image_ref_query = Arc::clone(&db.image_ref_query);
+
+    #[cfg(feature = "federation")]
+    let federation_handlers =
+        crate::federation::wire_worker_handlers(&db, &instance, config, &event_publisher_arc)
+            .await?;
+
+    let movie_command = db.movie_command;
+    let movie_query = db.movie_query;
+    let user = db.user;
+    let import_session = db.import_session;
+    let movie_profile = db.movie_profile;
+    let watch_event_command = db.watch_event_command;
+    let person_query = db.person_query;
+    let search_command = db.search_command;
+    let wrapup_repo = db.wrapup_repo;
+    let refresh_session = db.refresh_session;
+
+    let event_publisher = event_publisher_arc;
+    let metadata = metadata_client;
+
+    // ── Enrichment ────────────────────────────────────────────────────────────
+    // Both the event handler and the staleness job are gated on TMDB_API_KEY.
+    // Without a key, no MovieEnrichmentRequested events are produced or handled.
+
+    type EnrichmentParts = (
+        Option<Arc<dyn EventHandler>>,
+        Option<Arc<dyn EventHandler>>,
+        Option<Arc<dyn PeriodicJob>>,
+    );
+    let (enrichment_handler, person_enrichment_handler, enrichment_job): EnrichmentParts =
+        match tmdb_client {
+            Some(client) => {
+                let image_fetcher = poster_fetcher::create_image_fetcher(&config.metadata)?;
+                let handler = Arc::new(application::movies::MovieEnrichmentHandler::new(
+                    Arc::clone(&client) as Arc<dyn MovieEnrichmentClient>,
+                    worker_deps.enrich_movie.movie_query.clone(),
+                    worker_deps.enrich_movie.movie_profile.clone(),
+                    worker_deps.enrich_movie.person_command.clone(),
+                    worker_deps.enrich_movie.search_command.clone(),
+                    Arc::clone(&object_storage),
+                    image_fetcher,
+                )) as Arc<dyn EventHandler>;
+                let person_handler = Arc::new(application::person::PersonEnrichmentHandler::new(
+                    worker_deps.enrich_person.person_query.clone(),
+                    worker_deps.enrich_person.person_enrichment.clone(),
+                    worker_deps.enrich_person.person_command.clone(),
+                )) as Arc<dyn EventHandler>;
+                let job = Arc::new(application::jobs::EnrichmentStalenessJob::new(
+                    Arc::clone(&movie_profile),
+                    Arc::clone(&event_publisher),
+                )) as Arc<dyn PeriodicJob>;
+                (Some(handler), Some(person_handler), Some(job))
+            }
+            None => (None, None, None),
+        };
+
+    // ── Image conversion ──────────────────────────────────────────────────────
+
+    let conversion = image_converter::build(
+        &config.image_conversion,
+        Arc::clone(&object_storage),
+        image_ref_command,
+        image_ref_query,
+        Arc::clone(&event_publisher),
+    )?;
+
+    // ── Periodic jobs ─────────────────────────────────────────────────────────
+
+    let mut periodic_jobs: Vec<Arc<dyn PeriodicJob>> = vec![
+        Arc::new(application::jobs::MovieDeduplicationJob::new(
+            worker_deps.merge_duplicates.movie_query.clone(),
+            worker_deps.merge_duplicates.deduplicator.clone(),
+            worker_deps.merge_duplicates.object_storage.clone(),
+        )),
+        Arc::new(application::jobs::ImportSessionCleanupJob::new(
+            import_session.clone(),
+        )),
+        Arc::new(application::jobs::WatchEventCleanupJob::new(
+            watch_event_command.clone(),
+        )),
+        Arc::new(application::jobs::WrapUpAutoGenerateJob::new(
+            Arc::clone(&user),
+            Arc::clone(&wrapup_repo),
+            Arc::clone(&event_publisher),
+        )),
+        Arc::new(application::jobs::WrapUpCleanupJob::new(Arc::clone(
+            &wrapup_repo,
+        ))),
+        Arc::new(application::jobs::RefreshSessionCleanupJob::new(
+            Arc::clone(&refresh_session),
+        )),
+    ];
+    if let Some(job) = enrichment_job {
+        periodic_jobs.push(job);
+    }
+    if let Some((_, ref conv_job)) = conversion {
+        periodic_jobs.push(Arc::clone(conv_job));
+    }
+
+    for job in periodic_jobs {
+        tokio::spawn(async move {
+            let mut tick = tokio::time::interval(job.interval());
+            loop {
+                tick.tick().await;
+                if let Err(e) = job.run().await {
+                    tracing::error!("periodic job failed: {e}");
+                }
+            }
+        });
+    }
+
+    // ── Event handlers ────────────────────────────────────────────────────────
+
+    let handlers: Vec<Arc<dyn EventHandler>> = {
+        let poster = Arc::new(poster_sync::PosterSyncHandler::new(
+            Arc::clone(&movie_command),
+            Arc::clone(&movie_query),
+            Arc::clone(&metadata),
+            Arc::clone(&poster_fetcher),
+            Arc::clone(&object_storage),
+            Arc::clone(&event_publisher),
+            3,
+        )) as Arc<dyn EventHandler>;
+
+        let cleanup = Arc::new(object_storage::ImageCleanupHandler::new(Arc::clone(
+            &object_storage,
+        ))) as Arc<dyn EventHandler>;
+
+        let search_cleanup = Arc::new(SearchCleanupHandler::new(
+            Arc::clone(&search_command),
+            Arc::clone(&person_query),
+        )) as Arc<dyn EventHandler>;
+
+        let discovery_indexer = Arc::new(MovieDiscoveryIndexer::new(
+            Arc::clone(&movie_query),
+            Arc::clone(&search_command),
+        )) as Arc<dyn EventHandler>;
+
+        let wrapup_handler = Arc::new(application::wrapup::event_handler::WrapUpEventHandler::new(
+            worker_deps.handle_requested.wrapup_repo.clone(),
+            worker_deps.handle_requested.event_publisher.clone(),
+            worker_deps.handle_requested.wrapup_stats.clone(),
+        )) as Arc<dyn EventHandler>;
+
+        let reindex_handler = Arc::new(SearchReindexHandler::new(worker_deps.reindex_search))
+            as Arc<dyn EventHandler>;
+
+        let mut h = vec![
+            poster,
+            cleanup,
+            search_cleanup,
+            discovery_indexer,
+            wrapup_handler,
+            reindex_handler,
+        ];
+
+        #[cfg(feature = "federation")]
+        h.extend(federation_handlers);
+
+        if let Some(e) = enrichment_handler {
+            h.push(e);
+        }
+        if let Some(e) = person_enrichment_handler {
+            h.push(e);
+        }
+        if let Some((ref conv_handler, _)) = conversion {
+            h.push(Arc::clone(conv_handler));
+        }
+
+        h
+    };
+
+    Ok(WorkerApp {
+        service: WorkerService::new(consumer_arc, handlers),
+    })
+}

crates/composition/src/lib.rs

@@ -1,11 +0,0 @@
-pub mod build;
-pub mod factory;
-pub mod repositories;
-
-pub use build::{build_deps, build_worker_deps};
-pub use factory::{DatabaseOutput, DbPool};
-pub use repositories::Repositories;
-
-#[cfg(test)]
-#[path = "tests/build.rs"]
-mod build_tests;

crates/infra-wiring/Cargo.toml

@@ -1,13 +0,0 @@
-[package]
-name = "infra-wiring"
-version = "0.1.0"
-edition = "2021"
-
-[dependencies]
-config = { workspace = true }
-sqlx = { workspace = true }
-anyhow = { workspace = true }
-
-[features]
-default = []
-nats = []

crates/infra-wiring/src/config.rs

@@ -1,41 +0,0 @@
-#[derive(Clone)]
-pub struct AppConfig {
-    pub allow_registration: bool,
-    pub base_url: String,
-    pub rate_limit: u64,
-    pub refresh_ttl_seconds: u64,
-    pub secure_cookies: bool,
-    pub cors_origins: String,
-    pub wrapup: WrapUpConfig,
-}
-
-#[derive(Clone)]
-pub struct WrapUpConfig {
-    pub font_path: Option<String>,
-    pub logo_path: Option<String>,
-    pub bg_dir: Option<String>,
-}
-
-impl From<&::config::AppConfig> for AppConfig {
-    fn from(config: &::config::AppConfig) -> Self {
-        Self {
-            allow_registration: config.server.allow_registration,
-            base_url: config.server.base_url.clone(),
-            rate_limit: config.server.rate_limit,
-            refresh_ttl_seconds: config.auth.refresh_ttl_seconds,
-            secure_cookies: config.server.secure_cookies,
-            cors_origins: config.server.cors_origins.clone(),
-            wrapup: WrapUpConfig::from(&config.wrapup),
-        }
-    }
-}
-
-impl From<&::config::WrapUpConfig> for WrapUpConfig {
-    fn from(config: &::config::WrapUpConfig) -> Self {
-        Self {
-            font_path: config.font_path.clone(),
-            logo_path: config.logo_path.clone(),
-            bg_dir: config.bg_dir.clone(),
-        }
-    }
-}

crates/infra-wiring/src/lib.rs

@@ -1,29 +0,0 @@
-pub mod config;
-
-pub use config::{AppConfig, WrapUpConfig};
-
-pub enum DbPool {
-    Sqlite(sqlx::SqlitePool),
-}
-
-#[derive(Clone, Copy)]
-pub enum EventBusBackend {
-    Db,
-    #[cfg(feature = "nats")]
-    Nats,
-}
-
-impl EventBusBackend {
-    pub fn from_config(config: &::config::EventsConfig) -> anyhow::Result<Self> {
-        match config.bus_backend.as_str() {
-            "db" => Ok(Self::Db),
-            #[cfg(feature = "nats")]
-            "nats" => Ok(Self::Nats),
-            #[cfg(not(feature = "nats"))]
-            "nats" => {
-                anyhow::bail!("EVENT_BUS_BACKEND=nats requires the nats feature to be compiled in")
-            }
-            other => anyhow::bail!("unknown EVENT_BUS_BACKEND={other}, expected 'db' or 'nats'"),
-        }
-    }
-}

crates/presentation/Cargo.toml

@@ -43,4 +43,4 @@ bytes = { workspace = true }
 futures = { workspace = true }
 tower = { version = "0.5", features = ["util"] }
 domain = { workspace = true, features = ["test-helpers"] }
-composition = { workspace = true }
+bootstrap = { workspace = true }

crates/presentation/src/tests/extractors.rs

@@ -7,7 +7,7 @@ use axum::{
     http::{Request, StatusCode},
     routing::get,
 };
-use composition::Repositories;
+use bootstrap::Repositories;
 use domain::{
     errors::DomainError,
     events::DomainEvent,
@@ -816,7 +816,7 @@ pub(crate) fn test_repositories() -> Repositories {
 
 // --- Single state factory — builds `deps` from whatever `repos` it is given ---
 
-/// Builds an `AppState` from caller-supplied `repos`, running `composition::build_deps`
+/// Builds an `AppState` from caller-supplied `repos`, running `bootstrap::build_deps`
 /// AFTER any overrides the caller already applied to `repos`. This is the only place
 /// `deps` gets built for tests, so `repos` and `deps` can never disagree.
 pub(crate) fn build_test_state_from(
@@ -854,9 +854,7 @@ pub(crate) fn build_test_state_from(
 
     let instance = domain::value_objects::InstanceIdentity::new("http://localhost:3000");
 
-    let deps = Arc::new(composition::build_deps(
-        &repos, &services, &config, &instance,
-    ));
+    let deps = Arc::new(bootstrap::build_deps(&repos, &services, &config, &instance));
 
     crate::state::AppState {
         app_ctx: AppContext {

crates/server/Cargo.toml

@@ -7,54 +7,32 @@ license = "MIT"
 
 [features]
 default = ["federation"]
-federation = [
-    "dep:activitypub",
-    "dep:sqlite-federation",
-    "application/federation",
-    "presentation/federation",
-    "composition/federation",
-]
-nats = ["dep:nats", "infra-wiring/nats", "composition/nats"]
+federation = ["bootstrap/federation"]
+nats = ["bootstrap/nats"]
 # deprecated aliases kept so existing deploy commands keep working
 sqlite = []
 sqlite-federation = ["federation"]
 
 [dependencies]
+bootstrap = { workspace = true }
 config = { workspace = true }
 axum = { workspace = true }
 tokio = { workspace = true }
 anyhow = { workspace = true }
-tracing = { workspace = true }
-tracing-subscriber = { workspace = true }
 dotenvy = { workspace = true }
-
-domain = { workspace = true }
-application = { workspace = true }
-composition = { workspace = true }
-presentation = { path = "../presentation", default-features = false }
-auth = { workspace = true }
-metadata = { workspace = true }
-poster-fetcher = { workspace = true }
-object-storage = { workspace = true }
-rss = { workspace = true }
-export = { workspace = true }
-importer = { workspace = true }
-nats = { workspace = true, optional = true }
-sqlx = { workspace = true }
-infra-wiring = { workspace = true }
-async-trait = { workspace = true }
-
-sqlite = { workspace = true }
-
-# Optional — federation
-activitypub = { workspace = true, optional = true }
-sqlite-federation = { workspace = true, optional = true }
+tracing = { workspace = true }
 
 [dev-dependencies]
+domain = { workspace = true, features = ["test-helpers"] }
+application = { workspace = true }
+presentation = { path = "../presentation", default-features = false }
+rss = { workspace = true }
+sqlite = { workspace = true }
+sqlx = { workspace = true }
+async-trait = { workspace = true }
 bytes = { workspace = true }
 futures = { workspace = true }
 serde_json = { workspace = true }
 uuid = { workspace = true }
 tower = { version = "0.5", features = ["util"] }
 http-body-util = "0.1"
-domain = { workspace = true, features = ["test-helpers"] }

crates/server/src/main.rs

@@ -1,305 +1,22 @@
-use std::sync::Arc;
-
 use anyhow::Context;
-
 use tokio::net::TcpListener;
-use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt};
-
-use composition::Repositories;
-use export::ExportAdapter;
-use importer::ImporterDocumentParser;
-use presentation::context::AppContext;
-use presentation::{openapi, routes, state::AppState};
-use rss::RssAdapter;
-
-use domain::ports::{DiaryExporter, DocumentParser, EventPublisher};
-use infra_wiring::EventBusBackend;
 
 #[tokio::main]
 async fn main() -> anyhow::Result<()> {
     dotenvy::dotenv().ok();
-    init_tracing();
+    bootstrap::init_tracing("server=debug,tower_http=debug");
 
     let config = config::load().context("Failed to load configuration")?;
+    let app = bootstrap::build_server(&config).await?;
 
-    let (state, ap_router) = wire_dependencies(&config)
-        .await
-        .context("Failed to wire dependencies")?;
-
-    let app = openapi::serve(routes::build_router(state, ap_router));
-
-    let addr = format!("{}:{}", config.server.host, config.server.port);
-    let listener = TcpListener::bind(&addr).await?;
-    tracing::info!("Listening on {}", addr);
+    let listener = TcpListener::bind(app.addr).await?;
+    tracing::info!("Listening on {}", app.addr);
     axum::serve(
         listener,
-        app.into_make_service_with_connect_info::<std::net::SocketAddr>(),
+        app.router
+            .into_make_service_with_connect_info::<std::net::SocketAddr>(),
     )
     .await?;
 
     Ok(())
 }
-
-async fn wire_dependencies(config: &config::AppConfig) -> anyhow::Result<(AppState, axum::Router)> {
-    let app_config = application::config::AppConfig::from(config);
-    let instance = domain::value_objects::InstanceIdentity::new(app_config.base_url.clone());
-    let database_url = config.database.url.as_str();
-    composition::factory::warn_if_database_backend_set();
-
-    let (auth_service, password_hasher) = composition::factory::build_auth_adapters(&config.auth)?;
-    let metadata_client = composition::factory::build_metadata_client(&config.metadata)?;
-    let poster_fetcher = composition::factory::build_poster_fetcher(&config.metadata)?;
-    let object_storage = composition::factory::build_object_storage(&config.storage)?;
-
-    let db = composition::factory::build_database_adapters(database_url, &instance).await?;
-    #[cfg(feature = "federation")]
-    let ap_content_repo = db.ap_content;
-    let db_pool = db.db_pool;
-
-    // Wire up event channel, federation service, and ap_router
-    let event_bus = EventBusBackend::from_config(&config.events)?;
-
-    #[cfg(feature = "federation")]
-    let (
-        event_publisher_arc,
-        ap_router,
-        ap_document,
-        ap_blocklist,
-        social_query,
-        remote_watchlist_repo,
-        social_command_arc,
-        follow_graph_arc,
-        block_query_arc,
-    ) = {
-        let fed_repos = match &db_pool {
-            composition::DbPool::Sqlite(pool) => {
-                sqlite_federation::wire(pool.clone(), instance.clone())
-            }
-        };
-
-        let ep = create_event_publisher(event_bus, &db_pool, config).await?;
-
-        let ap = activitypub::wire(activitypub::ActivityPubDeps {
-            activity_repo: fed_repos.activity,
-            follow_repo: fed_repos.follow,
-            actor_repo: fed_repos.actor,
-            blocklist_repo: fed_repos.blocklist,
-            review_store: fed_repos.review_store,
-            remote_watchlist_repo: fed_repos.remote_watchlist.clone(),
-            remote_goal_repo: Arc::clone(&db.remote_goal),
-            local_ap_content: Arc::clone(&ap_content_repo),
-            movie_repo: Arc::clone(&db.movie_query),
-            review_repo: Arc::clone(&db.review),
-            diary_repo: Arc::clone(&db.diary),
-            goal_repo: Arc::clone(&db.goal_query),
-            stats_repo: Arc::clone(&db.stats),
-            user_repo: Arc::clone(&db.user),
-            federation_settings: std::sync::Arc::clone(&db.federation_settings),
-            follow_command: Arc::clone(&fed_repos.follow_command),
-            follow_query: Arc::clone(&fed_repos.follow_query),
-            instance: instance.clone(),
-            allow_registration: app_config.allow_registration,
-            federation: config.federation.clone(),
-            event_publisher: Arc::clone(&ep),
-        })
-        .await?;
-        let ap_router = ap.router;
-        let ap_document = ap.document;
-        let ap_blocklist = ap.blocklist;
-
-        let local_social: Arc<dyn domain::ports::LocalSocial> =
-            Arc::new(application::social::local_service::LocalSocialService::new(
-                Arc::clone(&db.user),
-                Arc::clone(&db.follow_command),
-                Arc::clone(&db.follow_query),
-                instance.clone(),
-            ));
-
-        let composite_social = Arc::new(activitypub::CompositeSocialAdapter::new(
-            local_social,
-            ap.service,
-            Arc::clone(&db.user),
-            instance.clone(),
-        ));
-
-        (
-            ep,
-            ap_router,
-            ap_document,
-            ap_blocklist,
-            fed_repos.admin_query,
-            fed_repos.remote_watchlist,
-            composite_social.clone() as Arc<dyn domain::ports::SocialCommand>,
-            composite_social.clone() as Arc<dyn domain::ports::FollowGraphQuery>,
-            composite_social as Arc<dyn domain::ports::BlockQuery>,
-        )
-    };
-
-    #[cfg(not(feature = "federation"))]
-    let event_publisher_arc = create_event_publisher(event_bus, &db_pool, config).await?;
-    #[cfg(not(feature = "federation"))]
-    let ap_router = axum::Router::new();
-    #[cfg(not(feature = "federation"))]
-    let (social_command_arc, follow_graph_arc, block_query_arc) = {
-        let local = Arc::new(application::social::local_service::LocalSocialService::new(
-            Arc::clone(&db.user),
-            Arc::clone(&db.follow_command),
-            Arc::clone(&db.follow_query),
-            instance.clone(),
-        ));
-        (
-            Arc::clone(&local) as Arc<dyn domain::ports::SocialCommand>,
-            Arc::clone(&local) as Arc<dyn domain::ports::FollowGraphQuery>,
-            local as Arc<dyn domain::ports::BlockQuery>,
-        )
-    };
-
-    let review_logger = Arc::new(application::diary::review_logger::DefaultReviewLogger::new(
-        Arc::clone(&db.movie_command),
-        Arc::clone(&db.movie_query),
-        Arc::clone(&db.review),
-        Arc::clone(&db.watchlist),
-        Arc::clone(&metadata_client),
-        Arc::clone(&event_publisher_arc),
-    ));
-
-    let repos = Repositories {
-        movie_command: db.movie_command,
-        movie_query: db.movie_query,
-        review: db.review,
-        diary: db.diary,
-        stats: db.stats,
-        user: db.user,
-        import_session: db.import_session,
-        import_profile: db.import_profile,
-        movie_profile: db.movie_profile,
-        watchlist: db.watchlist,
-        watch_event_command: db.watch_event_command,
-        watch_event_query: db.watch_event_query,
-        webhook_token: db.webhook_token,
-        person_command: db.person_command,
-        person_query: db.person_query,
-        search_port: db.search_port,
-        search_command: db.search_command,
-        profile_fields: db.profile_fields,
-        #[cfg(feature = "federation")]
-        remote_watchlist: remote_watchlist_repo,
-        #[cfg(not(feature = "federation"))]
-        remote_watchlist: Arc::new(domain::ports::noop::NoopRemoteWatchlistRepository),
-        social_command: social_command_arc,
-        follow_graph: follow_graph_arc,
-        block_query: block_query_arc,
-        #[cfg(feature = "federation")]
-        federation_admin: social_query.clone(),
-        // The empty list this noop returns is an invariant, not an approximation:
-        // federation-off, `LocalSocialService::follow_resolved` hard-errors on any
-        // non-Local target and block/unblock always error, so no remote follow can
-        // ever be persisted through this wiring. (Stale rows from an instance
-        // previously built federation-ON are the one exception — display staleness
-        // only; see ADR-0009.)
-        #[cfg(not(feature = "federation"))]
-        federation_admin: Arc::new(domain::ports::noop::NoopFederationAdminQuery),
-        wrapup_stats: db.wrapup_stats,
-        wrapup_repo: db.wrapup_repo,
-        insights: db.insights,
-        goal_command: db.goal_command,
-        goal_query: db.goal_query,
-        user_settings: db.user_settings,
-        remote_goal: db.remote_goal,
-        refresh_session: db.refresh_session,
-        #[cfg(feature = "federation")]
-        federated_profile: Some({
-            match &db_pool {
-                composition::DbPool::Sqlite(pool) => {
-                    sqlite::create_federated_profile_query(pool.clone(), instance.clone())
-                }
-            }
-        }),
-        #[cfg(not(feature = "federation"))]
-        federated_profile: None,
-    };
-
-    let services = application::Services {
-        auth: auth_service,
-        password_hasher,
-        metadata: metadata_client,
-        poster_fetcher,
-        object_storage,
-        event_publisher: event_publisher_arc,
-        diary_exporter: Arc::new(ExportAdapter) as Arc<dyn DiaryExporter>,
-        document_parser: Arc::new(ImporterDocumentParser) as Arc<dyn DocumentParser>,
-        review_logger,
-        person_enrichment: None,
-    };
-
-    let deps = Arc::new(composition::build_deps(
-        &repos,
-        &services,
-        &app_config,
-        &instance,
-    ));
-
-    let app_ctx = AppContext {
-        deps,
-        services,
-        config: app_config,
-        instance,
-        #[cfg(feature = "federation")]
-        ap_document,
-        #[cfg(feature = "federation")]
-        ap_blocklist,
-    };
-
-    let state = AppState {
-        app_ctx,
-        rss_renderer: Arc::new(RssAdapter::new(config.server.base_url.clone())),
-    };
-    Ok((state, ap_router))
-}
-
-async fn create_event_publisher(
-    event_bus: EventBusBackend,
-    db_pool: &composition::DbPool,
-    config: &config::AppConfig,
-) -> anyhow::Result<Arc<dyn EventPublisher>> {
-    match event_bus {
-        EventBusBackend::Db => {
-            tracing::info!("event bus: DB queue");
-            Ok(match db_pool {
-                composition::DbPool::Sqlite(pool) => {
-                    sqlite::SqliteEventQueue::create_publisher(pool.clone(), &config.events).await?
-                }
-            })
-        }
-        #[cfg(feature = "nats")]
-        EventBusBackend::Nats => {
-            let cfg = nats::NatsConfig::from_config(&config.nats)
-                .context("EVENT_BUS_BACKEND=nats requires NATS_URL to be set")?;
-            tracing::info!("event bus: NATS ({})", cfg.url);
-            Ok(nats::create_publisher(cfg).await?)
-        }
-    }
-}
-
-fn init_tracing() {
-    tracing_subscriber::registry()
-        .with(log_filter("server=debug,tower_http=debug"))
-        .with(tracing_subscriber::fmt::layer())
-        .init();
-}
-
-/// `RUST_LOG` names the crates to trace in detail; anything it doesn't name
-/// still reports warnings and errors. Without a baseline, a filter like
-/// `presentation=debug` silently drops adapter errors (e.g. the sqlx detail
-/// behind "Database operation failed").
-fn log_filter(default: &str) -> tracing_subscriber::EnvFilter {
-    let directives = std::env::var("RUST_LOG").unwrap_or_else(|_| default.to_string());
-    let has_baseline = directives
-        .split(',')
-        .any(|d| !d.trim().is_empty() && !d.contains('='));
-    if has_baseline {
-        tracing_subscriber::EnvFilter::new(directives)
-    } else {
-        tracing_subscriber::EnvFilter::new(format!("warn,{directives}"))
-    }
-}

crates/server/tests/api_test.rs

@@ -7,7 +7,7 @@ use axum::{
     body::Body,
     http::{Request, StatusCode},
 };
-use composition::Repositories;
+use bootstrap::Repositories;
 use domain::{
     errors::DomainError,
     events::DomainEvent,
@@ -461,9 +461,7 @@ async fn test_app_with(auth: impl AuthService + 'static) -> (Router, SqlitePool)
 
     let instance = domain::value_objects::InstanceIdentity::new("http://localhost:3000");
 
-    let deps = Arc::new(composition::build_deps(
-        &repos, &services, &config, &instance,
-    ));
+    let deps = Arc::new(bootstrap::build_deps(&repos, &services, &config, &instance));
 
     let state = AppState {
         app_ctx: AppContext {

crates/worker/Cargo.toml

@@ -5,43 +5,16 @@ edition.workspace = true
 
 [features]
 default = ["federation"]
-federation = [
-    "dep:activitypub",
-    "dep:sqlite-federation",
-    "application/federation",
-    "composition/federation",
-]
-nats = ["dep:nats", "infra-wiring/nats", "composition/nats"]
+federation = ["bootstrap/federation"]
+nats = ["bootstrap/nats"]
 # deprecated aliases kept so existing deploy commands keep working
 sqlite = []
 sqlite-federation = ["federation"]
 
 [dependencies]
+bootstrap = { workspace = true }
 config = { workspace = true }
-domain = { workspace = true }
-application = { workspace = true }
-composition = { workspace = true }
 tokio = { workspace = true, features = ["signal"] }
 anyhow = { workspace = true }
-tracing = { workspace = true }
-tracing-subscriber = { workspace = true }
 dotenvy = { workspace = true }
-auth = { workspace = true }
-metadata = { workspace = true }
-poster-fetcher = { workspace = true }
-object-storage = { workspace = true }
-poster-sync = { workspace = true }
-export = { workspace = true }
-tmdb-enrichment = { workspace = true }
-importer = { workspace = true }
-image-converter = { workspace = true }
-nats = { workspace = true, optional = true }
-sqlx = { workspace = true }
-infra-wiring = { workspace = true }
-async-trait = { workspace = true }
-
-sqlite = { workspace = true }
-
-# Optional — federation
-activitypub = { workspace = true, optional = true }
-sqlite-federation = { workspace = true, optional = true }
+tracing = { workspace = true }

crates/worker/src/event_bus.rs

@@ -1,32 +0,0 @@
-use std::sync::Arc;
-
-#[cfg(feature = "nats")]
-use anyhow::Context;
-use domain::ports::{EventConsumer, EventPublisher};
-
-use infra_wiring::{DbPool, EventBusBackend};
-
-pub async fn create(
-    db_pool: &DbPool,
-    config: &config::AppConfig,
-) -> anyhow::Result<(Arc<dyn EventPublisher>, Arc<dyn EventConsumer>)> {
-    match EventBusBackend::from_config(&config.events)? {
-        EventBusBackend::Db => {
-            tracing::info!("event bus: DB queue");
-            match db_pool {
-                DbPool::Sqlite(pool) => Ok(sqlite::SqliteEventQueue::create_channel(
-                    pool.clone(),
-                    &config.events,
-                )
-                .await?),
-            }
-        }
-        #[cfg(feature = "nats")]
-        EventBusBackend::Nats => {
-            let cfg = nats::NatsConfig::from_config(&config.nats)
-                .context("EVENT_BUS_BACKEND=nats requires NATS_URL to be set")?;
-            tracing::info!("event bus: NATS ({})", cfg.url);
-            Ok(nats::create_channel(cfg).await?)
-        }
-    }
-}

crates/worker/src/main.rs

@@ -1,289 +1,12 @@
-mod event_bus;
-#[cfg(feature = "federation")]
-mod follow_backfill_handler;
-
-use std::sync::Arc;
-
 use anyhow::Context;
-use application::{
-    MovieDiscoveryIndexer, SearchCleanupHandler, SearchReindexHandler, worker::WorkerService,
-};
-use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt};
-
-use domain::ports::{EventHandler, MovieEnrichmentClient, PeriodicJob, PersonEnrichmentClient};
 
 #[tokio::main]
 async fn main() -> anyhow::Result<()> {
     dotenvy::dotenv().ok();
-    init_tracing();
+    bootstrap::init_tracing("worker=info,application=info,k_ap=info");
 
     let config = config::load().context("Failed to load configuration")?;
-    composition::factory::warn_if_database_backend_set();
-    let app_config = application::config::AppConfig::from(&config);
-    let instance = domain::value_objects::InstanceIdentity::new(app_config.base_url.clone());
-
-    let metadata_client = metadata::create(&config.metadata)?;
-    let poster_fetcher = poster_fetcher::create(&config.metadata)?;
-    let object_storage = object_storage::create(&config.storage)?;
-
-    // TMDb client detection happens before `build_worker_deps` so the optional
-    // person-enrichment port can be handed to `WorkerServices` up front.
-    let tmdb_client = match tmdb_enrichment::TmdbEnrichmentClient::from_config(&config.metadata) {
-        Ok(client) => {
-            tracing::info!("TMDb enrichment enabled");
-            Some(Arc::new(client))
-        }
-        Err(e) => {
-            tracing::warn!("TMDb enrichment disabled: {e}");
-            None
-        }
-    };
-    let person_enrichment: Option<Arc<dyn PersonEnrichmentClient>> = tmdb_client
-        .clone()
-        .map(|c| c as Arc<dyn PersonEnrichmentClient>);
-
-    let db = composition::factory::build_database_adapters(&config.database.url, &instance).await?;
-    let (event_publisher_arc, consumer_arc) = event_bus::create(&db.db_pool, &config).await?;
-
-    let worker_services = application::WorkerServices {
-        object_storage: Arc::clone(&object_storage),
-        event_publisher: Arc::clone(&event_publisher_arc),
-        person_enrichment,
-    };
-    let worker_deps = composition::build_worker_deps(&db, &worker_services);
-
-    let image_ref_command = Arc::clone(&db.image_ref_command);
-    let image_ref_query = Arc::clone(&db.image_ref_query);
-
-    #[cfg(feature = "federation")]
-    let (
-        fed_ap_content,
-        fed_movie_repo,
-        fed_review_repo,
-        fed_diary_repo,
-        fed_goal_repo,
-        fed_stats_repo,
-        fed_user_repo,
-        allow_registration,
-    ) = (
-        Arc::clone(&db.ap_content),
-        Arc::clone(&db.movie_query),
-        Arc::clone(&db.review),
-        Arc::clone(&db.diary),
-        Arc::clone(&db.goal_query),
-        Arc::clone(&db.stats),
-        Arc::clone(&db.user),
-        app_config.allow_registration,
-    );
-    // Wire federation repos early to get remote_watchlist_repo for AppContext.
-    #[cfg(feature = "federation")]
-    let fed_repos = match &db.db_pool {
-        composition::DbPool::Sqlite(pool) => {
-            sqlite_federation::wire(pool.clone(), instance.clone())
-        }
-    };
-
-    let movie_command = db.movie_command;
-    let movie_query = db.movie_query;
-    let user = db.user;
-    let import_session = db.import_session;
-    let movie_profile = db.movie_profile;
-    let watch_event_command = db.watch_event_command;
-    let person_query = db.person_query;
-    let search_command = db.search_command;
-    let wrapup_repo = db.wrapup_repo;
-    #[cfg(feature = "federation")]
-    let remote_goal = db.remote_goal;
-    let refresh_session = db.refresh_session;
-
-    let event_publisher = event_publisher_arc;
-    let object_storage = object_storage;
-    let metadata = metadata_client;
-
-    // ── Enrichment ────────────────────────────────────────────────────────────
-    // Both the event handler and the staleness job are gated on TMDB_API_KEY.
-    // Without a key, no MovieEnrichmentRequested events are produced or handled.
-
-    type EnrichmentParts = (
-        Option<Arc<dyn EventHandler>>,
-        Option<Arc<dyn EventHandler>>,
-        Option<Arc<dyn PeriodicJob>>,
-    );
-    let (enrichment_handler, person_enrichment_handler, enrichment_job): EnrichmentParts =
-        match tmdb_client {
-            Some(client) => {
-                let image_fetcher = poster_fetcher::create_image_fetcher(&config.metadata)?;
-                let handler = Arc::new(application::movies::MovieEnrichmentHandler::new(
-                    Arc::clone(&client) as Arc<dyn MovieEnrichmentClient>,
-                    worker_deps.enrich_movie.movie_query.clone(),
-                    worker_deps.enrich_movie.movie_profile.clone(),
-                    worker_deps.enrich_movie.person_command.clone(),
-                    worker_deps.enrich_movie.search_command.clone(),
-                    Arc::clone(&object_storage),
-                    image_fetcher,
-                )) as Arc<dyn EventHandler>;
-                let person_handler = Arc::new(application::person::PersonEnrichmentHandler::new(
-                    worker_deps.enrich_person.person_query.clone(),
-                    worker_deps.enrich_person.person_enrichment.clone(),
-                    worker_deps.enrich_person.person_command.clone(),
-                )) as Arc<dyn EventHandler>;
-                let job = Arc::new(application::jobs::EnrichmentStalenessJob::new(
-                    Arc::clone(&movie_profile),
-                    Arc::clone(&event_publisher),
-                )) as Arc<dyn PeriodicJob>;
-                (Some(handler), Some(person_handler), Some(job))
-            }
-            None => (None, None, None),
-        };
-
-    // ── Image conversion ──────────────────────────────────────────────────────
-
-    let conversion = image_converter::build(
-        &config.image_conversion,
-        Arc::clone(&object_storage),
-        image_ref_command,
-        image_ref_query,
-        Arc::clone(&event_publisher),
-    )?;
-
-    // ── Periodic jobs ─────────────────────────────────────────────────────────
-
-    let mut periodic_jobs: Vec<Arc<dyn PeriodicJob>> = vec![
-        Arc::new(application::jobs::MovieDeduplicationJob::new(
-            worker_deps.merge_duplicates.movie_query.clone(),
-            worker_deps.merge_duplicates.deduplicator.clone(),
-            worker_deps.merge_duplicates.object_storage.clone(),
-        )),
-        Arc::new(application::jobs::ImportSessionCleanupJob::new(
-            import_session.clone(),
-        )),
-        Arc::new(application::jobs::WatchEventCleanupJob::new(
-            watch_event_command.clone(),
-        )),
-        Arc::new(application::jobs::WrapUpAutoGenerateJob::new(
-            Arc::clone(&user),
-            Arc::clone(&wrapup_repo),
-            Arc::clone(&event_publisher),
-        )),
-        Arc::new(application::jobs::WrapUpCleanupJob::new(Arc::clone(
-            &wrapup_repo,
-        ))),
-        Arc::new(application::jobs::RefreshSessionCleanupJob::new(
-            Arc::clone(&refresh_session),
-        )),
-    ];
-    if let Some(job) = enrichment_job {
-        periodic_jobs.push(job);
-    }
-    if let Some((_, ref conv_job)) = conversion {
-        periodic_jobs.push(Arc::clone(conv_job));
-    }
-
-    for job in periodic_jobs {
-        tokio::spawn(async move {
-            let mut tick = tokio::time::interval(job.interval());
-            loop {
-                tick.tick().await;
-                if let Err(e) = job.run().await {
-                    tracing::error!("periodic job failed: {e}");
-                }
-            }
-        });
-    }
-
-    // ── Event handlers ────────────────────────────────────────────────────────
-
-    let handlers: Vec<Arc<dyn EventHandler>> = {
-        let poster = Arc::new(poster_sync::PosterSyncHandler::new(
-            Arc::clone(&movie_command),
-            Arc::clone(&movie_query),
-            Arc::clone(&metadata),
-            Arc::clone(&poster_fetcher),
-            Arc::clone(&object_storage),
-            Arc::clone(&event_publisher),
-            3,
-        )) as Arc<dyn EventHandler>;
-
-        let cleanup = Arc::new(object_storage::ImageCleanupHandler::new(Arc::clone(
-            &object_storage,
-        ))) as Arc<dyn EventHandler>;
-
-        let search_cleanup = Arc::new(SearchCleanupHandler::new(
-            Arc::clone(&search_command),
-            Arc::clone(&person_query),
-        )) as Arc<dyn EventHandler>;
-
-        let discovery_indexer = Arc::new(MovieDiscoveryIndexer::new(
-            Arc::clone(&movie_query),
-            Arc::clone(&search_command),
-        )) as Arc<dyn EventHandler>;
-
-        let wrapup_handler = Arc::new(application::wrapup::event_handler::WrapUpEventHandler::new(
-            worker_deps.handle_requested.wrapup_repo.clone(),
-            worker_deps.handle_requested.event_publisher.clone(),
-            worker_deps.handle_requested.wrapup_stats.clone(),
-        )) as Arc<dyn EventHandler>;
-
-        let reindex_handler = Arc::new(SearchReindexHandler::new(worker_deps.reindex_search))
-            as Arc<dyn EventHandler>;
-
-        let mut h = vec![
-            poster,
-            cleanup,
-            search_cleanup,
-            discovery_indexer,
-            wrapup_handler,
-            reindex_handler,
-        ];
-
-        #[cfg(feature = "federation")]
-        {
-            let ap_wire = activitypub::wire(activitypub::ActivityPubDeps {
-                activity_repo: fed_repos.activity,
-                follow_repo: fed_repos.follow,
-                actor_repo: fed_repos.actor,
-                blocklist_repo: fed_repos.blocklist,
-                review_store: fed_repos.review_store,
-                remote_watchlist_repo: fed_repos.remote_watchlist,
-                remote_goal_repo: Arc::clone(&remote_goal),
-                local_ap_content: fed_ap_content,
-                movie_repo: fed_movie_repo,
-                review_repo: fed_review_repo,
-                diary_repo: fed_diary_repo,
-                goal_repo: fed_goal_repo,
-                stats_repo: fed_stats_repo,
-                user_repo: fed_user_repo,
-                follow_command: fed_repos.follow_command,
-                follow_query: fed_repos.follow_query,
-                instance: instance.clone(),
-                allow_registration,
-                federation: config.federation.clone(),
-                event_publisher: Arc::clone(&event_publisher),
-                federation_settings: std::sync::Arc::clone(&db.federation_settings),
-            })
-            .await?;
-
-            tracing::info!("federation event handler registered");
-            h.push(ap_wire.event_handler);
-            h.push(Arc::new(follow_backfill_handler::FollowBackfillHandler {
-                backfill: ap_wire.backfill,
-            }) as Arc<dyn EventHandler>);
-        }
-
-        if let Some(e) = enrichment_handler {
-            h.push(e);
-        }
-        if let Some(e) = person_enrichment_handler {
-            h.push(e);
-        }
-        if let Some((ref conv_handler, _)) = conversion {
-            h.push(Arc::clone(conv_handler));
-        }
-
-        h
-    };
-
-    // ── Run ───────────────────────────────────────────────────────────────────
+    let app = bootstrap::build_worker(&config).await?;
 
     let (shutdown_tx, shutdown_rx) = tokio::sync::watch::channel(false);
     tokio::spawn(async move {
@@ -291,32 +14,8 @@ async fn main() -> anyhow::Result<()> {
         let _ = shutdown_tx.send(true);
     });
 
-    let worker = WorkerService::new(consumer_arc, handlers);
     tracing::info!("worker started");
-    worker.run(shutdown_rx).await;
+    app.service.run(shutdown_rx).await;
 
     Ok(())
 }
-
-fn init_tracing() {
-    tracing_subscriber::registry()
-        .with(log_filter("worker=info,application=info,k_ap=info"))
-        .with(tracing_subscriber::fmt::layer())
-        .init();
-}
-
-/// `RUST_LOG` names the crates to trace in detail; anything it doesn't name
-/// still reports warnings and errors. Without a baseline, a filter like
-/// `presentation=debug` silently drops adapter errors (e.g. the sqlx detail
-/// behind "Database operation failed").
-fn log_filter(default: &str) -> tracing_subscriber::EnvFilter {
-    let directives = std::env::var("RUST_LOG").unwrap_or_else(|_| default.to_string());
-    let has_baseline = directives
-        .split(',')
-        .any(|d| !d.trim().is_empty() && !d.contains('='));
-    if has_baseline {
-        tracing_subscriber::EnvFilter::new(directives)
-    } else {
-        tracing_subscriber::EnvFilter::new(format!("warn,{directives}"))
-    }
-}