shuyi_platform/

link.rs

//! The live link (ADR-0047): how a tool reaches a build that is already
//! running, in a debug build with the backend's `link` feature. The wire is
//! JSON lines, one UTF-8 JSON object per line: the client sends a
//! [`Request`] per line, and the build answers each with an [`Answer`], in
//! order. The first line must be a [`Request::Hello`] with the build's
//! token, or the connection is closed.
//!
//! This module touches no device. A backend carries the lines (TCP on
//! loopback in `shuyi-app`) and the [`Server`] turns each into its answer
//! over the [`App`] it runs: it reads the screens, the frame as text, the
//! window's picture (taken by the backend), the log, and the frames'
//! records with a heap snapshot (taken by the backend), and its only input
//! is raw device events the backend adds after the devices' own in
//! [`Platform::poll_input`](crate::Platform::poll_input), so they go where a
//! player's go. It changes nothing any other way.
//!
//! `shuyi attach` is the client, and shares these types with the build, so
//! the two ends can't drift; [`VERSION`] says which wire they speak.

pub mod base64;

use crate::alloc_prelude::*;
use alloc::collections::VecDeque;
use alloc::format;

use serde::{Deserialize, Serialize};
use shuyi_ui::input::PadKind;
use shuyi_ui::log::LogRing;
use shuyi_ui::perf::{FrameRecord, HeapSnapshot, PERF_FRAMES, PerfRing};
use shuyi_ui::{GameData, RawInputEvent};

use crate::app::App;
use crate::script::{self, Planned, Step};

/// The link's version: a client and a build speak the same, or the build
/// closes the link after its hello.
pub const VERSION: u32 = 3;

/// The longest request line, in bytes: a longer one closes the link.
pub const MAX_LINE: usize = 64 * 1024;

/// The most bytes of answers a client may leave unread: past it, the
/// backend drops the client.
pub const MAX_UNSENT: usize = 64 * 1024 * 1024;

/// The longest [`Step::Wait`] of a play, in seconds: half an hour, played
/// as the build's frames at 60 a second ([`script::wait_frames`]).
pub const MAX_WAIT: f32 = 1_800.0;

/// How many records a [`Request::Perf`] answers when it doesn't say.
pub const PERF_MAX: u32 = 120;

/// A line a client sends, tagged by `op`.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(tag = "op", rename_all = "snake_case", deny_unknown_fields)]
#[non_exhaustive]
pub enum Request {
    /// The first line: the build's token, and the link's version the
    /// client speaks.
    Hello {
        /// The token the build logged when it started listening.
        token: String,
        /// The client's [`VERSION`].
        link: u32,
    },
    /// Where the build is: [`Status`].
    Status,
    /// The frame as text, in the snapshot format.
    Frame,
    /// The window's picture, as a PNG, after the next frame is shown.
    Screenshot,
    /// Steps played as a player's input, frame by frame: answered when
    /// the last has run. A wait's seconds are the build's frames at 60 a
    /// second ([`script::wait_frames`]); a crank isn't played over the
    /// link yet.
    Play {
        /// The steps, in order.
        steps: Vec<Step>,
    },
    /// The log's kept lines numbered `since` or more.
    Log {
        /// The first line's number: 0, the default, for every kept line;
        /// the last answer's `next` for the lines since.
        #[serde(default)]
        since: u64,
    },
    /// The frames' records numbered `since` or more ([`App::perf`]), the
    /// first `max` of them, and a heap snapshot after this frame if asked.
    Perf {
        /// The first record's number: 0, the default, for every kept
        /// record; the last answer's `next` for the records since.
        #[serde(default)]
        since: u64,
        /// The most records to answer, 1 to [`PERF_FRAMES`];
        /// [`PERF_MAX`] by default.
        #[serde(default = "perf_max")]
        max: u32,
        /// Whether the backend takes a heap snapshot after this frame
        /// ([`App::heap_snapshot`]) and answers it with the records.
        #[serde(default)]
        snapshot: bool,
    },
}

/// [`Request::Perf`]'s `max` when it doesn't say.
fn perf_max() -> u32 {
    PERF_MAX
}

