### `wai.live.remote`: a remote desktop in a room

- **The extension** ([remote-desktop](extensions/remote-desktop.md)): a host publishes its screen
  as the room's `screen` track and signs screen statements (`WDS1`) naming what it captures, the
  frame size every input's coordinates are in, the actions it injects, the oldest an action may
  be, whether it keeps a floor, and the encoder that made the frames with its version, as
  packaging §7 (paragraph 7.5) has a floor name one; no rule reads the encoder, and no verifier
  recomputes a frame. Input statements (`WDI1`) carry up to 32 pointer, button, wheel, key (HID
  usage IDs), text, touch and clipboard actions. A host decides each input by the seven rules of
  §5.3 at its place in the merged order and signs an outcome (`WDO1`) for every input it
  receives, anchored on the first frame it captured after injecting it, or refused with the
  rule's number; a verifier recomputes it. Control passes by grant exchange or by floor
  statements (`WDF1`). Latency records (`WDL1`) state an action's instant and its frame's
  presentation on the viewer's estimate, signed on their own, and a verifier states the three
  legs. Two grant attributes, `remote_host` and `remote_control` (the control power), and no new
  power bit, since live-rooms §3.4 refuses one.
- **The reference** (`wai-rs`, feature `remote_desktop`): the statements, the rules
  (`remote_desktop::decide`, which the host agent runs), and the verifier; the corpus
  `live-conformance/remote/` (`wai_remote_desktop_vectors gen`): a floor session and an open
  session whose control passes by grant exchange, a gap, and refused vectors giving every reason
  of §12, among them a host applying an input that each rule refuses; and its second
  implementation, `remote_desktop_verify.py`, which shares no code with `wai-rs`, agrees with it
  on every vector, fails every mutated copy of the corpus, and catches each of its own checks
  dropped.
- **The host agent** (`joule-moq-remote`) captures a screen, encodes it with the platform's
  encoder, publishes it to a room through `joule-moq-relay` with its receipts, decides every
  input with `wai-rs`'s rules and injects what they accept; the room page of `joule-moq-web`
  shows a host's screen, sends input under its grant, and signs latency records.
- **A floor statement the floor's rules refuse changes nothing** (§7.2, §7.3): it stays in its
  author's chain, a verifier states it with its reason (`floor_not_permitted`,
  `floor_not_eligible`, `floor_not_holder`, now §12's third table) and computes the floor without
  it, and a host gives it no effect, so a holder's release that crosses the host's take on the
  wire leaves a session that verifies. `wai-rs` exports the rule (`remote_desktop::floor_rule`),
  which the host agent and the room service's clock both run. The corpus states `floor_refused`;
  its six vectors of a refused floor statement, their rooms unchanged, are accepted, and three
  whole floor sessions follow them: a give by a controller that does not hold the floor, a
  release by one, and a late release.
- **Remote rooms a room service keeps** (`joule-moq-room` with `[remote]`): the service grants
  the host, each controller and each viewer for a key the visitor makes, hands control over by
  the host's grant exchange, watches the host's screen track, takes every principal's records in
  their chains' order, and serves the session's records to a principal of the room alone; the
  host agent joins such a room (`run --room`), and the room page makes its key and asks for its
  grant.

