One framework.
A concrete desktop.

pub fn desktop_adapters() -> DesktopAdapters {
    DesktopAdapters {
        apps: Arc::new(XdgApplications::default()),
        compositor: Hyprland::from_env()
            .ok()
            .map(|h| Arc::new(h) as Arc<dyn CompositorPort>),
        settings: Arc::new(JsonSettings::default()),
        theme: Arc::new(LucentTheme),
        palette_generation: Arc::new(lucent_services::wallpaper_catalog::ImagePalette),
        catalog: Arc::new(lucent_services::wallpaper_catalog::OnlineWallpapers),
        clock: Arc::new(LocalClock),
        system: Arc::new(LinuxSystem::default()),
        audio: Arc::new(lucent_services::audio::PulseAudio::default()),
        network: Arc::new(lucent_services::network::NetworkManager::default().with_secret_agent()),
        bluetooth: Arc::new(lucent_services::bluetooth::BlueZ::default()),
        displays: Arc::new(lucent_services::displays::HyprlandDisplays::default()),
        power: Arc::new(lucent_services::power::PowerServices::default()),
        tray: Arc::new(lucent_services::tray::StatusNotifier::default()),
        media: Arc::new(lucent_services::media::Mpris::default()),
        weather: Arc::new(OpenMeteo),
        wallpaper: Arc::new(LucentWallpaper),
        playback: Arc::new(lucent_services::video::NativeVideoWallpapers::default()),
        session: Arc::new(LucentSession),
        assets: Arc::new(NativeAssets),
        uri: Arc::new(lucent_services::applications::XdgUri),
        notifications: Arc::new(
            lucent_services::notifications::FreedesktopNotifications::with_history(Some(Arc::new(
                lucent_services::notifications::JsonNotificationHistory::default(),
            ))),
        ),
    }
}

pub fn request(&mut self, settings: &DesktopSettings, effects: &mut Effects<Message>) {
        let revision = self
            .latest
            .as_ref()
            .map_or(0, |snapshot| snapshot.revision.0);
        let Some(next) = revision.checked_add(1) else {
            self.error = "Preference revision limit reached; restart before editing again".into();
            Self::redraw(effects);
            return;
        };
        self.latest = Some(Arc::new(Snapshot {
            revision: Revision(next),
            settings: settings.clone(),
        }));
        // An in-flight write is never cancelled or overtaken. Pending snapshots
        // replace each other without adding tasks to the runtime queue.
        self.start(effects);
        Self::redraw(effects);
    }

#[derive(Clone)]
pub enum Message {
    Toggle,
    Close,
    Compacted(u64),
    Submitted {
        height: f32,
        now: f64,
    },
    Mode(Mode),
    Query(String),
    EditQuery(TextEdit),
    Select(usize),
    Navigate(i32),
    Activate,
    OpenActions(Application),
    SelectedActions,
    Back,
    SelectAction(usize),
    ChooseAction {
        menu: u64,
        action: ApplicationActionId,
    },
    ActionFinished {
        revision: u64,
        result: lucent_domain::Result<()>,
    },
    Request(Intent),
}

#[derive(Clone)]
pub enum Intent {
    Error(lucent_domain::DomainError),
    Launch(AppId, bool),
    LaunchAction {
        revision: u64,
        app: Application,
        action: ApplicationActionId,
    },
    Pin(AppId),
    Action(Action),
    Wallpaper(usize, bool),
    Browser(wallpaper_browser::Message),
    ToggleWidget(String),
    ResetLayout,
    EditWidgets(bool),
    Palette(ThemePalette),
    ExtractPalette,
    LauncherSize(LauncherSize),
}

