# Splitting `State`

A sketch for review item 1. Nothing here is built yet.

## Shape

```rust
pub struct State {
    pub backend: Backend,
    pub renderer: VulkanRenderer,
    pub wm: Wm,
    pub input: Input,
    pub services: Services,
    pub protocols: Protocols,
    pub config: Settings,
    pub dirty: Dirty,
    pub core: Core,
}
```

smithay requires every handler trait on `State`, and that stays. The `*_state(&mut self)` accessors just reach one level deeper. What changes is that functions take the sub-structs they need instead of `&mut State`, and disjoint borrows stop needing a 15-field destructure.

### `Core`

`display`, `handle`, `signal`, `socket_name`, `start`. These are the event loop and Wayland display plumbing that everything needs and nothing owns.

### `Backend`

```rust
pub enum Backend {
    Drm(Drm),
    Nested(Nested),
    // Headless(Headless) later, for tests and the smoke harness.
}
```

What shared code needs from it:

- `output(OutputId) -> Option<&Output>` and `outputs()`. This replaces `smithay_output`, the nested-only `output_id` field and `drm::output_for`. Each backend keeps its own `OutputId -> Output` map.
- `render_node() -> Option<DrmNode>`, replacing the `render_node` field.
- `syncobj()`, replacing the `syncobj` field. It exists only on DRM.
- `session()` for VT switching and the "is the session active" check. It returns `None` when nested.
- `render(state)`. Each backend keeps its own pacing and presentation (deadline scheduler or host frame callbacks) and calls the shared frame path for content.

`after_dispatch` matches once instead of calling both backends' render and letting one no-op.

### `Wm`, the window model

```rust
pub struct Wm {
    pub layout: Layout,
    pub windows: SecondaryMap<WindowId, Managed>,
    by_surface: HashMap<ObjectId, WindowId>,
    pub unmapped: Vec<Window>,
    pub space: Space<Window>,
    pub popups: PopupManager,
    pub anim: Animator,
    pub layer_focus: Option<WlSurface>,
}

pub struct Managed {
    pub window: Window,
    /// What the last layout pass configured, to spot tiled, floating and
    /// fullscreen switches.
    pub placed: Option<(Kind, Rect, OutputId)>,
    pub awaiting_buffer: bool,
    pub placed_by_rule: bool,
    pub list_handle: ForeignToplevelHandle,
    pub borders: [SolidColorBuffer; 4],
    /// Cached so publishers notice changes on commit instead of polling.
    pub app_id: String,
    pub title: String,
}
```

- **`SecondaryMap` keyed by the layout's `WindowId`.** Layout already owns that key space, and the window model becomes a typed extension of it, not a parallel `HashMap`.
- **`by_surface` gives O(1) lookup by root surface.** It replaces `window_id`, `x11_window_id`, the toplevel key search and `ListHandles::window`. X11 windows join it when xwayland-shell associates their surface.
- **One method each for adding and removing.** `Wm::insert` and `Wm::remove(id) -> Option<Managed>` are the only ways in and out. Removal drops the index entry, sends the list handle `closed`, and tells the animator to forget the window. Nothing can be left behind in another map.
- **Kept per window:**
  - `last_kind`, now `placed`
  - `awaiting`
  - `placed_by_rule`
  - `scene::Borders`
  - `ListHandles`
  - the polled title and app id
- **Not moved into the record:** the animator's per-output tracks are multi-window plans, so they stay in `Animator`. Its per-window glides and spawns could move into the record, but keeping all motion state in one place is easier to reason about. Ghost textures move from `Animator` to the scene, so the animator holds only geometry and time.
- `unmapped` stays a plain `Vec<Window>`. These windows have no `WindowId` until their first commit, which is when rules can see their app id.
- Methods that are about windows move from `state.rs` to `wm.rs`: `map_window`, `remove_window`, the pure half of `apply_layout` (diffing placements into glides, retargets and configures), `configure`, `root`, `identity` and close.

### `Input`

`seat`, `seat_state`, `pointer_pos`, `suppressed`, `drag`, `move_inverted`, `cursor` (the xcursor images) and `cursor_status`.

### `Services`

The subsystems that already have their own types, gathered so their fields stop sprawling:

- `lock`
- `captures`
- `imports`
- `xwayland`
- `launches`
- `ipc`
- `idle`, a new struct of `notifier`, `inhibitors` and `inhibited`

### `Protocols`

The inert globals: `compositor`, `xdg_shell`, `layer_shell`, `xdg_decoration`, `shm`, `dmabuf` plus its global, `output_manager`, the three capture states, `activation`, the three selection states, `session_lock`, `idle_inhibit`, `cursor_shape`, `xwayland_shell`, `data_device`.

The publishers go here too: `workspaces`, `foreign_toplevels` and `toplevel_list`. Their sync code moves to a `publish.rs` that reads `Wm` (item 3).

### `Settings`

`config`, `config_path`, `binds`. Reload swaps this whole struct.

### `Dirty`

```rust
pub struct Dirty {
    pub redraw: bool,
    pub cursor: bool,
    /// Something clients see changed: windows, titles, tags, focus.
    pub snapshot: bool,
}
```

`needs_redraw` and `cursor_moved` move here. `snapshot` gates the three publishers (item 3).

## The frame path this enables (item 2)

```rust
pub fn compose(ctx: FrameCtx<'_>, output: &Output, o: OutputId, now: u64) -> Vec<Draw>
pub fn send_frame_callbacks(wm: &Wm, services: &Services, output: &Output, elapsed: Duration)
```

`FrameCtx` borrows `&mut renderer`, `&mut wm` (for the border buffers), `&input` (for the cursor), `&services.lock`, `&config.decoration` and the unmanaged X11 list. DRM, nested and capture all call `compose`. `anim.prune` moves to `after_dispatch`, after every output has drawn.

## Migration

Every step compiles and passes `nix flake check` on its own.

1. `Protocols`, `Core`, `Settings`. This is pure field moves and accessor updates, with no logic changes.
2. `Services` and `Idle`.
3. `Backend` enum, folding in `output_id`, `render_node` and `syncobj`.
4. `Wm` with `Managed` and `by_surface`. This is the one with logic: insert and remove, and lookups through the index.
5. `Input` and `Dirty`.
6. The frame path (item 2) and publishers (item 3) on top.

## Open questions

- **Name the record `Managed` or `WindowState`?** smithay already has a `Window`, and layout has `layout::Window`. `Managed` avoids a third `Window`.
- **Keep `Space<Window>`?** It is used for hit testing, output enter and leave, and `element_under`. monolith positions everything itself, so Space mostly mirrors layout. Replacing it with our own hit test over the layout arrangement is possible, but not part of this split.
- **Does `layer_focus` belong in `Wm` or `Input`?** It is keyboard focus policy, which sits next to `sync_focus` in `Wm`, so this sketch puts it there.