feat: add headless automation protocol and CLI
Intrepid/Prometeu/Runtime/pipeline/head This commit looks good
Intrepid/Prometeu/Runtime/pipeline/pr-master This commit looks good

This commit is contained in:
2026-09-28 15:36:22 +01:00
parent e8e4d64e42
commit 4f10f6e584
20 changed files with 3310 additions and 18 deletions
@@ -12,6 +12,12 @@ prometeu-drivers = { path = "../../console/prometeu-drivers" }
prometeu-firmware = { path = "../../console/prometeu-firmware" }
prometeu-hal = { path = "../../console/prometeu-hal" }
prometeu-system = { path = "../../console/prometeu-system" }
prometeu-vm = { path = "../../console/prometeu-vm" }
serde = { version = "1", features = ["derive"] }
serde_json = "1"
base64 = "0.22"
png = "0.17"
getrandom = "0.3"
[[bench]]
name = "temporal"
@@ -0,0 +1,406 @@
//! Versioned external tooling boundary; the host API itself remains synchronous.
mod wire;
pub use wire::Limits;
use crate::{AdvanceFrameOutcome, HeadlessHost};
use serde_json::{Value, json};
use std::io::{self, BufRead, Write};
use std::sync::{Arc, Mutex, mpsc};
use wire::{CAPABILITIES, Command, Request, WireError};
#[derive(Default)]
struct Control {
active: Option<String>,
advancing: bool,
canceled: bool,
}
enum Job {
Work(String, Command),
Stop(Option<String>),
ReadError(io::Error),
}
struct Output<W> {
writer: Mutex<W>,
session: String,
limit: usize,
}
impl<W: Write> Output<W> {
fn send(&self, value: Value) -> io::Result<()> {
let mut bytes = serde_json::to_vec(&value)?;
if bytes.len() > self.limit {
bytes = serde_json::to_vec(&json!({"type":"response","sessionId":self.session,
"requestId":value.get("requestId"),"error":{"code":"response_too_large",
"message":"response exceeds configured limit","details":{"maxResponseBytes":self.limit}}}))?;
}
if bytes.len() > self.limit {
return Err(io::Error::other("response limit cannot contain error"));
}
let mut writer = self.writer.lock().map_err(|_| io::Error::other("output poisoned"))?;
writer.write_all(&bytes)?;
writer.write_all(b"\n")?;
writer.flush()
}
fn reply(&self, id: Option<&str>, result: Result<Value, WireError>) -> io::Result<()> {
let mut value = json!({"type":"response","sessionId":self.session,"requestId":id});
match result {
Ok(r) => value["result"] = r,
Err(e) => value["error"] = serde_json::to_value(e)?,
}
self.send(value)
}
}
enum Line {
Data(Vec<u8>),
Oversized,
Truncated,
Eof,
}
/// Consume at most one line without ever accumulating more than the configured bound.
fn read_line(reader: &mut impl BufRead, limit: usize) -> io::Result<Line> {
let mut bytes = Vec::new();
let mut oversized = false;
loop {
let chunk = reader.fill_buf()?;
if chunk.is_empty() {
return Ok(if oversized {
Line::Oversized
} else if bytes.is_empty() {
Line::Eof
} else {
Line::Truncated
});
}
let newline = chunk.iter().position(|b| *b == b'\n');
let length = newline.unwrap_or(chunk.len());
if !oversized {
if length > limit.saturating_sub(bytes.len()) {
oversized = true;
bytes.clear();
} else {
bytes.extend_from_slice(&chunk[..length]);
}
}
reader.consume(length + usize::from(newline.is_some()));
if newline.is_some() {
if bytes.last() == Some(&b'\r') {
bytes.pop();
}
return Ok(if oversized { Line::Oversized } else { Line::Data(bytes) });
}
}
}
fn read_commands<R: BufRead, W: Write>(
mut input: R,
output: &Output<W>,
control: &Mutex<Control>,
sender: &mpsc::Sender<Job>,
limits: &Limits,
) -> io::Result<()> {
let mut initialized = false;
loop {
let bytes = match read_line(&mut input, limits.max_command_bytes)? {
Line::Eof => break,
Line::Truncated => {
output.reply(None, Err(WireError::new("invalid_request", "EOF before LF")))?;
break;
}
Line::Oversized => {
output.reply(
None,
Err(WireError::new("request_too_large", "command exceeds configured limit")),
)?;
continue;
}
Line::Data(bytes) => bytes,
};
let raw: Value = match serde_json::from_slice(&bytes) {
Ok(value) => value,
Err(error) => {
output.reply(None, Err(WireError::new("invalid_request", error.to_string())))?;
continue;
}
};
let id = raw
.get("requestId")
.and_then(Value::as_str)
.filter(|id| wire::valid_id(id))
.map(str::to_owned);
let request = serde_json::from_value::<Request>(raw)
.map_err(|e| WireError::new("invalid_request", e.to_string()))
.and_then(wire::parse);
let (id, command) = match request {
Ok(value) => value,
Err(error) => {
output.reply(id.as_deref(), Err(error))?;
continue;
}
};
if let Command::Shutdown = command {
let mut c = control.lock().unwrap();
c.canceled = true;
sender.send(Job::Stop(Some(id))).map_err(|_| io::Error::other("execution stopped"))?;
return Ok(());
}
if let Command::Initialize(params) = command {
let result = if initialized {
Err(WireError::new("already_initialized", "session already initialized"))
} else if params.protocol_version.major != 1 {
Err(WireError::new("incompatible_version", "protocol major must be 1"))
} else if params
.required_capabilities
.iter()
.any(|c| !CAPABILITIES.contains(&c.as_str()))
{
Err(WireError::new("unsupported_capability", "required capability unavailable"))
} else {
initialized = true;
Ok(json!({"protocolVersion":{"major":1,"minor":0},"capabilities":CAPABILITIES}))
};
output.reply(Some(&id), result)?;
continue;
}
if !initialized {
output.reply(Some(&id), Err(WireError::new("not_initialized", "initialize first")))?;
continue;
}
let mut c = control.lock().unwrap();
if let Command::Cancel(params) = command {
let result = if c.advancing && c.active.as_deref() == Some(&params.target_request_id) {
c.canceled = true;
Ok(json!({"targetRequestId":params.target_request_id,"requested":true}))
} else {
Err(WireError::new("not_cancelable", "no matching active advance"))
};
output.reply(Some(&id), result)?;
continue;
}
if c.active.is_some() {
output.reply(Some(&id), Err(WireError::new("busy", "a host operation is active")))?;
continue;
}
if let Command::Advance(params) = &command
&& params.frames > limits.max_frames
{
output.reply(
Some(&id),
Err(WireError::new("limit_exceeded", "frames exceeds maxFrames")),
)?;
continue;
}
c.active = Some(id.clone());
c.advancing = matches!(command, Command::Advance(_));
c.canceled = false;
sender.send(Job::Work(id, command)).map_err(|_| io::Error::other("execution stopped"))?;
}
let mut c = control.lock().unwrap();
c.canceled = true;
sender.send(Job::Stop(None)).map_err(|_| io::Error::other("execution stopped"))
}
fn execute<W: Write>(
host: &mut HeadlessHost,
command: Command,
id: &str,
output: &Output<W>,
control: &Mutex<Control>,
) -> io::Result<Result<Value, WireError>> {
Ok(match command {
Command::Boot(p) => {
host.boot(p.path).map(|()| wire::state(host.get_state())).map_err(wire::host_error)
}
Command::Reset => {
host.reset();
Ok(wire::state(host.get_state()))
}
Command::SetInput(p) => {
host.set_input(p.into());
Ok(json!({}))
}
Command::ClearInput => {
host.clear_input();
Ok(json!({}))
}
Command::GetState => Ok(wire::state(host.get_state())),
Command::GetFault => Ok(host.get_fault().as_ref().map(wire::fault).unwrap_or(Value::Null)),
Command::Capture => host.capture_frame().map_err(wire::host_error).and_then(wire::capture),
Command::Advance(p) => {
let mut result = json!({"requested":p.frames,"completed":0,"stop":"completed"});
for completed in 0..p.frames {
if control.lock().unwrap().canceled {
result["stop"] = json!("canceled");
break;
}
match host.advance_frame() {
Ok(AdvanceFrameOutcome::FrameCompleted { .. }) => {
result["completed"] = json!(completed + 1);
output.send(
json!({"type":"progress","sessionId":output.session,"requestId":id,
"requested":p.frames,"completed":completed + 1}),
)?;
}
Ok(AdvanceFrameOutcome::Faulted(report)) => {
result["stop"] = json!("faulted");
result["fault"] = wire::fault(&report);
break;
}
Ok(AdvanceFrameOutcome::Terminated) => {
result["stop"] = json!("terminated");
break;
}
Err(error) => {
result["stop"] = json!("host_error");
result["error"] = serde_json::to_value(wire::host_error(error))?;
break;
}
}
}
Ok(result)
}
_ => unreachable!("reader handles control commands"),
})
}
/// Serve one process session. The input reader stays responsive while the owner
/// executes a frame. On fatal output failure the process caller must exit; a
/// blocking OS stdin reader cannot be joined until that input is closed.
pub fn serve<R: BufRead + Send + 'static, W: Write + Send + 'static>(
input: R,
writer: W,
limits: Limits,
runtime_version: &str,
) -> io::Result<()> {
limits.validate()?;
let mut random = [0u8; 16];
getrandom::fill(&mut random).map_err(|e| io::Error::other(e.to_string()))?;
let session: String = random.iter().map(|v| format!("{v:02x}")).collect();
let output =
Arc::new(Output { writer: Mutex::new(writer), session, limit: limits.max_response_bytes });
output.send(
json!({"type":"hello","sessionId":output.session,"protocolVersion":{"major":1,"minor":0},
"runtimeVersion":runtime_version,"capabilities":CAPABILITIES,"limits":limits}),
)?;
let control = Arc::new(Mutex::new(Control::default()));
let (sender, receiver) = mpsc::channel();
let reader_output = output.clone();
let reader_control = control.clone();
let reader = std::thread::spawn(move || {
if let Err(error) = read_commands(input, &reader_output, &reader_control, &sender, &limits)
{
reader_control.lock().unwrap().canceled = true;
let _ = sender.send(Job::ReadError(error));
}
});
let mut host = HeadlessHost::new();
while let Ok(job) = receiver.recv() {
match job {
Job::Work(id, command) => {
let result = execute(&mut host, command, &id, &output, &control)?;
// Release authority under the same lock as response publication:
// a client reacting to this reply cannot race a stale busy flag.
let mut c = control.lock().unwrap();
output.reply(Some(&id), result)?;
c.active = None;
c.advancing = false;
}
Job::Stop(id) => {
drop(host);
if let Some(id) = id {
output.reply(Some(&id), Ok(json!({"closed":true})))?;
}
reader.join().map_err(|_| io::Error::other("input reader panicked"))?;
return Ok(());
}
Job::ReadError(error) => return Err(error),
}
}
reader.join().map_err(|_| io::Error::other("input reader panicked"))?;
Ok(())
}
#[cfg(test)]
mod tests {
use super::*;
use std::io::{BufReader, Cursor};
#[test]
fn bounded_lines_accept_fragmentation_and_recover_after_oversize() {
let mut reader = BufReader::with_capacity(2, Cursor::new(b"12345\n123456\nok\r\n"));
assert!(matches!(read_line(&mut reader, 5).unwrap(), Line::Data(v) if v == b"12345"));
assert!(matches!(read_line(&mut reader, 5).unwrap(), Line::Oversized));
assert!(matches!(read_line(&mut reader, 5).unwrap(), Line::Data(v) if v == b"ok"));
assert!(matches!(read_line(&mut reader, 5).unwrap(), Line::Eof));
assert!(matches!(read_line(&mut Cursor::new(b"no LF"), 10).unwrap(), Line::Truncated));
}
#[test]
fn input_snapshot_is_replacement_and_rejects_unknown_fields() {
let input: wire::Input = serde_json::from_value(json!({"right":true})).unwrap();
let signals: prometeu_hal::InputSignals = input.into();
assert!(signals.right_signal);
assert!(!signals.left_signal);
assert_eq!(signals.x_pos, 0);
assert!(serde_json::from_value::<wire::Input>(json!({"rigth":true})).is_err());
}
#[test]
fn response_limit_counts_the_complete_envelope_and_keeps_correlation() {
let output =
Output { writer: Mutex::new(Vec::new()), session: "session".into(), limit: 4096 };
output.reply(Some("capture"), Ok(json!({"data":"x".repeat(4096)}))).unwrap();
let bytes = output.writer.into_inner().unwrap();
assert!(bytes.len() <= 4097);
let result: Value = serde_json::from_slice(&bytes).unwrap();
assert_eq!(result["requestId"], "capture");
assert_eq!(result["sessionId"], "session");
assert_eq!(result["error"]["code"], "response_too_large");
assert!(result.get("result").is_none());
}
#[test]
fn distributed_request_fixtures_are_accepted_by_the_actual_parser() {
let requests: Vec<Value> = serde_json::from_str(include_str!(
"../../../../../devtools/headless-protocol/requests.json"
))
.unwrap();
assert_eq!(requests.len(), 11);
for request in requests {
wire::parse(serde_json::from_value(request).unwrap()).unwrap();
}
}
#[test]
fn capture_preserves_independent_ids_and_excludes_padding_without_channel_loss() {
use base64::Engine as _;
use prometeu_hal::app_mode::AppMode;
use prometeu_hal::{FrameId, OwnedRgba8888Frame, RenderOwnership};
let frame = OwnedRgba8888Frame::new(
FrameId::new(91),
RenderOwnership::new(1, AppMode::Game, 41),
1,
2,
2,
vec![0x12345678, 0xffffffff, 0xabcdef01, 0xffffffff],
)
.unwrap();
let capture =
wire::capture(crate::CapturedFrame { logical_frame_index: 7, frame }).unwrap();
assert_eq!(capture["logicalFrameIndex"], 7);
assert_eq!(capture["frameId"], 91);
assert_eq!(capture["stridePixels"], 2);
let png = base64::engine::general_purpose::STANDARD
.decode(capture["data"].as_str().unwrap())
.unwrap();
let mut reader = png::Decoder::new(Cursor::new(png)).read_info().unwrap();
let mut bytes = vec![0; reader.output_buffer_size()];
let info = reader.next_frame(&mut bytes).unwrap();
assert_eq!((info.width, info.height), (1, 2));
assert_eq!(&bytes[..info.buffer_size()], &[0x12, 0x34, 0x56, 0x78, 0xab, 0xcd, 0xef, 0x01]);
}
}
@@ -0,0 +1,330 @@
use base64::{Engine as _, engine::general_purpose::STANDARD};
use prometeu_bytecode::Value as VmValue;
use prometeu_hal::InputSignals;
use prometeu_system::CrashReport;
use prometeu_vm::VmInitError;
use serde::{Deserialize, Serialize};
use serde_json::{Value, json};
use std::io;
use crate::{CapturedFrame, HostError, HostExecutionStatus, HostState};
pub const CAPABILITIES: &[&str] = &[
"boot",
"reset",
"set_input",
"clear_input",
"advance",
"capture",
"get_state",
"get_fault",
"cancel",
"shutdown",
];
#[derive(Clone, Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct Limits {
pub max_frames: u64,
pub max_command_bytes: usize,
pub max_response_bytes: usize,
pub handshake_timeout_ms: u64,
pub call_timeout_ms: u64,
pub shutdown_timeout_ms: u64,
}
impl Default for Limits {
fn default() -> Self {
Self {
max_frames: 600,
max_command_bytes: 64 * 1024,
max_response_bytes: 32 * 1024 * 1024,
handshake_timeout_ms: 5_000,
call_timeout_ms: 60_000,
shutdown_timeout_ms: 5_000,
}
}
}
impl Limits {
pub fn validate(&self) -> io::Result<()> {
if self.max_frames == 0
|| self.max_command_bytes < 4096
|| self.max_response_bytes < 4096
|| self.handshake_timeout_ms == 0
|| self.call_timeout_ms == 0
|| self.shutdown_timeout_ms == 0
{
return Err(io::Error::new(
io::ErrorKind::InvalidInput,
"limits must be positive and message bounds at least 4096 bytes",
));
}
Ok(())
}
}
#[derive(Debug, Deserialize)]
#[serde(deny_unknown_fields, rename_all = "camelCase")]
pub(super) struct Request {
pub request_id: String,
pub command: String,
pub params: Value,
}
pub(super) fn valid_id(id: &str) -> bool {
!id.is_empty() && id.len() <= 128
}
#[derive(Debug, Deserialize, Serialize)]
#[serde(deny_unknown_fields)]
pub(super) struct Version {
pub major: u32,
pub minor: u32,
}
#[derive(Debug, Deserialize)]
#[serde(deny_unknown_fields, rename_all = "camelCase")]
pub(super) struct Initialize {
pub protocol_version: Version,
pub required_capabilities: Vec<String>,
}
#[derive(Debug, Deserialize)]
#[serde(deny_unknown_fields)]
pub(super) struct Boot {
pub path: String,
}
#[derive(Debug, Deserialize)]
#[serde(deny_unknown_fields)]
pub(super) struct Advance {
pub frames: u64,
}
#[derive(Debug, Deserialize)]
#[serde(deny_unknown_fields, rename_all = "camelCase")]
pub(super) struct Cancel {
pub target_request_id: String,
}
#[derive(Debug, Default, Deserialize)]
#[serde(default, deny_unknown_fields, rename_all = "camelCase")]
pub(super) struct Input {
up: bool,
down: bool,
left: bool,
right: bool,
a: bool,
b: bool,
x: bool,
y: bool,
l: bool,
r: bool,
start: bool,
select: bool,
touch: bool,
touch_x: i32,
touch_y: i32,
}
impl From<Input> for InputSignals {
fn from(s: Input) -> Self {
Self {
up_signal: s.up,
down_signal: s.down,
left_signal: s.left,
right_signal: s.right,
a_signal: s.a,
b_signal: s.b,
x_signal: s.x,
y_signal: s.y,
l_signal: s.l,
r_signal: s.r,
start_signal: s.start,
select_signal: s.select,
f_signal: s.touch,
x_pos: s.touch_x,
y_pos: s.touch_y,
}
}
}
#[derive(Debug)]
pub(super) enum Command {
Initialize(Initialize),
Boot(Boot),
Reset,
SetInput(Input),
ClearInput,
Advance(Advance),
Capture,
GetState,
GetFault,
Cancel(Cancel),
Shutdown,
}
fn params<T: serde::de::DeserializeOwned>(value: Value) -> Result<T, WireError> {
serde_json::from_value(value).map_err(|e| WireError::new("invalid_params", e.to_string()))
}
fn empty(value: &Value) -> Result<(), WireError> {
if value.as_object().is_some_and(|v| v.is_empty()) {
Ok(())
} else {
Err(WireError::new("invalid_params", "expected an empty params object"))
}
}
pub(super) fn parse(req: Request) -> Result<(String, Command), WireError> {
if !valid_id(&req.request_id) {
return Err(WireError::new("invalid_request", "requestId must contain 1..128 UTF-8 bytes"));
}
let command = match req.command.as_str() {
"initialize" => Command::Initialize(params(req.params)?),
"boot" => {
let p: Boot = params(req.params)?;
if p.path.trim().is_empty() {
return Err(WireError::new("invalid_params", "path is empty"));
}
Command::Boot(p)
}
"advance" => Command::Advance(params(req.params)?),
"set_input" => Command::SetInput(params(req.params)?),
"cancel" => {
let p: Cancel = params(req.params)?;
if !valid_id(&p.target_request_id) {
return Err(WireError::new("invalid_params", "invalid targetRequestId"));
}
Command::Cancel(p)
}
"reset" | "clear_input" | "capture" | "get_state" | "get_fault" | "shutdown" => {
empty(&req.params)?;
match req.command.as_str() {
"reset" => Command::Reset,
"clear_input" => Command::ClearInput,
"capture" => Command::Capture,
"get_state" => Command::GetState,
"get_fault" => Command::GetFault,
_ => Command::Shutdown,
}
}
_ => return Err(WireError::new("unknown_command", "unknown command")),
};
Ok((req.request_id, command))
}
#[derive(Debug, Serialize)]
pub(super) struct WireError {
pub code: &'static str,
pub message: String,
pub details: Value,
}
impl WireError {
pub fn new(code: &'static str, message: impl Into<String>) -> Self {
Self { code, message: message.into(), details: json!({}) }
}
}
pub(super) fn host_error(error: HostError) -> WireError {
let (code, details) = match &error {
HostError::AlreadyBooted => ("already_booted", json!({})),
HostError::BootFailed { reason, report } => {
("boot_failed", json!({"reason":reason,"fault":report.as_ref().map(fault)}))
}
HostError::InvalidState { operation, status } => {
("invalid_state", json!({"operation":operation,"status":status_name(*status)}))
}
HostError::FrameAdvanceWatchdogExpired { host_tick_limit } => {
("watchdog_expired", json!({"hostTickLimit":host_tick_limit}))
}
HostError::FrameNotPublished { previous } => {
("frame_not_published", json!({"previousFrameId":previous.map(|id| id.get())}))
}
HostError::NoFrameAvailable => ("no_frame_available", json!({})),
};
WireError { code, message: error.to_string(), details }
}
fn status_name(status: HostExecutionStatus) -> &'static str {
match status {
HostExecutionStatus::Running => "running",
HostExecutionStatus::Paused => "paused",
HostExecutionStatus::Terminated => "terminated",
HostExecutionStatus::Faulted => "faulted",
}
}
fn stack_value(value: &VmValue) -> Value {
match value {
VmValue::Int32(v) => json!({"kind":"int32","value":v}),
VmValue::Int64(v) => json!({"kind":"int64","value":v.to_string()}),
VmValue::Float(v) => json!({"kind":"float64","value":v.to_string()}),
VmValue::Boolean(v) => json!({"kind":"boolean","value":v}),
VmValue::String(v) => json!({"kind":"string","value":v.as_ref()}),
VmValue::HeapRef(v) => json!({"kind":"heap_ref","value":v.0}),
VmValue::Null => json!({"kind":"null","value":null}),
}
}
pub(super) fn state(s: HostState) -> Value {
json!({"pc":s.pc,"stackTop":s.stack_top.iter().map(stack_value).collect::<Vec<_>>(),
"logicalFrameIndex":s.frame_index,"tickIndex":s.tick_index,"appId":s.app_id,
"status":status_name(s.status)})
}
pub(super) fn fault(report: &CrashReport) -> Value {
let mut result = json!({"kind":report.kind(),"pc":report.pc(),"summary":report.summary()});
match report {
CrashReport::VmTrap { trap } => {
result["trap"] = json!({"code":trap.code,"opcode":trap.opcode,
"message":trap.message,"pc":trap.pc,"span":trap.span});
}
CrashReport::VmPanic { message, .. } => {
result["message"] = json!(message);
}
CrashReport::VmInit { error } => {
let code = match error {
VmInitError::InvalidFormat => "invalid_format",
VmInitError::UnsupportedFormat => "unsupported_format",
VmInitError::ImageLoadFailed(_) => "image_load_failed",
VmInitError::LoaderPatchFailed(_) => "loader_patch_failed",
VmInitError::EntrypointNotFound => "entrypoint_not_found",
VmInitError::VerificationFailed(_) => "verification_failed",
};
result["initError"] = json!({"code":code,"message":format!("{error:?}")});
}
}
result
}
pub(super) fn capture(c: CapturedFrame) -> Result<Value, WireError> {
let frame = c.frame;
let width = u32::try_from(frame.width)
.map_err(|_| WireError::new("capture_failed", "width exceeds PNG limit"))?;
let height = u32::try_from(frame.height)
.map_err(|_| WireError::new("capture_failed", "height exceeds PNG limit"))?;
let mut rgba = Vec::new();
for y in 0..frame.height {
for pixel in frame.row(y).ok_or_else(|| WireError::new("capture_failed", "invalid row"))? {
rgba.extend_from_slice(&pixel.to_be_bytes());
}
}
let mut bytes = Vec::new();
{
let mut encoder = png::Encoder::new(&mut bytes, width, height);
encoder.set_color(png::ColorType::Rgba);
encoder.set_depth(png::BitDepth::Eight);
let mut writer =
encoder.write_header().map_err(|e| WireError::new("capture_failed", e.to_string()))?;
writer
.write_image_data(&rgba)
.map_err(|e| WireError::new("capture_failed", e.to_string()))?;
writer.finish().map_err(|e| WireError::new("capture_failed", e.to_string()))?;
}
Ok(json!({"mimeType":"image/png","encoding":"base64","data":STANDARD.encode(bytes),
"width":width,"height":height,"stridePixels":frame.stride_pixels,"pixelFormat":"RGBA8888",
"logicalFrameIndex":c.logical_frame_index,"frameId":frame.frame_id.get()}))
}
@@ -6,6 +6,7 @@
//! The desktop host's `stepFrame` command still advances on the 60 Hz winit loop.
//! That pacing stays in `prometeu-host-desktop-winit` until a later protocol agenda.
pub mod automation;
mod host;
pub use host::{