fn update_launcher(&mut self, message: launcher::Message, effects: &mut Effects<Message>) {
        let was_open = self.launcher.open();
        let palettes = if self.launcher.mode() == Mode::Themes
            || matches!(message, launcher::Message::Mode(Mode::Themes))
        {
            self.palette_choices()
        } else {
            Vec::new()
        };
        let mut geometry = self.launcher_geometry();
        geometry.palettes = palettes.len();
        let input = launcher::Input {
            apps: &self.apps,
            application_status: self.catalog.status(),
            widgets_editing: self.active_widgets().editing(),
            settings: &self.settings,
            widget_layout: self
                .monitors
                .active
                .as_ref()
                .and_then(|id| self.settings.monitor_layouts.get(id))
                .unwrap_or(&self.settings.layout),
            palettes: &palettes,
            wallpapers: &self.wallpapers,
            wallpaper_index: self.wallpaper_index,
            browser: &self.browser,
        };
        let mut intent = None;
        effects.delegate(
            |child| intent = self.launcher.update(message, input, geometry, child),
            Message::Launcher,
        );
        self.update_dock(crate::dock::Message::Forced(self.launcher.open()), effects);
        self.panel_opened(Panel::Launcher, was_open, effects);
        if let Some(intent) = intent {
            use launcher::Intent;
            let message = match intent {
                Intent::Error(error) => Message::Completed(Err(error)),
                Intent::Launch(id, prefer) => Message::Launch(id, prefer),
                Intent::LaunchAction {
                    revision,
                    app,
                    action,
                } => {
                    self.launch_application_action(revision, app, action, effects);
                    return;
                }
                Intent::Pin(id) => Message::Dock(crate::dock::Message::Pin(id)),
                Intent::Action(action) => Message::Action(action),
                Intent::Wallpaper(index, apply) => Message::Wallpaper(index, apply),
                Intent::Browser(message) => Message::Browser(message),
                Intent::ToggleWidget(id) => Message::Widgets(widgets::Message::Toggle(id)),
                Intent::ResetLayout => Message::Widgets(widgets::Message::ResetLayout),
                Intent::EditWidgets(enabled) => {
                    self.update_launcher(launcher::Message::Close, effects);
                    Message::Widgets(widgets::Message::Edit(enabled))
                }
                Intent::Palette(palette) => Message::Palette(palette),
                Intent::ExtractPalette => Message::ExtractPalette,
                Intent::LauncherSize(size) => Message::LauncherSize(size),
            };
            self.update(message, effects);
        }
    }
    fn submitted_event(&self, event: Event) -> Option<Message> {
        match event {
            Event::FrameSubmitted {
                surface: "weather-controls",
                now,
                ..
            } if !self.weather.open() => {
                Some(Message::Weather(crate::weather::Message::Frame(now)))
            }
            Event::FrameSubmitted {
                surface: "background",
                now,
                ..
            } => Some(Message::BackgroundPresented(None, now)),
            Event::FrameSubmitted {
                surface: "live-wallpaper",
                now,
                ..
            } => Some(Message::LiveWallpaper(
                crate::live_wallpaper::Message::Frame(now),
            )),
            Event::FrameSubmitted {
                surface: "notifications",
                now,
                ..
            } if self.notifications.settled(now) => Some(Message::Notifications(
                crate::notifications::Message::Settled,
            )),
            Event::Scoped { instance, event } => {
                let route = self.monitors.route(&instance)?;
                match *event {
                    Event::FrameSubmitted {
                        surface: "background",
                        now,
                        ..
                    } => Some(Message::BackgroundPresented(Some(instance), now)),
                    event => self
                        .submitted_event(event)
                        .map(|message| Message::OnMonitor(route, Box::new(message))),
                }
            }
            event => self
                .launcher
                .event(event, self.browser.source.is_some())
                .map(Message::Launcher),
        }
    }
    pub fn active_widgets(&self) -> &widgets::Host {
        self.monitors
            .current()
            .map_or(&self.widgets, |(_, monitor)| &monitor.widgets)
    }
    pub fn widget_layout(&self, id: Option<&MonitorId>) -> &WidgetLayout {
        id.and_then(|id| self.settings.monitor_layouts.get(id))
            .unwrap_or(&self.settings.layout)
    }
    pub fn active_widget_layout(&self) -> &WidgetLayout {
        self.widget_layout(self.monitors.active.as_ref())
    }
    /// A logical widget can paint inside a differently named overlap group.
    /// Resolve current host membership, including frozen capture sources, rather
    /// than invalidating every surface in the widgets redraw group.
    fn redraw_widget(&self, widget: &str, effects: &mut Effects<Message>) {
        let mut redraw_host = |host: &widgets::Host,
                               layout: &WidgetLayout,
                               viewport: (f32, f32),
                               instance: Option<&SurfaceInstance>| {
            let mut visible = false;
            for source in host.surfaces(layout, viewport) {
                if source.members.contains(&widget) {
                    visible = true;
                    effects.redraw_surface(SurfaceAddress {
                        role: source.id,
                        instance: instance.cloned(),
                    });
                }
            }
            // Captured sources retain input only; the temporary full-host
            // preview paints every visible card and the decorative grid.
            if visible && host.grid_visible() {
                effects.redraw_surface(SurfaceAddress {
                    role: "widgets",
                    instance: instance.cloned(),
                });
            }
        };
        if self.monitors.legacy() {
            redraw_host(&self.widgets, &self.settings.layout, self.viewport, None);
        } else {
            for (id, monitor) in &self.monitors.connected {
                redraw_host(
                    &monitor.widgets,
                    self.widget_layout(Some(id)),
                    monitor.viewport,
                    Some(&monitor.instance),
                );
            }
        }
    }
    fn select_monitor(&mut self, id: &MonitorId, effects: &mut Effects<Message>) {
        let Some(monitor) = self.monitors.connected.get(id) else {
            return;
        };
        let viewport = monitor.viewport;
        if self.monitors.active.as_ref() == Some(id) && self.viewport == viewport {
            return;
        }
        effects.delegate(
            |child| self.media.update(crate::media::Message::CancelSeek, child),
            Message::Media,
        );
        self.monitors.active = Some(id.clone());
        self.viewport = viewport;
        self.update_dock(crate::dock::Message::Cancel, effects);
        self.retarget_panel_transition(effects.now);
        for role in [
            "bar",
            "dock",
            "audio",
            "media-controls",
            "weather-controls",
            "network",
            "bluetooth",
            "power",
            "displays",
            "tray",
            "notifications",
            "osd",
        ] {
            effects.redraw(role);
        }
    }
    fn explicitly_select_monitor(&mut self, id: &MonitorId, effects: &mut Effects<Message>) {
        if self.monitors.connected.contains_key(id) {
            self.monitors.pending_focus = None;
            self.select_monitor(id, effects);
        }
    }
    fn resize_monitor_background(&mut self, effects: &mut Effects<Message>) {
        match self.monitors.background_target() {
            Ok(Some(target)) => effects.delegate(
                |child| self.wallpaper.resize(target, child),
                Message::WallpaperSelection,
            ),
            Ok(None) => {}
            Err(error) => {
                self.error = error.to_string();
                effects.redraw("dock");
            }
        }
    }
    fn widget_view_on(&self, id: Option<&MonitorId>) -> widgets::View<'_> {
        let host = id
            .and_then(|id| self.monitors.connected.get(id))
            .map_or(&self.widgets, |monitor| &monitor.widgets);
        widgets::View {
            host,
            input: widgets::Input {
                layout: self.widget_layout(id),
                notes: &self.settings.notes,
                clock: &self.clock,
                system: &self.system,
                network_status: self.network.status(),
                media: &self.media,
                weather: &self.weather,
                save_status: self.persistence.status(self.settings_writable),
            },
            artwork: self.artwork(),
        }
    }