impl Request {
    /// The request as one line, with no line break.
    pub fn to_line(&self) -> String {
        // An enum of strings and numbers: serializing can't fail.
        serde_json::to_string(self).unwrap_or_default()
    }
}

/// Which part of its life the game is in.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
#[non_exhaustive]
pub enum Phase {
    /// Its loading card shows.
    Loading,
    /// It runs.
    Running,
    /// Its load failed: the errors show.
    Failed,
}

/// Where a running build is.
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
// An answer, read field by field: it may grow (ADR-0039).
#[non_exhaustive]
pub struct Status {
    /// The frames run: [`App::frame_number`].
    pub frames: u32,
    /// Loading, running or failed.
    pub phase: Phase,
    /// Why the game didn't load, if it failed.
    pub errors: Option<String>,
    /// The open screens, bottom first.
    pub screens: Vec<String>,
    /// The top screen's name; empty with none open.
    pub top_screen: String,
    /// Whether the system has suspended the game.
    pub suspended: bool,
    /// Whether its window has the player's attention.
    pub focused: bool,
    /// Whether the game has quit.
    pub quit: bool,
}

impl Status {
    /// Where `app` is now.
    pub fn of<G: GameData>(app: &App<G>) -> Self {
        let phase = if app.is_loading() {
            Phase::Loading
        } else if app.errors().is_some() {
            Phase::Failed
        } else {
            Phase::Running
        };
        let screens: Vec<String> = app
            .game()
            .map(|game| game.screens().into_iter().map(str::to_owned).collect())
            .unwrap_or_default();
        Self {
            frames: app.frame_number(),
            phase,
            errors: app.errors().map(str::to_owned),
            top_screen: screens.last().cloned().unwrap_or_default(),
            screens,
            suspended: app.is_suspended(),
            focused: app.is_focused(),
            quit: app.has_quit(),
        }
    }
}

/// The window's picture.
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
#[non_exhaustive]
pub struct Screenshot {
    /// The PNG file, in [`base64`].
    pub png: String,
    /// Its width in pixels.
    pub width: u32,
    /// Its height in pixels.
    pub height: u32,
    /// What it doesn't show: the loading card or the errors instead of
    /// the game.
    pub limit: Option<String>,
}

/// What a [`Request::Play`] did.
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
#[non_exhaustive]
pub struct Played {
    /// The frames its steps took.
    pub frames: u32,
    /// Whether the steps waited for the game to load.
    pub waited_loading: bool,
    /// Whether the steps waited while the game was suspended.
    pub waited_suspended: bool,
}

/// One line of the log, with its number in the ring.
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
#[non_exhaustive]
pub struct LogEntry {
    /// Its number: lines are numbered from 0 as they are logged.
    pub seq: u64,
    /// The frame it was given in.
    pub frame: u32,
    /// How serious it is: `error`, `warn`, `info` or `debug`.
    pub level: String,
    /// What it is about (`assets`, `platform`, `game`, …).
    pub category: String,
    /// What it says.
    pub text: String,
}

/// The log's lines a [`Request::Log`] asked for.
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
#[non_exhaustive]
pub struct LogAnswer {
    /// The kept lines numbered `since` or more, oldest first.
    pub lines: Vec<LogEntry>,
    /// The number the next line gets: the next request's `since`.
    pub next: u64,
    /// How many lines numbered `since` or more the ring no longer keeps.
    pub dropped: u64,
}

/// The frames' records a [`Request::Perf`] asked for, counted as the
/// contract's `PerfRead` counts them.
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
#[non_exhaustive]
pub struct PerfAnswer {
    /// The kept records numbered `since` or more, oldest first, the first
    /// `max` of them.
    pub records: Vec<FrameRecord>,
    /// The number to read from next time: the one after the last record
    /// answered; 0 for a `since` past the ring's next number.
    pub next: u64,
    /// How many records numbered `since` or more the ring no longer keeps.
    pub dropped: u64,
    /// Whether any frame was measured.
    pub measured: bool,
    /// The frames run: [`App::frame_number`].
    pub frames: u32,
    /// The heap snapshot taken after the frame, if one was asked for and
    /// the build takes one (a debug build that counts the heap by tag).
    pub snapshot: Option<HeapSnapshot>,
}

