use std::collections::BTreeMap;
use std::io::{BufRead, BufReader, Write};
use std::net::{TcpListener, TcpStream};
use std::sync::atomic::{AtomicBool, AtomicU32, Ordering};
use std::sync::{Arc, mpsc};
use std::time::{Duration, Instant};
use day_core::{NodeProbe, rnode_to_id, with_tree};
pub mod record;
pub use record::play;
pub mod conformance;
mod memory;
mod memory_watch;
pub mod png;
pub const DEFAULT_MAIN_TIMEOUT_SECS: f64 = 30.0;
pub use day_script_protocol::{DEFAULT_TIMEOUT_SECS, DialogMode, Reply, Request, Step};
fn parse_width_class(s: &str) -> Option<day_spec::WidthClass> {
use day_spec::WidthClass as W;
match s {
"compact" => Some(W::Compact),
"medium" => Some(W::Medium),
"expanded" => Some(W::Expanded),
"large" => Some(W::Large),
"extra-large" => Some(W::ExtraLarge),
_ => None,
}
}
fn parse_height_class(s: &str) -> Option<day_spec::HeightClass> {
use day_spec::HeightClass as H;
match s {
"compact" => Some(H::Compact),
"medium" => Some(H::Medium),
"expanded" => Some(H::Expanded),
_ => None,
}
}
fn drive_undo(redo: bool) -> Result<Reply, Reply> {
if day_core::invoke_undo(redo) {
day_reactive::flush_sync();
Ok(Reply::ok())
} else {
Err(Reply::fail("no undo stack installed".to_string(), false))
}
}
pub fn init() {
if let Some(path) = std::env::var_os("DAY_RECORD").filter(|p| !p.is_empty()) {
record::start_to_file(path);
}
if std::env::var("DAY_LOG_ACTIONS").is_ok_and(|v| v == "1") {
record::log_actions(true);
}
let (Ok(port), Ok(token)) = (
std::env::var("DAYSCRIPT_PORT"),
std::env::var("DAYSCRIPT_TOKEN"),
) else {
return;
};
let Ok(port) = port.parse::<u16>() else {
return;
};
std::thread::spawn(move || serve(port, token));
}
const RETRY_MS: u32 = 100;
#[cfg(target_arch = "wasm32")]
mod web {
use super::*;
use std::cell::RefCell;
type WebSender = Box<dyn Fn(&str)>;
thread_local! {
static WEB: RefCell<Option<(String, WebSender)>> = const { RefCell::new(None) };
static WATCH: std::cell::Cell<u64> = const { std::cell::Cell::new(0) };
}
pub fn web_init(token: String, send: impl Fn(&str) + 'static) {
WATCH.with(|w| w.set(w.get() + 1));
WEB.with(|w| *w.borrow_mut() = Some((token, Box::new(send))));
}
pub fn web_line(line: &str) {
let reply = match serde_json::from_str::<Request>(line.trim()) {
Ok(req) => {
let authed = WEB.with(|w| {
w.borrow()
.as_ref()
.map(|(t, _)| *t == req.token)
.unwrap_or(false)
});
if authed {
if let Step::MemoryWatch { interval_ms } = req.step {
if !memory_watch::valid_interval(interval_ms) {
send_reply(Reply::fail(
"memory_watch interval must be 0 or 100..60000 ms",
false,
));
return;
}
let generation = WATCH.with(|w| {
w.set(w.get() + 1);
w.get()
});
send_reply(memory_watch::sample());
if interval_ms > 0 {
watch_tick(generation, interval_ms as u32);
}
send_reply(Reply::ok());
return;
}
let budget_ms = (req.step.wait_budget_secs() * 1000.0) as u32;
attempt(req.step, budget_ms, next_capture_revision());
return;
}
Reply::fail("bad token", false)
}
Err(e) => Reply::fail(format!("bad request: {e}"), false),
};
send_reply(reply);
}
fn attempt(step: Step, remaining_ms: u32, revision: u32) {
let reply = exec(step.clone(), revision);
if reply.ok || !reply.retryable || remaining_ms == 0 {
send_reply(reply);
return;
}
let interval = if reply.capture_pending { 16 } else { RETRY_MS };
let delay = interval.min(remaining_ms);
day_reactive::on_main_delayed(delay, move || attempt(step, remaining_ms - delay, revision));
}
fn watch_tick(generation: u64, interval: u32) {
day_reactive::on_main_delayed(interval, move || {
if WATCH.with(|w| w.get()) == generation {
send_reply(memory_watch::sample());
watch_tick(generation, interval);
}
});
}
fn send_reply(reply: Reply) {
let mut out = serde_json::to_string(&reply).unwrap_or_else(|_| "{\"ok\":false}".into());
out.push('\n');
WEB.with(|w| {
if let Some((_, send)) = w.borrow().as_ref() {
send(&out);
}
});
}
}
#[cfg(target_arch = "wasm32")]
pub use web::{web_init, web_line};
fn serve(port: u16, token: String) {
std::thread::sleep(Duration::from_millis(300));
let deadline = std::time::Instant::now() + Duration::from_secs(15);
let mut said = false;
let listener = loop {
match TcpListener::bind(("127.0.0.1", port)) {
Ok(l) => break l,
Err(e) if std::time::Instant::now() < deadline => {
if !said {
said = true;
log::warn!("day-script: 127.0.0.1:{port} still busy ({e}) — waiting for it");
}
std::thread::sleep(Duration::from_millis(250));
}
Err(e) => {
log::error!(
"day-script: bind 127.0.0.1:{port} failed after 15s: {e} — this app has NO \
dayscript engine; anything driving this port is reaching a DIFFERENT process"
);
return;
}
}
};
for stream in listener.incoming().flatten() {
handle_conn(stream, &token);
}
}
fn handle_conn(stream: TcpStream, token: &str) {
let _ = stream.set_nodelay(true);
let _ = stream.set_write_timeout(Some(Duration::from_secs(15)));
let mut reader = BufReader::new(stream.try_clone().expect("clone stream"));
let writer = Arc::new(std::sync::Mutex::new(stream));
let mut watch = None;
let mut line = String::new();
loop {
line.clear();
match reader.read_line(&mut line) {
Ok(0) | Err(_) => return,
Ok(_) => {}
}
let reply = match serde_json::from_str::<Request>(line.trim()) {
Ok(req) if req.token == token => {
if let Step::MemoryWatch { interval_ms } = req.step {
if memory_watch::valid_interval(interval_ms) {
drop(watch.take());
if interval_ms > 0 {
watch = Some(memory_watch::Watch::start(writer.clone(), interval_ms));
}
Reply::ok()
} else {
Reply::fail("memory_watch interval must be 0 or 100..60000 ms", false)
}
} else {
run_step_with_wait(req.step)
}
}
Ok(_) => Reply::fail("bad token", false),
Err(e) => Reply::fail(format!("bad request: {e}"), false),
};
let mut out = serde_json::to_string(&reply).unwrap_or_else(|_| "{\"ok\":false}".into());
out.push('\n');
if writer.lock().unwrap().write_all(out.as_bytes()).is_err() {
return;
}
}
}
const SNAPSHOT_RETRIES: u32 = 30;
static SNAPSHOT_MISSES: AtomicU32 = AtomicU32::new(0);
static SNAPSHOT_WORKS: AtomicBool = AtomicBool::new(false);
static SNAPSHOT_NEVER: AtomicBool = AtomicBool::new(false);
const FOCUS_WAIT_POLLS: u32 = 10;
static FOCUS_WAITS: AtomicU32 = AtomicU32::new(0);
static CAPTURE_REVISION: AtomicU32 = AtomicU32::new(1);
fn next_capture_revision() -> u32 {
CAPTURE_REVISION.fetch_add(1, Ordering::Relaxed)
}
pub fn step(step: Step) -> Reply {
exec(step, next_capture_revision())
}
fn run_step_with_wait(step: Step) -> Reply {
let revision = next_capture_revision();
let budget = Duration::from_secs_f64(step.wait_budget_secs());
let deadline = Instant::now() + budget;
let main_budget = main_thread_budget(budget);
loop {
let reply = run_on_main(step.clone(), main_budget, revision);
if reply.ok || !reply.retryable || Instant::now() > deadline {
return reply;
}
let retry_ms = if reply.capture_pending { 16 } else { RETRY_MS };
std::thread::sleep(Duration::from_millis(u64::from(retry_ms)));
}
}
fn main_thread_budget(step_budget: Duration) -> Duration {
let secs = std::env::var("DAY_SCRIPT_MAIN_TIMEOUT_SECS")
.ok()
.and_then(|v| v.parse::<f64>().ok())
.filter(|v| v.is_finite() && *v > 0.0)
.unwrap_or(DEFAULT_MAIN_TIMEOUT_SECS);
Duration::from_secs_f64(secs).max(step_budget)
}
fn run_on_main(step: Step, budget: Duration, revision: u32) -> Reply {
let (tx, rx) = mpsc::sync_channel::<Reply>(1);
let abandoned = Arc::new(AtomicBool::new(false));
let flag = Arc::clone(&abandoned);
day_reactive::on_main(move || {
if flag.load(Ordering::SeqCst) {
return;
}
if !day_core::has_tree() {
let _ = tx.send(Reply::fail("the app is still starting", true));
return;
}
let _ = tx.send(exec(step, revision));
});
match rx.recv_timeout(budget) {
Ok(reply) => reply,
Err(_) => {
abandoned.store(true, Ordering::SeqCst);
Reply {
main_thread_stalled: true,
..Reply::fail(
format!(
"main thread did not respond within {:.0}s — raise \
DAY_SCRIPT_MAIN_TIMEOUT_SECS if this machine is just slow",
budget.as_secs_f64()
),
false,
)
}
}
}
}
fn parse_modifiers(names: &[String]) -> day_spec::Modifiers {
let mut m = day_spec::Modifiers::default();
for n in names {
match n.to_ascii_lowercase().as_str() {
"shift" => m.shift = true,
"primary" | "cmd" | "ctrl" | "meta" => m.primary = true,
"alt" | "option" => m.alt = true,
_ => {}
}
}
m
}
fn find_menu_actions(
items: &[day_spec::MenuItem],
target_label: &str,
target_key: Option<&str>,
target_id: Option<&str>,
path: &[(String, String)],
) -> Vec<(u64, bool, Vec<String>)> {
fn role_key(role: day_spec::MenuRole) -> &'static str {
use day_spec::MenuRole as R;
match role {
R::Cut => "day_cut",
R::Copy => "day_copy",
R::Paste => "day_paste",
R::SelectAll => "day_select_all",
R::Undo => "day_undo",
R::Redo => "day_redo",
R::Delete => "day_delete",
R::About => "day_about",
R::Quit => "day_quit",
R::Preferences => "day_preferences",
R::Minimize => "day_minimize",
R::CloseWindow => "day_close",
R::Fullscreen => "day_fullscreen",
R::NewWindow => "day_new_window",
R::CheckForUpdates => "day_check_for_updates",
}
}
#[allow(clippy::too_many_arguments)]
fn walk(
items: &[day_spec::MenuItem],
trail: &mut Vec<String>,
target_label: &str,
target_key: Option<&str>,
target_id: Option<&str>,
path: &[(String, String)],
out: &mut Vec<(u64, bool, Vec<String>)>,
) {
for it in items {
match it {
day_spec::MenuItem::Action {
id,
action,
label,
enabled,
role,
..
} => {
let by_id = target_id.is_some_and(|w| id.as_deref() == Some(w));
let by_label =
target_id.is_none() && !label.is_empty() && label == target_label;
let by_key = target_id.is_none()
&& target_key.is_some_and(|k| role.is_some_and(|r| role_key(r) == k));
let path_ok = path.is_empty()
|| (path.len() <= trail.len()
&& trail[trail.len() - path.len()..]
.iter()
.zip(path)
.all(|(seen, want)| seen == &want.0 || seen == &want.1));
if (by_id || by_label || by_key) && path_ok {
out.push((*action, *enabled, trail.clone()));
}
}
day_spec::MenuItem::Submenu { label, items, .. } => {
trail.push(label.clone());
walk(items, trail, target_label, target_key, target_id, path, out);
trail.pop();
}
day_spec::MenuItem::Separator => {}
}
}
}
let mut out = Vec::new();
walk(
items,
&mut Vec::new(),
target_label,
target_key,
target_id,
path,
&mut out,
);
out
}
fn format_key(key: &str, args: Option<BTreeMap<String, serde_json::Value>>) -> String {
let mut lt = day_localization_ui::tr(key);
for (name, v) in args.unwrap_or_default() {
lt = match v {
serde_json::Value::Number(n) => lt.arg(&name, n.as_f64().unwrap_or(0.0)),
serde_json::Value::String(s) => lt.arg(&name, s),
other => lt.arg(&name, other.to_string()),
};
}
lt.format()
}
fn find(id: &str) -> Result<day_core::RNode, Reply> {
with_tree(|t| t.find_by_id(id)).ok_or_else(|| Reply::fail(format!("no element {id:?}"), true))
}
fn probe(id: &str) -> Result<NodeProbe, Reply> {
let node = find(id)?;
with_tree(|t| t.node_probe(node)).ok_or_else(|| Reply::fail("element vanished", true))
}
fn emit(id: &str, ev: day_spec::Event) -> Result<(), Reply> {
let node = find(id)?;
day_core::enqueue_event(rnode_to_id(node), ev);
day_reactive::flush_sync();
Ok(())
}
fn visible(id: &str) -> Result<(), Reply> {
let node = find(id)?;
let frame = with_tree(|t| t.node_frame(node));
match frame {
Some(f) if f.size.width > 0.0 && f.size.height > 0.0 => Ok(()),
_ => Err(Reply::fail(format!("{id:?} has no visible frame"), true)),
}
}
fn parse_hex_color(s: &str) -> Option<[u8; 3]> {
let hex = s.strip_prefix('#')?;
if hex.len() != 6 {
return None;
}
let channel = |i: usize| u8::from_str_radix(hex.get(i..i + 2)?, 16).ok();
Some([channel(0)?, channel(2)?, channel(4)?])
}
fn norm(s: &str) -> String {
day_localization_ui::strip_isolates(s)
}
fn hosts_settled() -> Result<(), Reply> {
if day_spec::capture::holds_settled() {
Ok(())
} else {
Err(Reply {
capture_pending: true,
..Reply::fail("waiting for a host's pending frame", true)
})
}
}
fn id_catalog() -> Result<&'static day_script_protocol::IdCatalog, String> {
static CATALOG: std::sync::OnceLock<Result<day_script_protocol::IdCatalog, String>> =
std::sync::OnceLock::new();
CATALOG
.get_or_init(|| {
Ok(day_script_protocol::IdCatalog {
schema_version: 1,
declarations: day_core::element_id::registry()?
.iter()
.cloned()
.map(|d| day_script_protocol::IdDeclaration {
family: d.family,
keyed: d.keyed,
package: d.package,
version: d.version,
locations: d.locations,
})
.collect(),
})
})
.as_ref()
.map_err(Clone::clone)
}
fn exec(step: Step, revision: u32) -> Reply {
let evidence_class = step.evidence_class();
let evidence_id = step.element_references().into_iter().next();
let absent_optional_action = matches!(&step,
Step::Tap { id, if_present: true, .. }
| Step::Select { id, if_present: true, .. }
| Step::ContextMenu { id, if_present: true, .. } if find(id).is_err());
use day_spec::Event;
use day_spec::present::PresentResult;
let result: Result<Reply, Reply> = (|| {
match step {
Step::IdMounted => Ok(Reply {
data: Some(serde_json::json!(with_tree(|t| t.mounted_id_families()))),
..Reply::ok()
}),
Step::IdCatalog => {
let catalog = id_catalog().map_err(|e| Reply::fail(e, false))?;
Ok(Reply {
data: Some(serde_json::to_value(catalog).unwrap()),
..Reply::ok()
})
}
Step::WaitFor { id, .. } => {
visible(&id)?;
Ok(Reply::ok())
}
Step::WaitIdle => {
day_reactive::flush_sync();
if !with_tree(|t| t.ui_idle()) {
return Err(Reply::fail("ui transitions still settling", true));
}
Ok(Reply::ok())
}
Step::MemoryUsage { fail_if_above } => Ok(memory::sample(fail_if_above)),
Step::MemoryWatch { .. } => Err(Reply::fail(
"memory_watch requires a transport connection",
false,
)),
Step::Tap {
id,
if_present,
repeat,
at,
modifiers,
} => {
day_reactive::flush_sync();
if !with_tree(|t| t.ui_idle()) {
return Err(Reply::fail("ui transitions still settling", true));
}
if if_present && with_tree(|t| t.find_by_id(&id)).is_none() {
return Ok(Reply::ok());
}
visible(&id)?;
if !probe(&id)?.enabled {
return Err(Reply::fail(format!("{id:?} is disabled"), true));
}
let node = find(&id)?;
let point = match at {
Some([x, y]) => day_spec::Point::new(x, y),
None => with_tree(|t| t.node_frame(node))
.map(|f| day_spec::Point::new(f.size.width / 2.0, f.size.height / 2.0))
.unwrap_or(day_spec::Point::ZERO),
};
if !modifiers.is_empty() {
day_core::set_modifier_override(Some(parse_modifiers(&modifiers)));
}
for _ in 0..repeat.unwrap_or(1).max(1) {
day_core::enqueue_event(rnode_to_id(node), Event::Pressed);
day_core::enqueue_event(rnode_to_id(node), Event::Tap(point));
}
day_reactive::flush_sync();
day_core::set_modifier_override(None);
Ok(Reply::ok())
}
Step::Key { key, id, modifiers } => {
let target = match &id {
Some(id) => rnode_to_id(find(id)?),
None => match day_core::focused_node() {
Some(n) => rnode_to_id(n),
None => {
return Err(Reply::fail(
"nothing has focus — name an `id`, or `focus:` a piece first",
true,
));
}
},
};
let m = parse_modifiers(&modifiers);
let mut mask = 0u8;
if m.shift {
mask |= day_spec::KeyEvent::SHIFT;
}
if m.primary {
mask |= day_spec::KeyEvent::PRIMARY;
}
if m.alt {
mask |= day_spec::KeyEvent::ALT;
}
if modifiers.iter().any(|n| n.eq_ignore_ascii_case("control")) {
mask |= day_spec::KeyEvent::CONTROL;
}
let chord = mask
& (day_spec::KeyEvent::PRIMARY
| day_spec::KeyEvent::ALT
| day_spec::KeyEvent::CONTROL)
!= 0;
let event = if day_spec::keys::text(target)
&& !chord
&& !day_spec::KeyEvent::NAMED.contains(&key.as_str())
{
day_spec::KeyEvent::typed_text(key, mask)
} else {
day_spec::KeyEvent::named(key, mask)
};
day_core::enqueue_event(target, Event::Key(event));
day_reactive::flush_sync();
Ok(Reply::ok())
}
Step::Drag {
id,
from,
to,
steps,
modifiers,
} => {
let node = find(&id)?;
let (fx, fy) = (from[0], from[1]);
let (tx, ty) = (to[0], to[1]);
let n = steps.unwrap_or(4).max(1);
let emit_drag = |phase, x: f64, y: f64| {
day_core::enqueue_event(
rnode_to_id(node),
Event::Drag {
phase,
location: day_spec::Point::new(x, y),
translation: day_spec::Point::new(x - fx, y - fy),
},
);
};
if !modifiers.is_empty() {
day_core::set_modifier_override(Some(parse_modifiers(&modifiers)));
}
emit_drag(day_spec::DragPhase::Began, fx, fy);
day_reactive::flush_sync();
for i in 1..=n {
let f = i as f64 / n as f64;
emit_drag(
day_spec::DragPhase::Changed,
fx + (tx - fx) * f,
fy + (ty - fy) * f,
);
day_reactive::flush_sync();
}
emit_drag(day_spec::DragPhase::Ended, tx, ty);
day_reactive::flush_sync();
day_core::set_modifier_override(None);
Ok(Reply::ok())
}
Step::Hover { id, at, leave } => {
let node = find(&id)?;
let location = match at {
Some([x, y]) => day_spec::Point::new(x, y),
None => {
let f = with_tree(|t| t.node_frame(node)).unwrap_or_default();
day_spec::Point::new(f.size.width / 2.0, f.size.height / 2.0)
}
};
let phase = if leave {
day_spec::DragPhase::Ended
} else {
day_spec::DragPhase::Began
};
day_core::enqueue_event(rnode_to_id(node), Event::Hover { phase, location });
day_reactive::flush_sync();
Ok(Reply::ok())
}
Step::Pan { id, by, steps } => {
let node = find(&id)?;
let f = with_tree(|t| t.node_frame(node)).unwrap_or_default();
let location = day_spec::Point::new(f.size.width / 2.0, f.size.height / 2.0);
let n = steps.unwrap_or(4).max(1);
let emit_pan = |phase, dx: f64, dy: f64| {
day_core::enqueue_event(
rnode_to_id(node),
Event::Pan {
phase,
delta: day_spec::Point::new(dx, dy),
location,
},
);
day_reactive::flush_sync();
};
emit_pan(day_spec::DragPhase::Began, 0.0, 0.0);
for _ in 0..n {
emit_pan(
day_spec::DragPhase::Changed,
by[0] / n as f64,
by[1] / n as f64,
);
}
emit_pan(day_spec::DragPhase::Ended, 0.0, 0.0);
Ok(Reply::ok())
}
Step::Pinch { id, scale, steps } => {
let node = find(&id)?;
let f = with_tree(|t| t.node_frame(node)).unwrap_or_default();
let location = day_spec::Point::new(f.size.width / 2.0, f.size.height / 2.0);
let n = steps.unwrap_or(4).max(1);
let emit_pinch = |phase, s: f64| {
day_core::enqueue_event(
rnode_to_id(node),
Event::Pinch {
phase,
scale: s,
location,
},
);
day_reactive::flush_sync();
};
emit_pinch(day_spec::DragPhase::Began, 1.0);
for i in 1..=n {
emit_pinch(
day_spec::DragPhase::Changed,
1.0 + (scale - 1.0) * i as f64 / n as f64,
);
}
emit_pinch(day_spec::DragPhase::Ended, scale);
Ok(Reply::ok())
}
Step::Rotate {
id,
rotation,
steps,
} => {
let node = find(&id)?;
let f = with_tree(|t| t.node_frame(node)).unwrap_or_default();
let location = day_spec::Point::new(f.size.width / 2.0, f.size.height / 2.0);
let n = steps.unwrap_or(4).max(1);
let emit_rotate = |phase, r: f64| {
day_core::enqueue_event(
rnode_to_id(node),
Event::Rotate {
phase,
rotation: r,
location,
},
);
day_reactive::flush_sync();
};
emit_rotate(day_spec::DragPhase::Began, 0.0);
for i in 1..=n {
emit_rotate(day_spec::DragPhase::Changed, rotation * i as f64 / n as f64);
}
emit_rotate(day_spec::DragPhase::Ended, rotation);
Ok(Reply::ok())
}
Step::Submit { id } => emit(&id, Event::Submitted).map(|()| Reply::ok()),
Step::Input {
id,
text,
key,
args,
} => {
let value = match key {
Some(k) => format_key(&k, args),
None => text.unwrap_or_default(),
};
let node = find(&id)?;
day_core::synthesize_text(node, value);
day_reactive::flush_sync();
Ok(Reply::ok())
}
Step::SetValue { id, value } => {
emit(&id, Event::ValueChanged(value))?;
emit(&id, Event::ValueCommitted(value))?;
Ok(Reply::ok())
}
Step::Toggle { id, value } => {
let target = match value {
Some(v) => v,
None => !probe(&id)?.flag,
};
emit(&id, Event::ToggleChanged(target))?;
Ok(Reply::ok())
}
Step::Activate { id, index } => {
emit(&id, Event::ListActivated(index))?;
Ok(Reply::ok())
}
Step::Select {
id,
index,
if_present,
} => {
if if_present {
day_reactive::flush_sync();
if !with_tree(|t| t.ui_idle()) {
return Err(Reply::fail("ui transitions still settling", true));
}
if with_tree(|t| t.find_by_id(&id)).is_none() {
return Ok(Reply::ok());
}
}
let node = find(&id)?;
let state = probe(&id)?;
if with_tree(|t| t.node_kind(node)) == Some(day_spec::kinds::PICKER)
&& (index < 0 || index as usize >= state.options.len())
{
return Err(Reply::fail(
format!(
"select {id:?}: index {index} is out of range for {} options",
state.options.len()
),
false,
));
}
emit(&id, Event::SelectionChanged(index))?;
Ok(Reply::ok())
}
Step::Reorder { id, from, to } => {
let node = find(&id)?;
match day_core::list_try_reorder(node, from, to) {
Ok(_) => Ok(Reply::ok()),
Err(e) => Err(Reply::fail(
format!("reorder {id:?} {from}->{to}: {e}"),
false,
)),
}
}
Step::Undo => drive_undo(false),
Step::Redo => drive_undo(true),
Step::Expand { id, row, expanded } => {
let node = find(&id)?;
let driver = day_core::tree_driver(node).ok_or_else(|| {
Reply::fail(format!("expand {id:?}: no tree at this node"), false)
})?;
let token = (driver.resolve_row)(&row).ok_or_else(|| {
Reply::fail(format!("expand {id:?}: no row {row:?}"), true)
})?;
emit(&id, Event::TreeExpanded { token, expanded })?;
Ok(Reply::ok())
}
Step::TreeMove {
id,
row,
parent,
index,
} => {
let node = find(&id)?;
let driver = day_core::tree_driver(node).ok_or_else(|| {
Reply::fail(format!("tree_move {id:?}: no tree at this node"), false)
})?;
let token = (driver.resolve_row)(&row).ok_or_else(|| {
Reply::fail(format!("tree_move {id:?}: no row {row:?}"), true)
})?;
let parent_tok = match &parent {
Some(p) => Some((driver.resolve_row)(p).ok_or_else(|| {
Reply::fail(format!("tree_move {id:?}: no parent row {p:?}"), true)
})?),
None => None,
};
match day_core::tree_try_move(node, token, parent_tok, index) {
Ok(()) => Ok(Reply::ok()),
Err(e) => Err(Reply::fail(format!("tree_move {id:?} {row:?}: {e}"), false)),
}
}
Step::DeleteRow { id, row } => {
let node = find(&id)?;
match day_core::list_try_delete(node, row) {
Ok(()) => Ok(Reply::ok()),
Err(e) => Err(Reply::fail(format!("delete_row {id:?} {row}: {e}"), false)),
}
}
Step::SwipeRow {
id,
row,
edge,
action,
label,
key,
} => {
let node = find(&id)?;
let edge = match edge.as_deref() {
None | Some("trailing") => day_spec::SwipeEdge::Trailing,
Some("leading") => day_spec::SwipeEdge::Leading,
Some(other) => {
return Err(Reply::fail(
format!("swipe_row {id:?}: edge {other:?} (leading|trailing)"),
false,
));
}
};
let expected = match (&label, &key) {
(Some(l), _) => Some(l.clone()),
(None, Some(k)) => Some(format_key(k, None)),
(None, None) => None,
};
match day_core::list_try_swipe(node, row, edge, action, expected.as_deref()) {
Ok(_) => Ok(Reply::ok()),
Err(e) => Err(Reply::fail(format!("swipe_row {id:?} {row}: {e}"), false)),
}
}
Step::WebEval {
id,
script,
contains,
text,
..
} => {
use std::cell::RefCell;
use std::rc::Rc;
type EvalCell = Rc<RefCell<Option<Result<String, String>>>>;
thread_local! {
static WEB_EVALS: RefCell<
std::collections::HashMap<(String, String), (u32, EvalCell)>,
> = RefCell::new(std::collections::HashMap::new());
}
let node = find(&id)?;
let key = (id.clone(), script.clone());
let pending = WEB_EVALS.with(|m| m.borrow().get(&key).map(|(_, c)| c.clone()));
let Some(cell) = pending else {
let cell: EvalCell = Rc::new(RefCell::new(None));
let done = {
let cell = cell.clone();
Box::new(move |r: Result<String, String>| *cell.borrow_mut() = Some(r))
};
if !day_core::piece_operation(node, "day.webview.eval", &script, done) {
return Err(Reply::fail(
format!(
"web_eval {id:?}: not a web view (or no webview piece registered an evaluator)"
),
false,
));
}
WEB_EVALS.with(|m| m.borrow_mut().insert(key, (0, cell)));
return Err(Reply::fail(
format!("web_eval {id:?}: awaiting the engine"),
true,
));
};
let Some(result) = cell.borrow_mut().take() else {
let stale = WEB_EVALS.with(|m| {
let mut m = m.borrow_mut();
match m.get_mut(&key) {
Some((polls, _)) => {
*polls += 1;
*polls > 25
}
None => false,
}
});
if stale {
WEB_EVALS.with(|m| m.borrow_mut().remove(&key));
}
return Err(Reply::fail(
format!("web_eval {id:?}: awaiting the engine"),
true,
));
};
WEB_EVALS.with(|m| m.borrow_mut().remove(&key));
match result {
Err(e) => Err(Reply::fail(format!("web_eval {id:?}: {e}"), true)),
Ok(json) => {
let value = serde_json::from_str::<serde_json::Value>(&json)
.ok()
.and_then(|v| v.as_str().map(str::to_string))
.unwrap_or(json);
let failed = match (&contains, &text) {
(Some(c), _) if !value.contains(c.as_str()) => {
Some(format!("result {value:?} does not contain {c:?}"))
}
(_, Some(t)) if value != *t => {
Some(format!("result {value:?}, expected {t:?}"))
}
_ => None,
};
match failed {
Some(why) => Err(Reply::fail(format!("web_eval {id:?}: {why}"), true)),
None => Ok(Reply::ok()),
}
}
}
}
Step::ContextMenu {
id,
if_present,
item_id,
item,
key,
path,
} => {
if if_present {
day_reactive::flush_sync();
if !with_tree(|t| t.ui_idle()) {
return Err(Reply::fail("ui transitions still settling", true));
}
if with_tree(|t| t.find_by_id(&id)).is_none() {
return Ok(Reply::ok());
}
}
let node = find(&id)?;
let menu = with_tree(|t| t.context_menu_of(node)).ok_or_else(|| {
Reply::fail(
format!("context_menu {id:?}: the element has no menu"),
true,
)
})?;
let items = menu(day_spec::Point::ZERO);
let target_label = match (&item_id, &item, &key) {
(Some(_), _, _) => String::new(),
(None, Some(l), _) => l.clone(),
(None, None, Some(k)) => format_key(k, None),
(None, None, None) => {
return Err(Reply::fail(
"context_menu: needs `item_id:`, `item:` or `key:`",
false,
));
}
};
let path: Vec<(String, String)> = path
.unwrap_or_default()
.into_iter()
.map(|p| {
let resolved = format_key(&p, None);
(p, resolved)
})
.collect();
let matches = find_menu_actions(
&items,
&target_label,
key.as_deref(),
item_id.as_deref(),
&path,
);
let what = match &item_id {
Some(want) => format!("id {want:?}"),
None => format!("{target_label:?}"),
};
match matches.as_slice() {
[] => Err(Reply::fail(
format!("context_menu {id:?}: no item {what}"),
true,
)),
[(action, enabled, _)] => {
if *action == 0 {
Err(Reply::fail(
format!(
"context_menu {id:?}: {what} runs a native command (no day \
action)"
),
false,
))
} else if !enabled {
Err(Reply::fail(
format!("context_menu {id:?}: {what} is disabled"),
true,
))
} else {
day_core::dispatch_menu_action(*action);
day_reactive::flush_sync();
Ok(Reply::ok())
}
}
_ => Err(Reply::fail(
format!("context_menu {id:?}: {what} is ambiguous; add a path"),
false,
)),
}
}
Step::Menu {
id,
item,
key,
path,
} => {
let target_label = match (&id, &item, &key) {
(Some(_), _, _) => String::new(),
(None, Some(l), _) => l.clone(),
(None, None, Some(k)) => format_key(k, None),
(None, None, None) => {
return Err(Reply::fail("menu: needs `id:`, `item:` or `key:`", false));
}
};
let path: Vec<(String, String)> = path
.unwrap_or_default()
.into_iter()
.map(|p| {
let resolved = format_key(&p, None);
(p, resolved)
})
.collect();
let matches = find_menu_actions(
&day_core::menu::app_menu_model(),
&target_label,
key.as_deref(),
id.as_deref(),
&path,
);
let auto_id = match (matches.is_empty(), key.as_deref()) {
(true, Some("day_preferences")) => {
Some(day_core::windows::preferences_action_id())
}
(true, Some("day_new_window")) => {
Some(day_core::windows::new_window_action_id())
}
(true, Some("day_about")) => Some(day_core::windows::about_action_id()),
(true, Some("day_check_for_updates")) => {
Some(day_core::windows::check_for_updates_action_id())
}
_ => None,
};
if let Some(id) = auto_id
&& id != 0
{
day_core::dispatch_menu_action(id);
day_reactive::flush_sync();
return Ok(Reply::ok());
}
let what = match &id {
Some(want) => format!("id {want:?}"),
None => format!("{target_label:?}"),
};
match matches.as_slice() {
[] => Err(Reply::fail(
format!("menu: no item {what}"),
true,
)),
[(action, enabled, _)] => {
if *action == 0 {
Err(Reply::fail(
format!(
"menu: {what} runs a native selector (no day action) — not \
invokable from dayscript"
),
false,
))
} else if !enabled {
Err(Reply::fail(format!("menu: {what} is disabled"), true))
} else {
day_core::dispatch_menu_action(*action);
day_reactive::flush_sync();
Ok(Reply::ok())
}
}
many => Err(Reply::fail(
format!(
"menu: {what} is ambiguous — disambiguate with path: {:?}",
many.iter()
.map(|(_, _, p)| p.join(" ▸ "))
.collect::<Vec<_>>()
),
false,
)),
}
}
Step::Toolbar {
item,
text,
key,
args,
on,
index,
submit,
} => {
let text = match key {
Some(k) => Some(format_key(&k, args)),
None => text,
};
let model = day_core::toolbar::toolbar_model();
let Some(found) = model.iter().find(|i| i.id == item) else {
if item == day_spec::SEARCH_ITEM_ID
&& let Some(host) = day_core::inline_search_host()
{
let Some(t) = text else {
return Err(Reply::fail(
"toolbar: day::search rides the navigation surface here, which takes text (or key) only",
false,
));
};
day_core::enqueue_event(rnode_to_id(host), Event::SearchChanged(t.clone()));
if submit {
day_core::enqueue_event(rnode_to_id(host), Event::SearchSubmitted(t));
}
day_reactive::flush_sync();
return Ok(Reply::ok());
}
return Err(Reply::fail(format!("toolbar: no item {item:?}"), true));
};
if !found.enabled {
return Err(Reply::fail(format!("toolbar: {item:?} is disabled"), false));
}
if found.action == 0 {
return Err(Reply::fail(
format!("toolbar: {item:?} has no command"),
false,
));
}
if let day_spec::ToolbarItemKind::Segmented { segments, .. } = &found.kind {
let Some(i) = index else {
return Err(Reply::fail(
format!("toolbar: {item:?} is segmented — say `index: <n>`"),
false,
));
};
if i >= segments.len() {
return Err(Reply::fail(
format!(
"toolbar: {item:?} has {} segments, asked for {i}",
segments.len()
),
false,
));
}
day_core::toolbar::dispatch_toolbar_value(
found.action,
&day_spec::ToolbarValue::Selected(i),
);
day_reactive::flush_sync();
return Ok(Reply::ok());
}
if matches!(found.kind, day_spec::ToolbarItemKind::Toggle { .. })
&& on.is_none()
&& text.is_none()
{
return Err(Reply::fail(
format!("toolbar: {item:?} is a toggle — say `on: true` or `on: false`"),
false,
));
}
if submit && text.is_none() {
return Err(Reply::fail(
format!("toolbar: submitting {item:?} needs `text:` (or `key:`)"),
false,
));
}
match (text, on) {
(Some(t), _) => {
day_core::toolbar::synthesize_toolbar_value(
found.action,
&day_spec::ToolbarValue::Text(t.clone()),
);
if submit {
day_reactive::flush_sync();
day_core::toolbar::dispatch_toolbar_value(
found.action,
&day_spec::ToolbarValue::Submit(t),
);
}
}
(None, Some(v)) => day_core::toolbar::dispatch_toolbar_value(
found.action,
&day_spec::ToolbarValue::On(v),
),
(None, None) => day_core::dispatch_menu_action(found.action),
}
day_reactive::flush_sync();
Ok(Reply::ok())
}
Step::AssertVisible { id } => {
visible(&id)?;
Ok(Reply::ok())
}
Step::AssertHidden { id } => {
let Some(node) = with_tree(|t| t.find_by_id(&id)) else {
return Ok(Reply::ok());
};
let empty = with_tree(|t| t.node_frame(node))
.is_none_or(|f| f.size.width <= 0.0 || f.size.height <= 0.0);
let native = with_tree(|t| t.read_native(node)).unwrap_or_default();
if empty || (native.found && native.visible == Some(false)) {
Ok(Reply::ok())
} else {
Err(Reply::fail(format!("element {id:?} is shown"), true))
}
}
Step::AssertMissing { id } => match with_tree(|t| t.find_by_id(&id)) {
Some(_) => Err(Reply::fail(format!("element {id:?} is present"), true)),
None => Ok(Reply::ok()),
},
Step::AssertText {
id,
text,
key,
args,
..
} => {
let actual = norm(&probe(&id)?.text);
let expected = if let Some(k) = key {
norm(&format_key(&k, args))
} else {
norm(&text.unwrap_or_default())
};
if actual == expected {
Ok(Reply::ok())
} else {
Err(Reply::fail(
format!("{id:?}: expected {expected:?}, found {actual:?}"),
true,
))
}
}
Step::AssertNoPlaceholders { allow } => {
let unexpected: Vec<&str> = day_spec::placeholder::seen()
.into_iter()
.filter(|k| !allow.iter().any(|a| a == k))
.collect();
if unexpected.is_empty() {
Ok(Reply::ok())
} else {
Err(Reply::fail(
format!(
"rendered a placeholder for {} — no renderer on this backend. Enable \
the piece's feature for this toolkit, or add the kind to `allow:` if \
the gap is intended.",
unexpected.join(", ")
),
true,
))
}
}
Step::AssertValue { id, value } => {
let p = probe(&id)?;
let ok = match &value {
serde_json::Value::Bool(b) => p.flag == *b,
serde_json::Value::Number(n) => {
(p.value - n.as_f64().unwrap_or(f64::NAN)).abs() < 0.5
}
serde_json::Value::String(s) => norm(&p.text) == norm(s),
_ => false,
};
if ok {
Ok(Reply::ok())
} else {
Err(Reply::fail(
format!(
"{id:?}: expected {value}, probe text={:?} value={} flag={}",
p.text, p.value, p.flag
),
true,
))
}
}
Step::AssertAnnounced { text } => {
let said = day_core::conformance::announcements();
if said.iter().any(|s| norm(s) == norm(&text)) {
Ok(Reply::ok())
} else {
Err(Reply::fail(
format!("{text:?} was not announced (announced: {said:?})"),
true,
))
}
}
Step::AssertOpenedUrl { url } => {
let opened = day_core::conformance::opened_urls();
if opened.contains(&url) {
Ok(Reply::ok())
} else {
Err(Reply::fail(
format!("{url:?} was not opened (opened: {opened:?})"),
true,
))
}
}
Step::AssertFrame {
id,
width,
height,
x,
y,
relative_to,
tolerance,
} => {
let tol = tolerance.unwrap_or(1.0);
let node = find(&id)?;
let day = with_tree(|t| t.node_frame(node))
.ok_or_else(|| Reply::fail(format!("{id:?} has no frame"), true))?;
let native = with_tree(|t| t.read_native(node)).and_then(|n| n.frame);
let (base_day, base_native) = match &relative_to {
Some(other) => {
let o = find(other)?;
let f = with_tree(|t| t.node_frame(o))
.ok_or_else(|| Reply::fail(format!("{other:?} has no frame"), true))?;
let n = with_tree(|t| t.read_native(o)).and_then(|n| n.frame);
(f.origin, n.map(|r| r.origin))
}
None => (day_spec::Point::ZERO, Some(day_spec::Point::ZERO)),
};
let mut fails = Vec::new();
let mut check = |source: &str, f: day_spec::Rect, base: day_spec::Point| {
let got = [
("width", f.size.width, width),
("height", f.size.height, height),
("x", f.origin.x - base.x, x),
("y", f.origin.y - base.y, y),
];
for (name, value, want) in got {
if let Some(w) = want
&& (value - w).abs() > tol
{
fails.push(format!("{source} {name} {value:.1} ≠ {w}"));
}
}
};
check("Day", day, base_day);
let unread = match (native, base_native) {
(Some(f), Some(base)) => {
check("native", f, base);
false
}
_ => true,
};
if !fails.is_empty() {
return Err(Reply::fail(format!("{id:?}: {}", fails.join("; ")), true));
}
Ok(Reply {
data: unread.then(|| serde_json::json!({ "unread": ["frame"] })),
..Reply::ok()
})
}
Step::SamplePixel {
id,
x,
y,
color,
tolerance,
} => {
let want = parse_hex_color(&color).ok_or_else(|| {
Reply::fail(format!("sample_pixel: {color:?} is not #rrggbb"), false)
})?;
if day_core::capability(day_spec::Cap::Snapshot) == day_spec::Support::Unsupported {
return Ok(Reply {
data: Some(serde_json::json!({ "unread": ["pixel"] })),
..Reply::ok()
});
}
day_reactive::flush_sync();
if !with_tree(|t| t.ui_idle()) {
return Err(Reply::fail("ui transitions still settling", true));
}
hosts_settled()?;
let readiness = with_tree(|t| t.prepare_snapshot(None, revision))
.map_err(|e| Reply::fail(format!("sample_pixel readiness: {e}"), false))?;
if readiness == day_spec::capture::Readiness::Pending {
return Err(Reply {
capture_pending: true,
..Reply::fail("waiting for a render checkpoint", true)
});
}
let node = find(&id)?;
let frame = with_tree(|t| t.node_frame(node))
.ok_or_else(|| Reply::fail(format!("{id:?} has no frame"), true))?;
let window = with_tree(|t| t.node_frame(t.root_node()))
.ok_or_else(|| Reply::fail("the window has no frame", true))?;
let bytes = with_tree(|t| t.snapshot())
.map_err(|e| Reply::fail(format!("sample_pixel capture: {e}"), true))?;
let origin = with_tree(|t| t.snapshot_origin());
let Ok(img) = png::decode(&bytes) else {
return Ok(Reply {
data: Some(serde_json::json!({ "unread": ["pixel"] })),
..Reply::ok()
});
};
let (scale, left, above) = match origin {
Some(o) => (
img.width as f64 / (window.size.width + 2.0 * o.x).max(1.0),
o.x,
o.y,
),
None => {
let scale = img.width as f64 / window.size.width.max(1.0);
let above = (img.height as f64 / scale - window.size.height).max(0.0);
(scale, 0.0, above)
}
};
let px = ((left + frame.origin.x - window.origin.x + x * frame.size.width) * scale)
.floor()
.max(0.0) as usize;
let py = ((above + frame.origin.y - window.origin.y + y * frame.size.height)
* scale)
.floor()
.max(0.0) as usize;
let got = img.pixel(px, py).ok_or_else(|| {
Reply::fail(
format!("{id:?}: ({px}, {py}) is outside the capture"),
false,
)
})?;
let tol = tolerance.unwrap_or(64);
let near = (0..3).all(|i| got[i].abs_diff(want[i]) <= tol);
if near {
Ok(Reply::ok())
} else {
Err(Reply::fail(
format!(
"{id:?} at ({x}, {y}): #{:02x}{:02x}{:02x} ≠ {color}",
got[0], got[1], got[2]
),
true,
))
}
}
Step::AssertNative {
id,
text,
number,
checked,
enabled,
visible,
} => {
let node = find(&id)?;
let native = with_tree(|t| t.read_native(node)).unwrap_or_default();
if let Some(want) = enabled
&& probe(&id)?.enabled != want
{
return Err(Reply::fail(
format!("{id:?}: Day has enabled={}, expected {want}", !want),
true,
));
}
let mut unread = Vec::new();
let mut fails = Vec::new();
let mut check = |field: &str,
got: Option<String>,
want: Option<String>,
eq: bool| match (got, want) {
(_, None) => {}
(None, Some(_)) => unread.push(field.to_owned()),
(Some(g), Some(w)) if !eq => {
fails.push(format!("native {field} {g} ≠ expected {w}"))
}
_ => {}
};
let text_eq =
matches!((&native.text, &text), (Some(g), Some(w)) if norm(g) == norm(w));
check(
"text",
native.text.as_ref().map(|t| format!("{t:?}")),
text.as_ref().map(|t| format!("{t:?}")),
text_eq,
);
let number_eq = matches!((native.number, number), (Some(g), Some(w)) if (g - w).abs() <= 1e-3 * w.abs().max(1.0));
check(
"number",
native.number.map(|n| n.to_string()),
number.map(|n| n.to_string()),
number_eq,
);
check(
"checked",
native.checked.map(|b| b.to_string()),
checked.map(|b| b.to_string()),
native.checked == checked,
);
check(
"enabled",
native.enabled.map(|b| b.to_string()),
enabled.map(|b| b.to_string()),
native.enabled == enabled,
);
check(
"visible",
native.visible.map(|b| b.to_string()),
visible.map(|b| b.to_string()),
native.visible == visible,
);
if !fails.is_empty() {
return Err(Reply::fail(format!("{id:?}: {}", fails.join("; ")), true));
}
Ok(Reply {
data: (!unread.is_empty()).then(|| serde_json::json!({ "unread": unread })),
..Reply::ok()
})
}
Step::ScrollTo { id, edge, x, y } => {
let node = find(&id)?;
let target = match (edge.as_deref(), x, y) {
(Some("top"), _, _) => day_core::ScrollTarget::Top,
(Some("bottom"), _, _) => day_core::ScrollTarget::Bottom,
(Some("leading"), _, _) => day_core::ScrollTarget::Leading,
(Some("trailing"), _, _) => day_core::ScrollTarget::Trailing,
(Some(other), _, _) => {
return Err(Reply::fail(
format!(
"scroll_to: unknown edge {other:?} (top|bottom|leading|trailing)"
),
false,
));
}
(None, None, None) => {
let ok = with_tree(|t| t.scroll_reveal(node, false));
if !ok {
return Err(Reply::fail(
format!("scroll_to: {id:?} has no enclosing scroll"),
true,
));
}
day_reactive::flush_sync();
return Ok(Reply::ok());
}
(None, x, y) => day_core::ScrollTarget::Offset(day_spec::Point::new(
x.unwrap_or(0.0),
y.unwrap_or(0.0),
)),
};
let ok = with_tree(|t| t.scroll_to_target(node, &target, false));
if !ok {
return Err(Reply::fail(
format!("scroll_to: {id:?} does not support this scroll target"),
true,
));
}
day_reactive::flush_sync();
Ok(Reply::ok())
}
Step::Focus { id, focused } => {
let want = focused.unwrap_or(true);
let node = find(&id)?;
with_tree(|t| t.focus_node(node, want));
day_reactive::flush_sync();
if probe(&id)?.focused != want
&& FOCUS_WAITS.fetch_add(1, Ordering::Relaxed) < FOCUS_WAIT_POLLS
{
return Err(Reply::fail(
format!("{id:?}: waiting for the toolkit to report focused={want}"),
true,
));
}
FOCUS_WAITS.store(0, Ordering::Relaxed);
Ok(Reply::ok())
}
Step::AssertFocused { id, focused } => {
let want = focused.unwrap_or(true);
let got = probe(&id)?.focused;
if got == want {
Ok(Reply::ok())
} else {
Err(Reply::fail(
format!("{id:?}: expected focused={want}, found focused={got}"),
true,
))
}
}
Step::CloseWindow { window } => {
let handle = match &window {
Some(key) => day_core::window_by_key(key),
None => day_core::initial_window(),
};
if let Some(handle) = handle {
handle.close();
}
day_reactive::flush_sync();
Ok(Reply::ok())
}
Step::Screenshot {
window, in_process, ..
} => {
day_reactive::flush_sync();
if !with_tree(|t| t.ui_idle()) {
return Err(Reply::fail("ui transitions still settling", true));
}
hosts_settled()?;
let root = match window.as_deref() {
Some(key) => Some(
day_core::windows::window_root_by_key(key)
.ok_or_else(|| Reply::fail(format!("no window {key:?}"), true))?,
),
None => None,
};
let readiness = with_tree(|t| t.prepare_snapshot(root, revision))
.map_err(|e| Reply::fail(format!("screenshot readiness: {e}"), false))?;
if readiness == day_spec::capture::Readiness::Pending {
return Err(Reply {
capture_pending: true,
..Reply::fail("waiting for screenshot render checkpoint", true)
});
}
let capture_revision =
(readiness == day_spec::capture::Readiness::Ready).then_some(revision);
if !in_process {
return Ok(Reply {
capture_revision,
..Reply::ok()
});
}
let png = match window.as_deref() {
Some(key) => match day_core::windows::window_root_by_key(key) {
Some(root) => with_tree(|t| t.snapshot_of(root)),
None => return Err(Reply::fail(format!("no window {key:?}"), true)),
},
None => with_tree(|t| t.snapshot()),
};
match png {
Ok(bytes) => {
SNAPSHOT_MISSES.store(0, Ordering::Relaxed);
SNAPSHOT_WORKS.store(true, Ordering::Relaxed);
Ok(Reply {
ok: true,
png_base64: Some(b64encode(&bytes)),
capture_revision: Some(revision),
..Default::default()
})
}
Err(_)
if (SNAPSHOT_WORKS.load(Ordering::Relaxed)
|| !SNAPSHOT_NEVER.load(Ordering::Relaxed))
&& SNAPSHOT_MISSES.fetch_add(1, Ordering::Relaxed)
< SNAPSHOT_RETRIES =>
{
Err(Reply::fail("the window has nothing to capture yet", true))
}
Err(_) => {
SNAPSHOT_MISSES.store(0, Ordering::Relaxed);
if !SNAPSHOT_WORKS.load(Ordering::Relaxed) {
SNAPSHOT_NEVER.store(true, Ordering::Relaxed);
}
Ok(Reply {
ok: true,
screenshot_unsupported: true,
..Default::default()
})
}
}
}
Step::Pause { secs } => {
let _ = secs;
Ok(Reply::ok())
}
Step::ExpectExit { within } => {
let _ = within;
Ok(Reply::ok())
}
Step::SizeClass { width, height } => {
if width == "auto" {
day_core::restore_reported_size_class();
day_reactive::flush_sync();
return Ok(Reply::ok());
}
let width = parse_width_class(&width).ok_or_else(|| {
Reply::fail(
format!(
"size_class: unknown width {width:?} \
(auto|compact|medium|expanded|large|extra-large)"
),
false,
)
})?;
let height = match height.as_deref() {
None => day_spec::HeightClass::Expanded,
Some(h) => parse_height_class(h).ok_or_else(|| {
Reply::fail(
format!("size_class: unknown height {h:?} (compact|medium|expanded)"),
false,
)
})?,
};
day_core::override_size_class(day_spec::SizeClass { width, height });
day_reactive::flush_sync();
Ok(Reply::ok())
}
Step::Resize {
width,
height,
restore,
} => {
if !with_tree(|t| t.ui_idle()) {
return Err(Reply::fail("ui transitions still settling", true));
}
day_core::restore_reported_size_class();
day_reactive::flush_sync();
let (Some(w), Some(h)) = (width, height) else {
let _ = restore;
return Ok(Reply::ok());
};
let want = day_spec::SizeClass::from_size(w, h).width;
let have = day_core::size_class();
if have.map(|c| c.width) == Some(want) {
Ok(Reply::ok())
} else {
Err(Reply::fail(
format!(
"resize to {w}x{h} wants width {want:?}, window reports {have:?} \
(a width within a few points of a breakpoint can fall the other \
side of it once safe-area insets come out — aim for mid-bucket)"
),
true,
))
}
}
Step::OpenUrl { url } => {
day_core::request_open_url(&url);
Ok(Reply::ok())
}
Step::DeepLink { url } => {
day_reactive::flush_sync();
let route = day_spec::route_of_url(&url);
if day_core::navigate(&route) {
day_reactive::flush_sync();
Ok(Reply::ok())
} else {
Err(Reply::fail(format!("no route for {url:?}"), true))
}
}
Step::Navigate { route } => {
day_reactive::flush_sync();
if day_core::navigate(&route) {
day_reactive::flush_sync();
Ok(Reply::ok())
} else {
Err(Reply::fail(format!("no route {route:?}"), true))
}
}
Step::NavBack { native } => {
if native && !with_tree(|t| t.ui_idle()) {
return Err(Reply::fail("ui transitions still settling", true));
}
let popped = if native {
with_tree(|t| t.native_back())
} else {
day_core::nav_back()
};
if popped {
if !native {
day_reactive::flush_sync();
}
Ok(Reply::ok())
} else if day_core::size_class().is_some_and(|c| c.prefers_split()) {
Ok(Reply::ok())
} else {
Err(Reply::fail("nothing to pop", true))
}
}
Step::AssertRoute { route } => {
let current = day_core::current_route();
if current.as_deref() == Some(route.as_str()) {
Ok(Reply::ok())
} else {
Err(Reply::fail(
format!("expected route {route:?}, current {current:?}"),
true,
))
}
}
Step::DialogMode { mode } => {
let mode = match mode {
DialogMode::Native => day_core::PresentationMode::Native,
DialogMode::Scripted => day_core::PresentationMode::Scripted,
};
day_core::set_presentation_mode(mode).map_err(|why| Reply::fail(why, false))?;
Ok(Reply::ok())
}
Step::AssertNotPresented => {
if let Some((_, spec)) = day_core::pending_presentation() {
Err(Reply::fail(
format!("unanswered presentation: {:?}", spec.title()),
true,
))
} else {
Ok(Reply::ok())
}
}
Step::AssertPresented { title } => match day_core::pending_presentation() {
Some((_, spec)) => {
let actual = norm(spec.title());
match title {
Some(want) if norm(&want) != actual => Err(Reply::fail(
format!("modal title {actual:?} != expected {want:?}"),
true,
)),
_ => Ok(Reply::ok()),
}
}
None => Err(Reply::fail("no modal presented", true)),
},
Step::Respond {
button,
text,
path,
dismiss,
} => {
let Some((req, _)) = day_core::pending_presentation() else {
return Err(Reply::fail("no modal to respond to", true));
};
let result = if dismiss {
PresentResult::Dismissed
} else if let Some(t) = text {
PresentResult::Text(t)
} else if let Some(p) = path {
let pb = std::path::PathBuf::from(&p);
let full = if pb.is_absolute() {
pb
} else {
day_core::app_temp_dir().join(pb)
};
PresentResult::Files(vec![full.to_string_lossy().into_owned()])
} else if let Some(i) = button {
PresentResult::Button(i)
} else {
PresentResult::Dismissed
};
day_core::respond_presentation(req, result);
day_reactive::flush_sync();
Ok(Reply::ok())
}
Step::Tests => Ok(Reply {
data: Some(conformance::listing().map_err(|e| Reply::fail(e, false))?),
..Reply::ok()
}),
Step::RunTests {
filter,
shots,
case_timeout_secs,
..
} => conformance::run_tests(&filter, shots, case_timeout_secs),
Step::A11yAudit { id } => {
let rows = with_tree(|t| t.a11y_nodes());
let rows: Vec<_> = match &id {
Some(want) => rows.into_iter().filter(|(nid, ..)| nid == want).collect(),
None => rows,
};
if let Some(want) = &id
&& rows.is_empty()
{
return Err(Reply::fail(
format!("a11y_audit: no element {want:?}"),
true,
));
}
let mut fails = Vec::new();
for (nid, _kind, expected, actual) in &rows {
audit_a11y_node(nid, expected, actual, &mut fails);
}
if !fails.is_empty() {
return Err(Reply::fail(
format!("a11y_audit: {}", fails.join("; ")),
false,
));
}
Ok(Reply::ok())
}
}
})();
let mut reply = result.unwrap_or_else(|r| r);
if reply.ok
&& !absent_optional_action
&& let (Some(class), Some(id)) = (evidence_class, evidence_id)
&& let Ok(catalog) = id_catalog()
&& let Ok(d) = catalog.resolve(&id)
{
reply.id_evidence = Box::new([day_script_protocol::IdEvidence {
family: d.family.clone(),
class,
}]);
}
reply.fast_animations = Some(day_core::testing::fast_animations());
reply
}
fn audit_a11y_node(
nid: &str,
expected: &day_spec::A11yProps,
actual: &day_spec::NativeSnapshot,
fails: &mut Vec<String>,
) {
if !actual.found || actual.visible == Some(false) {
return;
}
if actual.identifier.as_deref() != Some(nid) {
fails.push(format!(
"{nid}: native identifier {:?} ≠ {nid:?}",
actual.identifier
));
}
if expected.role != day_spec::Role::None
&& actual.role != day_spec::Role::None
&& !role_eq(expected.role, actual.role)
{
fails.push(format!(
"{nid}: role {:?} ≠ expected {:?}",
actual.role, expected.role
));
}
if let Some(lbl) = &expected.label
&& actual.label.as_deref() != Some(lbl.as_str())
{
fails.push(format!(
"{nid}: label {:?} ≠ expected {lbl:?}",
actual.label
));
}
if let Some(val) = &expected.value
&& actual.value.as_deref() != Some(val.as_str())
{
fails.push(format!(
"{nid}: value {:?} ≠ expected {val:?}",
actual.value
));
}
}
fn role_eq(a: day_spec::Role, b: day_spec::Role) -> bool {
use day_spec::Role::Heading;
matches!((a, b), (Heading(_), Heading(_))) || a == b
}
const B64: &[u8; 64] = b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
pub fn b64encode(data: &[u8]) -> String {
let mut out = String::with_capacity(data.len().div_ceil(3) * 4);
for chunk in data.chunks(3) {
let b = [
chunk[0],
*chunk.get(1).unwrap_or(&0),
*chunk.get(2).unwrap_or(&0),
];
let n = ((b[0] as u32) << 16) | ((b[1] as u32) << 8) | b[2] as u32;
out.push(B64[(n >> 18) as usize & 63] as char);
out.push(B64[(n >> 12) as usize & 63] as char);
out.push(if chunk.len() > 1 {
B64[(n >> 6) as usize & 63] as char
} else {
'='
});
out.push(if chunk.len() > 2 {
B64[n as usize & 63] as char
} else {
'='
});
}
out
}
pub fn b64decode(s: &str) -> Vec<u8> {
let val = |c: u8| B64.iter().position(|&x| x == c).unwrap_or(0) as u32;
let bytes: Vec<u8> = s.bytes().filter(|&c| c != b'\n' && c != b'\r').collect();
let mut out = Vec::with_capacity(bytes.len() / 4 * 3);
for chunk in bytes.chunks(4) {
if chunk.len() < 4 {
break;
}
let pad = chunk.iter().filter(|&&c| c == b'=').count();
let n = (val(chunk[0]) << 18)
| (val(chunk[1]) << 12)
| (val(if chunk[2] == b'=' { b'A' } else { chunk[2] }) << 6)
| val(if chunk[3] == b'=' { b'A' } else { chunk[3] });
out.push((n >> 16) as u8);
if pad < 2 {
out.push((n >> 8) as u8);
}
if pad < 1 {
out.push(n as u8);
}
}
out
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn a11y_audit_checks_metadata_when_visible_or_visibility_is_unknown() {
let expected = day_spec::A11yProps {
label: Some("Fixture list".into()),
..Default::default()
};
let mut actual = day_spec::NativeSnapshot {
found: true,
identifier: Some("fixture-list".into()),
visible: Some(false),
..Default::default()
};
let mut fails = Vec::new();
audit_a11y_node("fixture-list", &expected, &actual, &mut fails);
assert!(
fails.is_empty(),
"hidden panes need not expose their labels"
);
for visible in [Some(true), None] {
actual.visible = visible;
fails.clear();
audit_a11y_node("fixture-list", &expected, &actual, &mut fails);
assert_eq!(
fails.len(),
1,
"missing labels must still fail: {visible:?}"
);
assert!(fails[0].contains("label None"));
}
actual.visible = Some(true);
actual.label = expected.label.clone();
fails.clear();
audit_a11y_node("fixture-list", &expected, &actual, &mut fails);
assert!(
fails.is_empty(),
"the list exposes its label when shown again"
);
actual.label = None;
actual.found = false;
audit_a11y_node("fixture-list", &expected, &actual, &mut fails);
assert!(
fails.is_empty(),
"unreadable accessibility nodes remain unsupported"
);
}
#[test]
fn dialog_steps_hold_requests_until_an_explicit_response() {
use day_spec::present::{PresentResult, PresentSpec};
use std::future::Future;
use std::task::{Context, Poll, Waker};
assert!(serde_json::from_str::<Step>(r#"{"op":"dialog_mode","mode":"typo"}"#).is_err());
let mode: Step = serde_json::from_str(r#"{"op":"dialog_mode","mode":"scripted"}"#).unwrap();
assert!(exec(mode, 0).ok);
assert!(exec(Step::AssertNotPresented, 0).ok);
let mut future = Box::pin(day_core::present(PresentSpec::OpenFile {
title: "Choose file".into(),
filters: vec![],
multiple: false,
}));
let mut cx = Context::from_waker(Waker::noop());
assert!(future.as_mut().poll(&mut cx).is_pending());
assert!(
exec(
Step::AssertPresented {
title: Some("Choose file".into())
},
0
)
.ok
);
assert!(!exec(Step::AssertNotPresented, 0).ok);
let refused = exec(
Step::DialogMode {
mode: DialogMode::Native,
},
0,
);
assert!(!refused.ok && !refused.retryable);
assert!(
exec(
Step::Respond {
button: None,
text: None,
path: None,
dismiss: true
},
0
)
.ok
);
assert_eq!(
future.as_mut().poll(&mut cx),
Poll::Ready(PresentResult::Dismissed)
);
assert!(exec(Step::AssertNotPresented, 0).ok);
assert!(
exec(
Step::DialogMode {
mode: DialogMode::Native
},
0
)
.ok
);
}
#[test]
fn optional_tap_only_skips_absent_elements_after_transitions_settle() {
use day_pieces::prelude::*;
let _guard = ENV_LOCK.lock().unwrap_or_else(|e| e.into_inner());
day_core::uninstall_tree();
let enabled = Signal::new(false);
let presses = Signal::new(0);
let (mock, probe) = day_mock::MockToolkit::new();
day_core::launch_with(mock, day_spec::WindowOptions::default(), move || {
button("Remove fixture")
.enabled(move || enabled.get())
.action(move || presses.update(|n| *n += 1))
.id(day_core::id!(remove_fixture))
.height(50.)
.grow(Dimension::Width)
.any()
});
let tap = |id, optional| {
exec(
serde_json::from_value(serde_json::json!({
"op": "tap", "id": id, "if_present": optional
}))
.unwrap(),
1,
)
};
assert!(!tap("missing", false).ok);
let absent = tap("missing", true);
assert!(absent.ok);
assert!(absent.id_evidence.is_empty());
probe.state.borrow_mut().ui_busy = true;
assert!(!tap("missing", true).ok);
probe.state.borrow_mut().ui_busy = false;
let disabled = tap("remove_fixture", true);
assert!(!disabled.ok && disabled.retryable);
assert_eq!(presses.get(), 0);
enabled.set(true);
id_catalog().expect("the compiled test fixture registry is valid");
let present = tap("remove_fixture", true);
assert!(present.ok);
assert_eq!(present.id_evidence.len(), 1);
assert_eq!(present.id_evidence[0].family, "remove_fixture");
assert_eq!(
present.id_evidence[0].class,
day_script_protocol::EvidenceClass::Interaction
);
assert_eq!(presses.get(), 1);
day_core::uninstall_tree();
}
#[test]
fn nav_back_steps_reach_the_system_back_handler() {
use day_pieces::prelude::*;
let _guard = ENV_LOCK.lock().unwrap_or_else(|e| e.into_inner());
day_core::uninstall_tree();
let enabled = Signal::new(true);
let backs = Signal::new(0);
let (mock, probe) = day_mock::MockToolkit::new();
day_core::launch_with(mock, day_spec::WindowOptions::default(), move || {
label("Fixture page")
.on_system_back(move || enabled.get(), move || backs.update(|n| *n += 1))
.any()
});
let back = |native: bool| exec(Step::NavBack { native }, 1);
assert!(back(false).ok);
assert_eq!(backs.get(), 1);
assert!(back(true).ok);
assert_eq!(backs.get(), 2);
enabled.set(false);
day_reactive::flush_sync();
assert!(!probe.system_back_armed());
let _ = back(false);
let _ = back(true);
assert_eq!(backs.get(), 2);
day_core::uninstall_tree();
}
#[test]
fn tap_waits_for_navigation_and_enabled_state_before_dispatching_once() {
use day_pieces::prelude::*;
let _guard = ENV_LOCK.lock().unwrap_or_else(|e| e.into_inner());
day_core::uninstall_tree();
let enabled = Signal::new(false);
let presses = Signal::new(0);
let (mock, probe) = day_mock::MockToolkit::new();
day_core::launch_with(mock, day_spec::WindowOptions::default(), move || {
button("Fixture download")
.enabled(move || enabled.get())
.action(move || presses.update(|n| *n += 1))
.id(day_core::id!(fixture_download))
.height(50.)
.grow(Dimension::Width)
.any()
});
let tap = || {
exec(
serde_json::from_value(serde_json::json!({
"op": "tap", "id": "fixture_download"
}))
.unwrap(),
1,
)
};
let reply = tap();
assert!(!reply.ok && reply.retryable);
assert!(reply.error.unwrap().contains("disabled"));
assert_eq!(presses.get(), 0);
enabled.set(true);
probe.state.borrow_mut().ui_busy = true;
assert!(!tap().ok);
assert!(!exec(Step::WaitIdle, 1).ok);
assert_eq!(presses.get(), 0);
probe.state.borrow_mut().ui_busy = false;
assert!(exec(Step::WaitIdle, 1).ok);
assert!(tap().ok);
assert_eq!(presses.get(), 1);
day_core::uninstall_tree();
}
#[test]
fn capture_acknowledgments_are_optional_and_pending_stays_internal() {
let old: Reply = serde_json::from_str(r#"{"ok":true}"#).unwrap();
assert_eq!(old.capture_revision, None);
assert_eq!(old.fast_animations, None);
let reply = Reply {
capture_revision: Some(73),
fast_animations: Some(true),
capture_pending: true,
..Reply::ok()
};
let json = serde_json::to_value(reply).unwrap();
assert_eq!(json["capture_revision"], 73);
assert!(json.get("capture_pending").is_none());
let decoded: Reply = serde_json::from_value(json).unwrap();
assert_eq!(decoded.capture_revision, Some(73));
assert_eq!(decoded.fast_animations, Some(true));
}
static ENV_LOCK: std::sync::Mutex<()> = std::sync::Mutex::new(());
#[test]
fn the_main_thread_budget_is_generous_overridable_and_never_below_the_step() {
let five = Duration::from_secs(5);
let _guard = ENV_LOCK.lock().unwrap_or_else(|e| e.into_inner());
unsafe { std::env::remove_var("DAY_SCRIPT_MAIN_TIMEOUT_SECS") };
assert_eq!(
main_thread_budget(five),
Duration::from_secs_f64(DEFAULT_MAIN_TIMEOUT_SECS)
);
assert_eq!(
main_thread_budget(Duration::from_secs(120)),
Duration::from_secs(120)
);
unsafe { std::env::set_var("DAY_SCRIPT_MAIN_TIMEOUT_SECS", "90") };
assert_eq!(main_thread_budget(five), Duration::from_secs(90));
for bad in ["0", "-3", "abc", ""] {
unsafe { std::env::set_var("DAY_SCRIPT_MAIN_TIMEOUT_SECS", bad) };
assert_eq!(
main_thread_budget(five),
Duration::from_secs_f64(DEFAULT_MAIN_TIMEOUT_SECS),
"{bad:?} should fall back to the default"
);
}
unsafe { std::env::remove_var("DAY_SCRIPT_MAIN_TIMEOUT_SECS") };
}
#[test]
fn assert_text_honors_its_own_timeout() {
let step = |json: &str| serde_json::from_str::<Step>(json).expect("step");
let slow = step(r#"{"op":"assert_text","id":"state","text":"done","timeout_secs":120}"#);
assert_eq!(slow.wait_budget_secs(), 120.0);
let plain = step(r#"{"op":"assert_text","id":"state","text":"done"}"#);
assert_eq!(plain.wait_budget_secs(), DEFAULT_TIMEOUT_SECS);
let waiting = step(r#"{"op":"wait_for","id":"state","timeout_secs":30}"#);
assert_eq!(waiting.wait_budget_secs(), 30.0);
}
#[test]
fn web_eval_honors_its_own_timeout() {
for (timeout, expected) in [
(None, DEFAULT_TIMEOUT_SECS),
(Some(30.0), 30.0),
(Some(0.0), DEFAULT_TIMEOUT_SECS),
(Some(-1.0), DEFAULT_TIMEOUT_SECS),
] {
let step: Step = serde_json::from_value(serde_json::json!({
"op": "web_eval", "id": "page", "script": "document.title",
"timeout_secs": timeout,
}))
.expect("web_eval step");
assert_eq!(step.wait_budget_secs(), expected);
}
}
#[test]
fn menu_id_addresses_an_item_whose_label_moves() {
use day_spec::MenuItem as MI;
let model = |mark: &str| {
vec![MI::Submenu {
label: "View".into(),
role: None,
items: vec![
MI::Action {
id: Some("view-grid".into()),
action: 42,
label: format!("{mark}Grid"),
shortcut: None,
enabled: true,
checked: Some(mark == "\u{2713} "),
role: None,
icon: None,
},
MI::Action {
id: None,
action: 7,
label: "Grid".into(),
shortcut: None,
enabled: true,
checked: None,
role: None,
icon: None,
},
],
}]
};
let by_id = |items: &[MI]| {
find_menu_actions(items, "", None, Some("view-grid"), &[])
.into_iter()
.map(|(a, _, _)| a)
.collect::<Vec<_>>()
};
assert_eq!(by_id(&model("\u{2713} ")), vec![42]);
assert_eq!(by_id(&model(" ")), vec![42]);
assert_eq!(
find_menu_actions(&model(" "), "Grid", None, None, &[])
.into_iter()
.map(|(a, _, _)| a)
.collect::<Vec<_>>(),
vec![7]
);
assert!(
find_menu_actions(&model(" "), "Grid", None, Some("view-ruler"), &[]).is_empty()
);
}
}