fn launch(&self, id: &AppId, prefer_running: bool, effects: &mut Effects<Message>) {
        let Some(app) = self.apps.iter().find(|a| &a.id == id).cloned() else {
            return;
        };
        let app_id = app
            .id
            .as_str()
            .strip_suffix(".desktop")
            .unwrap_or(app.id.as_str())
            .to_owned();
        effects.activation_token(Some(app_id), move |outcome| {
            Message::LaunchPrepared(app, prefer_running, outcome)
        });
    }
    fn launch_prepared(
        &self,
        app: domain::Application,
        prefer_running: bool,
        outcome: api::ActivationOutcome,
        effects: &mut Effects<Message>,
    ) {
        if !matches!(self.catalog.status(), crate::catalog::Status::Ready)
            || self.apps.iter().find(|entry| entry.id == app.id) != Some(&app)
        {
            return;
        }
        let context = launch_context(outcome);
        let apps = self.adapters.apps.clone();
        let hypr = self.adapters.compositor.clone();
        effects.task_on(crate::work::CONTROLS, move || {
            Message::Completed(if let Some(hypr) = hypr {
                lucent_usecases::activate_application_with_context(
                    apps.as_ref(),
                    hypr.as_ref(),
                    &app,
                    prefer_running,
                    context,
                )
            } else {
                apps.launch_with_context(&app, context)
            })
        });
    }
    fn launch_application_action(
        &mut self,
        revision: u64,
        app: domain::Application,
        action: ApplicationActionId,
        effects: &mut Effects<Message>,
    ) {
        let app_id = app
            .id
            .as_str()
            .strip_suffix(".desktop")
            .unwrap_or(app.id.as_str())
            .to_owned();
        effects.activation_token(Some(app_id), move |outcome| {
            Message::LaunchActionPrepared(revision, app, action, outcome)
        });
    }
    fn launch_application_action_prepared(
        &mut self,
        revision: u64,
        app: domain::Application,
        action: ApplicationActionId,
        outcome: api::ActivationOutcome,
        effects: &mut Effects<Message>,
    ) {
        let mut current = self.apps.iter().filter(|entry| entry.id == app.id);
        if !matches!(self.catalog.status(), crate::catalog::Status::Ready)
            || current.next() != Some(&app)
            || current.next().is_some()
        {
            self.update_launcher(
                launcher::Message::ActionFinished {
                    revision,
                    result: Err(DomainError::Invalid(
                        "Application actions changed; open them again".into(),
                    )),
                },
                effects,
            );
            return;
        }
        let apps = self.adapters.apps.clone();
        let context = launch_context(outcome);
        effects.task_on_with_failure(
            crate::work::CONTROLS,
            move || {
                Message::Launcher(launcher::Message::ActionFinished {
                    revision,
                    result: lucent_usecases::applications::application_action(&app, &action)
                        .and_then(|_| apps.launch_action_with_context(&app, &action, context)),
                })
            },
            move |failure| {
                Message::Launcher(launcher::Message::ActionFinished {
                    revision,
                    result: Err(DomainError::Failed(format!(
                        "Application action outcome is uncertain: {failure}"
                    ))),
                })
            },
        );
    }