/// A line the build sends, tagged by `answer`.
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(tag = "answer", rename_all = "snake_case", deny_unknown_fields)]
#[non_exhaustive]
pub enum Answer {
    /// The hello's answer: the build's link version (a client of another
    /// is closed after it) and its game, the window's title.
    Hello {
        /// The build's [`VERSION`].
        link: u32,
        /// The game: the window's title.
        game: String,
    },
    /// [`Request::Status`]'s.
    Status(Status),
    /// [`Request::Frame`]'s: the frame in the snapshot format, empty
    /// while the game isn't running, with a limit saying why.
    Frame {
        /// The frame as text.
        frame: String,
        /// Why there is none.
        limit: Option<String>,
    },
    /// [`Request::Screenshot`]'s.
    Screenshot(Screenshot),
    /// [`Request::Play`]'s, once its last frame has run.
    Played(Played),
    /// [`Request::Log`]'s.
    Log(LogAnswer),
    /// [`Request::Perf`]'s.
    Perf(PerfAnswer),
    /// A request that couldn't be answered: why.
    Error {
        /// What was wrong.
        error: String,
    },
    /// Another client holds the link: this one is closed after this line.
    Busy,
}

impl Answer {
    /// The answer as one line, with no line break.
    pub fn to_line(&self) -> String {
        // Strings, numbers and lists: serializing can't fail.
        serde_json::to_string(self).unwrap_or_default()
    }

    /// The answer `line` holds.
    pub fn from_line(line: &str) -> Result<Self, String> {
        serde_json::from_str(line.trim_end()).map_err(|e| format!("not a link answer: {e}"))
    }

    fn error(error: impl Into<String>) -> String {
        Self::Error {
            error: error.into(),
        }
        .to_line()
    }
}

/// What the [`Server`] made of a line.
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive]
pub enum Handled {
    /// Its answer, to send now.
    Answer(String),
    /// Its answer comes from [`Server::after_frame`]: a play's when its
    /// last frame has run, or any request's behind a play or a picture.
    Later,
    /// The backend answers it after this frame is shown, with
    /// [`Server::screenshot`].
    Screenshot,
    /// The backend answers it after this frame, with a heap snapshot
    /// ([`App::heap_snapshot`]) given to [`Server::snapshot`].
    Snapshot,
    /// Close the connection, after sending this line if there is one,
    /// and read nothing more: the first line wasn't a hello with the
    /// token, a line was longer than [`MAX_LINE`], or the client speaks
    /// another link version (the line is the hello's answer, saying the
    /// build's).
    Close(Option<String>),
}

/// A play being played.
#[derive(Debug)]
struct Play {
    steps: Vec<Step>,
    /// Its frames, once its actions are looked up (the game has loaded).
    frames: Option<VecDeque<Planned>>,
    /// The frames given so far.
    run: u32,
    waited_loading: bool,
    waited_suspended: bool,
}

/// What the server is busy with: later requests wait for it.
#[derive(Debug)]
enum Busy {
    Idle,
    Play(Play),
    /// A picture the backend takes after this frame is shown.
    Screenshot {
        limit: Option<String>,
    },
    /// A heap snapshot the backend takes after this frame, answered with
    /// the records this asks for.
    Snapshot {
        since: u64,
        max: u32,
    },
}

/// The build's end of the link, for one client: it turns the client's
/// lines into answers over the [`App`] the backend runs, and gives the
/// backend a play's input frame by frame. The backend makes one per
/// connection.
///
/// Each frame the backend calls [`handle`](Self::handle) for each line
/// read and sends the answers; [`input`](Self::input) before
/// [`App::frame`], adding what it gives after the devices' input; then
/// [`after_frame`](Self::after_frame), sending what it gives; if
/// [`wants_screenshot`](Self::wants_screenshot), reads the window and
/// sends [`screenshot`](Self::screenshot)'s line; and if
/// [`wants_snapshot`](Self::wants_snapshot), takes a heap snapshot and
/// sends [`snapshot`](Self::snapshot)'s.
#[derive(Debug)]
pub struct Server {
    token: String,
    game: String,
    hello: bool,
    busy: Busy,
    /// The request lines behind a play or a picture, in order.
    waiting: VecDeque<String>,
    /// The answers [`after_frame`](Self::after_frame) gives.
    due: Vec<String>,
}