#[derive(Clone)]
pub enum Message {
    Toggle(String),
    Show(String),
    Move(String, DragEvent),
    Resize(String, DragEvent),
    Size(String, WidgetSize),
    SizeStep(String, i32),
    Edit(bool),
    Press,
    EditNotes(TextEdit),
    ScrollNotes(ScrollEvent),
    RetrySave,
    TimerToggle,
    TimerReset,
    Tick(u64),
    Month(i32),
    ResetLayout,
    /// Cancel capture before its output or loaded configuration changes.
    CancelDrags,
    Media(crate::media::Message),
    Weather(crate::weather::Message),
}
pub enum Intent {
    Save,
    RetrySave,
    Media(crate::media::Message),
    Weather(crate::weather::Message),
    Error(lucent_domain::DomainError),
}
/// Preferences remain in the root aggregate. The child borrows them for this
/// update rather than maintaining a second persisted copy.
pub struct Update<'a> {
    pub layout: &'a mut WidgetLayout,
    pub notes: &'a mut String,
    pub instance: Option<lucent_api::SurfaceInstance>,
    pub viewport: (f32, f32),
    pub unix_seconds: u64,
}
#[derive(Clone, Copy)]
enum Drag {
    Active {
        origin: Placement,
        preview: Placement,
    },
    // Ignore the rest of a gesture after hide/reset/invalid input. Its final
    // release removes this marker; a subsequent press can start a new drag.
    Cancelled,
}