impl Server {
    /// The server of a build whose token is `token`, of the game `game`
    /// (the window's title).
    pub fn new(token: String, game: String) -> Self {
        Self {
            token,
            game,
            hello: false,
            busy: Busy::Idle,
            waiting: VecDeque::new(),
            due: Vec::new(),
        }
    }

    /// What `line` (without its line break) asks of `app`.
    pub fn handle<G: GameData>(&mut self, line: &str, app: &App<G>) -> Handled {
        if line.len() > MAX_LINE {
            return Handled::Close(None);
        }
        if !self.hello {
            return self.hello(line);
        }
        if !matches!(self.busy, Busy::Idle) || !self.waiting.is_empty() {
            self.waiting.push_back(line.to_owned());
            return Handled::Later;
        }
        self.request(line, app)
    }

    /// The first line: a hello with the token and this link's version.
    fn hello(&mut self, line: &str) -> Handled {
        let Ok(Request::Hello { token, link }) = serde_json::from_str::<Request>(line) else {
            return Handled::Close(None);
        };
        if token != self.token {
            return Handled::Close(None);
        }
        let answer = Answer::Hello {
            link: VERSION,
            game: self.game.clone(),
        }
        .to_line();
        if link != VERSION {
            return Handled::Close(Some(answer));
        }
        self.hello = true;
        Handled::Answer(answer)
    }

    /// A request after the hello, with nothing before it waiting.
    fn request<G: GameData>(&mut self, line: &str, app: &App<G>) -> Handled {
        let request = match serde_json::from_str::<Request>(line) {
            Ok(request) => request,
            Err(e) => return Handled::Answer(Answer::error(format!("not a request: {e}"))),
        };
        let answer = match request {
            Request::Hello { .. } => Answer::error("the link has said hello already"),
            Request::Status => Answer::Status(Status::of(app)).to_line(),
            Request::Frame => frame(app).to_line(),
            Request::Log { since } => Answer::Log(log(app.log(), since)).to_line(),
            Request::Perf {
                since,
                max,
                snapshot,
            } => {
                let most = u32::try_from(PERF_FRAMES).unwrap_or(u32::MAX);
                if !(1..=most).contains(&max) {
                    return Handled::Answer(Answer::error(format!("max: 1 to {most}, not {max}")));
                }
                if snapshot {
                    self.busy = Busy::Snapshot { since, max };
                    return Handled::Snapshot;
                }
                Answer::Perf(perf(app, since, max, None)).to_line()
            }
            Request::Screenshot => {
                self.busy = Busy::Screenshot {
                    limit: shot_limit(app),
                };
                return Handled::Screenshot;
            }
            Request::Play { steps } => {
                if let Err(e) = check_play(&steps) {
                    return Handled::Answer(Answer::error(e));
                }
                // A play of no frames (nothing, or waits of none) is done.
                let none =
                    |step: &Step| matches!(step, Step::Wait(s) if script::wait_frames(*s) == 0);
                if steps.iter().all(none) {
                    Answer::Played(Played {
                        frames: 0,
                        waited_loading: false,
                        waited_suspended: false,
                    })
                    .to_line()
                } else {
                    self.busy = Busy::Play(Play {
                        steps,
                        frames: None,
                        run: 0,
                        waited_loading: false,
                        waited_suspended: false,
                    });
                    return Handled::Later;
                }
            }
        };
        Handled::Answer(answer)
    }

    /// This frame's input from the play being played, if one is: the next
    /// frame of its steps, put in `out` after what is there. While the
    /// game loads or is suspended the steps wait. A play whose game failed
    /// to load, or one of whose actions can't be pressed, ends with an
    /// error, having played nothing more.
    pub fn input<G: GameData>(&mut self, app: &App<G>, out: &mut Vec<RawInputEvent>) {
        let Busy::Play(play) = &mut self.busy else {
            return;
        };
        if let Some(errors) = app.errors() {
            let error = format!("the game didn't load, so the steps can't be played: {errors}");
            self.end_play(Answer::error(error));
            return;
        }
        if app.is_loading() {
            play.waited_loading = true;
            return;
        }
        if app.is_suspended() {
            play.waited_suspended = true;
            return;
        }
        let Some(game) = app.game() else {
            return;
        };
        if play.frames.is_none() {
            match script::frames(&play.steps, game.input().keymap(), PadKind::default()) {
                Ok(frames) if frames.is_empty() => {
                    let played = Played {
                        frames: 0,
                        waited_loading: play.waited_loading,
                        waited_suspended: play.waited_suspended,
                    };
                    self.end_play(Answer::Played(played).to_line());
                    return;
                }
                Ok(frames) => play.frames = Some(frames.into()),
                Err(e) => {
                    self.end_play(Answer::error(e));
                    return;
                }
            }
        }
        let frames = play.frames.get_or_insert_with(VecDeque::new);
        match frames.front_mut() {
            Some(Planned::Events(events)) => {
                out.append(events);
                frames.pop_front();
            }
            Some(Planned::Idle(n)) => {
                *n = n.saturating_sub(1);
                if *n == 0 {
                    frames.pop_front();
                }
            }
            None => {}
        }
        play.run = play.run.saturating_add(1);
    }

    /// Ends the play with `answer`, due after this frame.
    fn end_play(&mut self, answer: String) {
        self.busy = Busy::Idle;
        self.due.push(answer);
    }

    /// The answers due now that `app`'s frame has run: a play's whose last
    /// frame it was, then those of the requests that waited behind it, up
    /// to the next play or picture.
    pub fn after_frame<G: GameData>(&mut self, app: &App<G>) -> Vec<String> {
        match &mut self.busy {
            Busy::Play(play) if play.frames.as_ref().is_some_and(VecDeque::is_empty) => {
                let answer = Answer::Played(Played {
                    frames: play.run,
                    waited_loading: play.waited_loading,
                    waited_suspended: play.waited_suspended,
                });
                self.end_play(answer.to_line());
            }
            Busy::Screenshot { limit } => *limit = shot_limit(app),
            Busy::Idle | Busy::Play(_) | Busy::Snapshot { .. } => {}
        }
        while matches!(self.busy, Busy::Idle)
            && let Some(line) = self.waiting.pop_front()
        {
            match self.request(&line, app) {
                Handled::Answer(answer) => self.due.push(answer),
                Handled::Later | Handled::Screenshot | Handled::Snapshot | Handled::Close(_) => {}
            }
        }
        core::mem::take(&mut self.due)
    }

    /// Whether the backend should read the window after this frame and
    /// answer with [`screenshot`](Self::screenshot).
    pub fn wants_screenshot(&self) -> bool {
        matches!(self.busy, Busy::Screenshot { .. })
    }

    /// The answer to a [`Request::Screenshot`]: `png`, the window's
    /// picture of `width` × `height` pixels. Requests behind it are
    /// answered from the next [`after_frame`](Self::after_frame).
    pub fn screenshot(&mut self, png: &[u8], width: u32, height: u32) -> String {
        let limit = match core::mem::replace(&mut self.busy, Busy::Idle) {
            Busy::Screenshot { limit } => limit,
            other => {
                self.busy = other;
                None
            }
        };
        Answer::Screenshot(Screenshot {
            png: base64::encode(png),
            width,
            height,
            limit,
        })
        .to_line()
    }

    /// Whether the backend should take a heap snapshot after this frame
    /// and answer with [`snapshot`](Self::snapshot).
    pub fn wants_snapshot(&self) -> bool {
        matches!(self.busy, Busy::Snapshot { .. })
    }

    /// The answer to a [`Request::Perf`] that asked for a snapshot:
    /// `app`'s records it asked for, and `snapshot`, the backend's
    /// ([`App::heap_snapshot`]; `None` where it takes none). Requests
    /// behind it are answered from the next
    /// [`after_frame`](Self::after_frame).
    pub fn snapshot<G: GameData>(
        &mut self,
        app: &App<G>,
        snapshot: Option<HeapSnapshot>,
    ) -> String {
        let (since, max) = match core::mem::replace(&mut self.busy, Busy::Idle) {
            Busy::Snapshot { since, max } => (since, max),
            other => {
                self.busy = other;
                (app.perf().next_seq(), PERF_MAX)
            }
        };
        Answer::Perf(perf(app, since, max, snapshot)).to_line()
    }
}