fn update_widgets(&mut self, message: widgets::Message, effects: &mut Effects<Message>) {
        let selected = self.monitors.active.clone();
        self.update_widgets_on(selected.as_ref(), message, effects);
    }
    fn update_widgets_on(
        &mut self,
        id: Option<&MonitorId>,
        message: widgets::Message,
        effects: &mut Effects<Message>,
    ) {
        if let (Some(id), widgets::Message::Tick(now)) = (id, &message) {
            let layout = self
                .settings
                .monitor_layouts
                .get(id)
                .unwrap_or(&self.settings.layout);
            let Some(monitor) = self.monitors.connected.get_mut(id) else {
                return;
            };
            if monitor
                .widgets
                .tick(*now, layout.visible_widgets.iter().any(|id| id == "timer"))
            {
                for source in monitor.widgets.surfaces(layout, monitor.viewport) {
                    effects.redraw_surface(
                        SurfaceAddress::new(source.id).instance(monitor.instance.clone()),
                    );
                }
            }
            return;
        }
        let mut intent = None;
        let route = id.and_then(|id| {
            self.monitors
                .connected
                .get(id)
                .map(|monitor| monitor.route(id))
        });
        let instance = route
            .as_ref()
            .and_then(|route| self.monitors.connected.get(&route.id))
            .map(|monitor| monitor.instance.clone());
        let shared_notes = matches!(message, widgets::Message::EditNotes(_));
        let (host, layout, viewport) = if let Some(route) = &route {
            if let Err(error) =
                lucent_usecases::ensure_monitor_layout(&mut self.settings, &route.id)
            {
                self.error = error.to_string();
                effects.redraw("dock");
                return;
            }
            let layout = self
                .settings
                .monitor_layouts
                .get_mut(&route.id)
                .expect("initialized monitor layout");
            let monitor = self
                .monitors
                .connected
                .get_mut(&route.id)
                .expect("current route");
            (&mut monitor.widgets, layout, monitor.viewport)
        } else {
            (&mut self.widgets, &mut self.settings.layout, self.viewport)
        };
        effects.delegate(
            |child| {
                intent = host.update(
                    message,
                    widgets::Update {
                        layout,
                        notes: &mut self.settings.notes,
                        instance: instance.clone(),
                        viewport,
                        unix_seconds: self.clock.unix_seconds,
                    },
                    child,
                );
                if let Some(instance) = &instance
                    && !shared_notes
                    && child.redraw.remove("widgets")
                {
                    child.redraw_surface(SurfaceAddress::new("widgets").instance(instance.clone()));
                    for source in host.surfaces(layout, viewport) {
                        child.redraw_surface(
                            SurfaceAddress::new(source.id).instance(instance.clone()),
                        );
                    }
                }
            },
            move |message| match &route {
                Some(route) => {
                    Message::OnMonitor(route.clone(), Box::new(Message::Widgets(message)))
                }
                None => Message::Widgets(message),
            },
        );
        match intent {
            Some(widgets::Intent::Save) => self.save(effects),
            Some(widgets::Intent::RetrySave) => self.update(
                Message::Persistence(crate::persistence::Message::Retry),
                effects,
            ),
            Some(widgets::Intent::Media(message)) => self.update(Message::Media(message), effects),
            Some(widgets::Intent::Weather(message)) => {
                self.update(Message::Weather(message), effects)
            }
            Some(widgets::Intent::Error(error)) => {
                self.error = error.to_string();
                effects.redraw("dock");
            }
            None => {}
        }
    }