/// The frame `app` shows, as text.
fn frame<G: GameData>(app: &App<G>) -> Answer {
    match app.game() {
        Some(game) => Answer::Frame {
            frame: game.buffer().to_snapshot(&game.ctx().palette),
            limit: None,
        },
        None => Answer::Frame {
            frame: String::new(),
            limit: Some(not_running(app)),
        },
    }
}

/// Why `app` shows no game: its loading card, or the errors of its load.
fn not_running<G: GameData>(app: &App<G>) -> String {
    match app.errors() {
        Some(errors) => format!("the build's game didn't load: {errors}"),
        None => "the build shows its loading card".to_owned(),
    }
}

/// What a picture of `app`'s window doesn't show.
fn shot_limit<G: GameData>(app: &App<G>) -> Option<String> {
    app.game()
        .is_none()
        .then(|| format!("{}: the picture shows that, not the game", not_running(app)))
}

/// `ring`'s kept lines numbered `since` or more, each with its number.
fn log(ring: &LogRing, since: u64) -> LogAnswer {
    let next = ring.next_seq();
    let kept = u64::try_from(ring.lines().len()).unwrap_or(u64::MAX);
    let first = next.saturating_sub(kept);
    let lines = (since.max(first)..)
        .zip(ring.since(since))
        .map(|(seq, line)| LogEntry {
            seq,
            frame: line.frame,
            level: line.level.name().to_owned(),
            category: line.category.name().to_owned(),
            text: line.text.clone(),
        })
        .collect();
    LogAnswer {
        lines,
        next,
        dropped: first.saturating_sub(since),
    }
}

/// `app`'s records numbered `since` or more, the first `max`, with
/// `snapshot`.
fn perf<G: GameData>(
    app: &App<G>,
    since: u64,
    max: u32,
    snapshot: Option<HeapSnapshot>,
) -> PerfAnswer {
    let mut answer = perf_read(app.perf(), since, max);
    answer.frames = app.frame_number();
    answer.snapshot = snapshot;
    answer
}

/// The first `max` records of `ring` numbered `since` or more, as the
/// contract's `PerfRead::of` reads them: a `since` past the ring's next
/// number (a build started again) reads nothing, with `next` 0. No frames
/// and no snapshot.
fn perf_read(ring: &PerfRing, since: u64, max: u32) -> PerfAnswer {
    let next_seq = ring.next_seq();
    let kept = u64::try_from(ring.records().len()).unwrap_or(u64::MAX);
    let first = next_seq.saturating_sub(kept);
    let mut answer = PerfAnswer {
        records: Vec::new(),
        next: 0,
        dropped: 0,
        measured: next_seq > 0,
        frames: 0,
        snapshot: None,
    };
    if since > next_seq {
        return answer;
    }
    let max = usize::try_from(max).unwrap_or(usize::MAX);
    answer.records = ring.since(since).take(max).cloned().collect();
    answer.next = since.max(first) + u64::try_from(answer.records.len()).unwrap_or(u64::MAX);
    answer.dropped = first.saturating_sub(since);
    answer
}

/// Whether a play's `steps` can be played: each step
/// ([`Step::check`](script::Step::check)), waits of at most [`MAX_WAIT`]
/// seconds, and no crank or debug step; an error names the step. An action's name is
/// looked up when the play starts.
pub fn check_play(steps: &[Step]) -> Result<(), String> {
    for (i, step) in steps.iter().enumerate() {
        step.check().map_err(|e| format!("step {}: {e}", i + 1))?;
        if matches!(step, Step::Crank(_)) {
            return Err(format!("step {}: crank: not over the live link yet", i + 1));
        }
        if matches!(step, Step::Debug(_)) {
            return Err(format!("step {}: debug: not over the live link yet", i + 1));
        }
    }
    script::check_waits(steps, MAX_WAIT)
}

#[cfg(test)]
mod tests;