akanjs 3.0.0-beta.20 → 3.0.0-beta.21

package/vendor/@akanjs/native/native/desktop/src/contract.rs

@@ -0,0 +1,105 @@
+//! Generated by scripts/contract.ts from packages/core/contract.json. Do not edit.
+#![allow(dead_code)]
+
+pub const ERROR_CODES: &[&str] = &["UNSUPPORTED", "PERMISSION_DENIED", "CANCELLED", "TIMEOUT", "INVALID_ARGS", "NOT_FOUND", "NOT_ALLOWED", "INTERNAL"];
+
+/// File name extension → MIME type (assets and FileRefs).
+pub const MIME: &[(&str, &str)] = &[
+  ("html", "text/html"),
+  ("htm", "text/html"),
+  ("js", "text/javascript"),
+  ("mjs", "text/javascript"),
+  ("css", "text/css"),
+  ("json", "application/json"),
+  ("map", "application/json"),
+  ("webmanifest", "application/manifest+json"),
+  ("txt", "text/plain"),
+  ("text", "text/plain"),
+  ("log", "text/plain"),
+  ("md", "text/markdown"),
+  ("csv", "text/csv"),
+  ("tsv", "text/tab-separated-values"),
+  ("xml", "application/xml"),
+  ("yaml", "application/yaml"),
+  ("yml", "application/yaml"),
+  ("ics", "text/calendar"),
+  ("vcf", "text/vcard"),
+  ("pdf", "application/pdf"),
+  ("rtf", "application/rtf"),
+  ("zip", "application/zip"),
+  ("gz", "application/gzip"),
+  ("tar", "application/x-tar"),
+  ("wasm", "application/wasm"),
+  ("epub", "application/epub+zip"),
+  ("doc", "application/msword"),
+  ("docx", "application/vnd.openxmlformats-officedocument.wordprocessingml.document"),
+  ("xls", "application/vnd.ms-excel"),
+  ("xlsx", "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"),
+  ("ppt", "application/vnd.ms-powerpoint"),
+  ("pptx", "application/vnd.openxmlformats-officedocument.presentationml.presentation"),
+  ("png", "image/png"),
+  ("jpg", "image/jpeg"),
+  ("jpeg", "image/jpeg"),
+  ("gif", "image/gif"),
+  ("webp", "image/webp"),
+  ("avif", "image/avif"),
+  ("heic", "image/heic"),
+  ("heif", "image/heif"),
+  ("bmp", "image/bmp"),
+  ("svg", "image/svg+xml"),
+  ("ico", "image/x-icon"),
+  ("tif", "image/tiff"),
+  ("tiff", "image/tiff"),
+  ("mp3", "audio/mpeg"),
+  ("m4a", "audio/mp4"),
+  ("aac", "audio/aac"),
+  ("wav", "audio/wav"),
+  ("ogg", "audio/ogg"),
+  ("flac", "audio/flac"),
+  ("mp4", "video/mp4"),
+  ("m4v", "video/mp4"),
+  ("mov", "video/quicktime"),
+  ("webm", "video/webm"),
+  ("ttf", "font/ttf"),
+  ("otf", "font/otf"),
+  ("woff", "font/woff"),
+  ("woff2", "font/woff2"),
+  ("glb", "model/gltf-binary"),
+  ("gltf", "model/gltf+json"),
+];
+
+/// Besides text/*, the asset types served with charset=utf-8.
+pub const MIME_UTF8: &[&str] = &["application/json", "application/manifest+json", "application/xml", "application/yaml", "image/svg+xml", "model/gltf+json"];
+
+/// An id grammar: allowed characters, length, and an optional extension after the first dot.
+pub struct IdSpec {
+  pub chars: &'static str,
+  pub first: &'static str,
+  pub not_first: &'static str,
+  pub min: usize,
+  pub max: usize,
+  pub ext_chars: &'static str,
+  pub ext_max: usize,
+}
+
+pub const ID_FILE_REF: IdSpec = IdSpec { chars: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_-", first: "", not_first: "", min: 1, max: 128, ext_chars: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789", ext_max: 8 };
+pub const ID_BUNDLE: IdSpec = IdSpec { chars: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_.-", first: "", not_first: ".", min: 1, max: 80, ext_chars: "", ext_max: 0 };
+pub const ID_DOCUMENT: IdSpec = IdSpec { chars: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_-", first: "", not_first: "", min: 8, max: 64, ext_chars: "", ext_max: 0 };
+pub const ID_NAME: IdSpec = IdSpec { chars: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_.-", first: "$ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", not_first: "", min: 1, max: 64, ext_chars: "", ext_max: 0 };
+
+pub const EXTERNAL_SCHEMES: &[&str] = &["http", "https", "mailto", "tel"];
+pub const FRAME_SCHEMES: &[&str] = &["http", "https", "data", "blob", "about"];
+/// Schemes an app can never add to the external list.
+pub const NEVER_EXTERNAL_SCHEMES: &[&str] = &["javascript", "vbscript", "file", "data", "blob", "about", "content", "intent", "app"];
+
+pub const ROUTE_ROOT: &str = "__akan_native";
+pub const ROUTE_INIT: &str = "init.js";
+pub const ROUTE_IPC: &str = "ipc";
+pub const ROUTE_HELLO: &str = "hello";
+pub const ROUTE_FILE: &str = "file";
+
+pub const INIT_PREFIX: &str = "window.__AKAN_NATIVE__=(function(o,b,e){for(var k in b)o[k]=b[k];o.env=e;return o})(window.__AKAN_NATIVE__||{},";
+pub const INIT_SUFFIX: &str = ");\n";
+pub const MAX_RANGE_BYTES: usize = 1024000;
+pub const EXTERNAL_OPENS_PER_SECOND: u32 = 1;
+pub const MAX_RETAINED_EVENTS: usize = 16;

package/vendor/@akanjs/native/native/desktop/src/devproxy.rs

@@ -0,0 +1,234 @@
+//! `akan-native dev --hmr` (dev builds): app:// page requests are fetched from the dev gateway on the
+//! loopback interface (packages/cli/src/lib/hmr.ts) instead of Resources/app, keeping the page on
+//! app://localhost. A minimal HTTP/1.1 client over std::net, since there is no HTTP client crate
+//! in the tree and none is added: one request per connection (`Connection: close`), response
+//! bodies delimited by Content-Length, chunked transfer coding, or the end of the connection.
+
+use std::io::{Read, Write};
+use std::net::{TcpStream, ToSocketAddrs};
+use std::time::Duration;
+
+#[derive(Debug, PartialEq, Eq)]
+pub struct Reply {
+  pub status: u16,
+  pub headers: Vec<(String, String)>,
+  pub body: Vec<u8>,
+}
+
+/// "http://127.0.0.1:4173" → "127.0.0.1:4173". Only plain http to a loopback host with a port:
+/// the gateway always runs on the developer's machine.
+pub fn authority(base: &str) -> Option<&str> {
+  let rest = base.strip_prefix("http://")?.trim_end_matches('/');
+  let (host, port) = rest.rsplit_once(':')?;
+  let loopback = matches!(host, "127.0.0.1" | "localhost" | "[::1]");
+  (loopback && port.parse::<u16>().is_ok_and(|p| p > 0)).then_some(rest)
+}
+
+const MAX_HEAD: usize = 64 * 1024;
+
+pub fn fetch(authority: &str, method: &str, target: &str, headers: &[(String, String)], body: &[u8]) -> Result<Reply, String> {
+  let addr = authority.to_socket_addrs().map_err(|e| format!("{authority}: {e}"))?.next().ok_or_else(|| format!("{authority}: no address"))?;
+  let mut stream = TcpStream::connect_timeout(&addr, Duration::from_secs(2)).map_err(|e| format!("{authority}: {e}"))?;
+  // Bun bundles on the first request for a page, which can take a few seconds.
+  let _ = stream.set_read_timeout(Some(Duration::from_secs(60)));
+  let _ = stream.set_nodelay(true);
+  stream.write_all(&request_head(authority, method, target, headers, body.len())).map_err(|e| e.to_string())?;
+  stream.write_all(body).map_err(|e| e.to_string())?;
+  read_response(&mut stream, method == "HEAD")
+}
+
+fn request_head(authority: &str, method: &str, target: &str, headers: &[(String, String)], body_len: usize) -> Vec<u8> {
+  let mut head = format!("{method} {target} HTTP/1.1\r\nHost: {authority}\r\nConnection: close\r\nAccept-Encoding: identity\r\n");
+  for (name, value) in headers {
+    // Never let a value end the header line.
+    if !name.is_empty() && !name.contains([':', '\r', '\n']) && !value.contains(['\r', '\n']) {
+      head.push_str(&format!("{name}: {value}\r\n"));
+    }
+  }
+  if body_len > 0 || matches!(method, "POST" | "PUT" | "PATCH") {
+    head.push_str(&format!("Content-Length: {body_len}\r\n"));
+  }
+  head.push_str("\r\n");
+  head.into_bytes()
+}
+
+fn find(haystack: &[u8], needle: &[u8]) -> Option<usize> {
+  haystack.windows(needle.len()).position(|w| w == needle)
+}
+
+/// Reads more bytes into `buf`; the connection ending here is an error (a truncated response).
+fn fill(r: &mut impl Read, buf: &mut Vec<u8>) -> Result<(), String> {
+  let mut chunk = [0u8; 16 * 1024];
+  let n = r.read(&mut chunk).map_err(|e| e.to_string())?;
+  if n == 0 {
+    return Err("connection closed before the response was complete".into());
+  }
+  buf.extend_from_slice(&chunk[..n]);
+  Ok(())
+}
+
+pub fn read_response(r: &mut impl Read, head_only: bool) -> Result<Reply, String> {
+  let mut buf = Vec::new();
+  let end = loop {
+    if let Some(i) = find(&buf, b"\r\n\r\n") {
+      break i;
+    }
+    if buf.len() > MAX_HEAD {
+      return Err("response headers too large".into());
+    }
+    fill(r, &mut buf)?;
+  };
+  let head = std::str::from_utf8(&buf[..end]).map_err(|_| "response headers are not UTF-8".to_string())?;
+  let mut lines = head.split("\r\n");
+  let status_line = lines.next().unwrap_or_default();
+  let status = status_line
+    .strip_prefix("HTTP/1.")
+    .and_then(|s| s.split(' ').nth(1))
+    .and_then(|s| s.parse::<u16>().ok())
+    .filter(|s| (100..600).contains(s))
+    .ok_or_else(|| format!("bad status line {status_line:?}"))?;
+  let headers: Vec<(String, String)> = lines.filter_map(|l| l.split_once(':')).map(|(k, v)| (k.trim().to_string(), v.trim().to_string())).collect();
+  let header = |name: &str| headers.iter().find(|(k, _)| k.eq_ignore_ascii_case(name)).map(|(_, v)| v.as_str());
+  let rest = buf[end + 4..].to_vec();
+
+  let body = if head_only || status == 204 || status == 304 || status < 200 {
+    Vec::new()
+  } else if header("transfer-encoding").is_some_and(|v| v.to_ascii_lowercase().contains("chunked")) {
+    dechunk(r, rest)?
+  } else if let Some(len) = header("content-length") {
+    let len: usize = len.parse().map_err(|_| format!("bad content-length {len:?}"))?;
+    let mut body = rest;
+    while body.len() < len {
+      fill(r, &mut body)?;
+    }
+    body.truncate(len);
+    body
+  } else {
+    let mut body = rest;
+    r.read_to_end(&mut body).map_err(|e| e.to_string())?;
+    body
+  };
+  Ok(Reply { status, headers, body })
+}
+
+/// Chunked transfer coding (RFC 9112 §7.1); chunk extensions and trailers are ignored.
+fn dechunk(r: &mut impl Read, mut buf: Vec<u8>) -> Result<Vec<u8>, String> {
+  let mut out = Vec::new();
+  let mut pos = 0;
+  loop {
+    let line_end = loop {
+      if let Some(i) = find(&buf[pos..], b"\r\n") {
+        break pos + i;
+      }
+      fill(r, &mut buf)?;
+    };
+    let line = std::str::from_utf8(&buf[pos..line_end]).map_err(|_| "bad chunk size".to_string())?;
+    let size_text = line.split(';').next().unwrap_or_default().trim();
+    let size = usize::from_str_radix(size_text, 16).map_err(|_| format!("bad chunk size {size_text:?}"))?;
+    pos = line_end + 2;
+    if size == 0 {
+      return Ok(out);
+    }
+    while buf.len() < pos + size + 2 {
+      fill(r, &mut buf)?;
+    }
+    out.extend_from_slice(&buf[pos..pos + size]);
+    pos += size + 2;
+  }
+}
+
+#[cfg(test)]
+mod tests {
+  use super::*;
+  use std::net::TcpListener;
+
+  /// Serves `response` once (in pieces, to exercise the incremental reads) and returns the request.
+  fn serve_once(response: &'static [u8]) -> (String, std::thread::JoinHandle<String>) {
+    let listener = TcpListener::bind("127.0.0.1:0").unwrap();
+    let authority = listener.local_addr().unwrap().to_string();
+    let handle = std::thread::spawn(move || {
+      let (mut socket, _) = listener.accept().unwrap();
+      let mut request = Vec::new();
+      // The whole request, body included: closing with unread bytes would reset the connection.
+      let complete = |r: &[u8]| {
+        find(r, b"\r\n\r\n").is_some_and(|end| {
+          let head = String::from_utf8_lossy(&r[..end]).to_ascii_lowercase();
+          let len = head.split("\r\n").find_map(|l| l.strip_prefix("content-length: ")).map_or(0, |v| v.parse().unwrap());
+          r.len() >= end + 4 + len
+        })
+      };
+      while !complete(&request) {
+        let mut chunk = [0u8; 1024];
+        let n = socket.read(&mut chunk).unwrap();
+        request.extend_from_slice(&chunk[..n]);
+      }
+      // The client may close once it has what it needs (a chunked body ends before its trailers);
+      // Windows then fails the next write (WSAECONNABORTED), where macOS and Linux still buffer it.
+      for piece in response.chunks(7) {
+        if socket.write_all(piece).and_then(|()| socket.flush()).is_err() {
+          break;
+        }
+      }
+      String::from_utf8(request).unwrap()
+    });
+    (authority, handle)
+  }
+
+  #[test]
+  fn authorities() {
+    assert_eq!(authority("http://127.0.0.1:4173"), Some("127.0.0.1:4173"));
+    assert_eq!(authority("http://localhost:80/"), Some("localhost:80"));
+    assert_eq!(authority("https://127.0.0.1:4173"), None);
+    assert_eq!(authority("http://example.com:80"), None);
+    assert_eq!(authority("http://127.0.0.1"), None);
+    assert_eq!(authority("http://127.0.0.1:0"), None);
+    assert_eq!(authority("http://127.0.0.1:1/x"), None);
+  }
+
+  #[test]
+  fn content_length() {
+    let (authority, server) = serve_once(b"HTTP/1.1 200 OK\r\nContent-Type: text/html\r\nContent-Length: 5\r\n\r\nhello");
+    let headers = vec![("Range".to_string(), "bytes=0-4".to_string()), ("Bad".to_string(), "a\r\nInjected: 1".to_string())];
+    let reply = fetch(&authority, "GET", "/a/b?c=1", &headers, b"").unwrap();
+    assert_eq!(reply.status, 200);
+    assert_eq!(reply.body, b"hello");
+    assert!(reply.headers.contains(&("Content-Type".into(), "text/html".into())));
+    let request = server.join().unwrap();
+    assert!(request.starts_with("GET /a/b?c=1 HTTP/1.1\r\n"), "{request}");
+    assert!(request.contains("\r\nConnection: close\r\n") && request.contains("\r\nRange: bytes=0-4\r\n"));
+    assert!(!request.contains("Injected"));
+  }
+
+  #[test]
+  fn chunked() {
+    let (authority, server) = serve_once(b"HTTP/1.1 200 OK\r\nTransfer-Encoding: chunked\r\n\r\n5;ext=1\r\nhello\r\n7\r\n, world\r\n0\r\nTrailer: x\r\n\r\n");
+    let reply = fetch(&authority, "POST", "/_bun/report_error", &[], b"body").unwrap();
+    assert_eq!(reply.body, b"hello, world");
+    let request = server.join().unwrap();
+    assert!(request.contains("\r\nContent-Length: 4\r\n"));
+  }
+
+  #[test]
+  fn until_close_and_empty_bodies() {
+    let (authority, server) = serve_once(b"HTTP/1.1 404 Not Found\r\n\r\nnot found");
+    let reply = fetch(&authority, "GET", "/x.png", &[], b"").unwrap();
+    assert_eq!((reply.status, reply.body.as_slice()), (404, &b"not found"[..]));
+    server.join().unwrap();
+    let (authority, server) = serve_once(b"HTTP/1.1 200 OK\r\nContent-Length: 5\r\n\r\n");
+    assert_eq!(fetch(&authority, "HEAD", "/", &[], b"").unwrap().body, b"");
+    server.join().unwrap();
+  }
+
+  #[test]
+  fn broken_responses() {
+    let (authority, server) = serve_once(b"HTTP/1.1 200 OK\r\nContent-Length: 10\r\n\r\nshort");
+    assert!(fetch(&authority, "GET", "/", &[], b"").is_err());
+    server.join().unwrap();
+    let (authority, server) = serve_once(b"garbage\r\n\r\n");
+    assert!(fetch(&authority, "GET", "/", &[], b"").is_err());
+    server.join().unwrap();
+    // Nothing listens there any more: an error, which makes the host serve its bundled files.
+    let closed = TcpListener::bind("127.0.0.1:0").unwrap().local_addr().unwrap().to_string();
+    assert!(fetch(&closed, "GET", "/", &[], b"").is_err());
+  }
+}

package/vendor/@akanjs/native/native/desktop/src/dialog_args.rs

@@ -0,0 +1,189 @@
+//! What the native dialogs of every desktop OS share (panels.rs on macOS, win/dialogs.rs,
+//! linux/dialogs.rs): the arguments of `alert.show`, the answers of `alert.show`, `panel.open`,
+//! `panel.save` and `panel.mime`, and the test answers (AKAN_NATIVE_TEST_PANELS). One contract, so the
+//! dialog and file-picker plugins keep one desktop.ts.
+
+use std::sync::OnceLock;
+
+use crate::json::{self, V};
+
+// ───────────────────────── alert.show ─────────────────────────
+
+/// `alert.show { title, message, buttons: [{ title, style }], input?: { text, placeholder } }`
+/// → `{ button, text? }`, the index of the button that ended the dialog. The first button is the
+/// default (Return); a "cancel" button also answers Escape; "destructive" is styled where the OS can.
+pub struct Alert {
+  pub title: String,
+  pub message: String,
+  /// (label, style): style is "default", "cancel" or "destructive".
+  pub buttons: Vec<(String, String)>,
+  /// A prompt's text field: (text, placeholder).
+  pub input: Option<(String, String)>,
+  /// The page's name for this alert, for `alert.dismiss` (the call was cancelled or its page ended).
+  pub tag: Option<String>,
+}
+
+impl Alert {
+  pub fn parse(cmd: &V) -> Alert {
+    let text = |v: Option<&V>, key: &str| v.and_then(|v| v.get(key)).and_then(|v| v.as_str()).unwrap_or("").to_string();
+    let mut buttons: Vec<(String, String)> = Vec::new();
+    if let Some(V::Arr(list)) = cmd.get("buttons") {
+      for b in list {
+        let t = b.get("title").and_then(|v| v.as_str()).unwrap_or("OK").to_string();
+        let s = b.get("style").and_then(|v| v.as_str()).unwrap_or("default").to_string();
+        buttons.push((t, s));
+      }
+    }
+    if buttons.is_empty() {
+      buttons.push(("OK".into(), "default".into()));
+    }
+    let input = cmd.get("input").map(|i| (text(Some(i), "text"), text(Some(i), "placeholder")));
+    let tag = cmd.get("tag").and_then(|v| v.as_str()).map(str::to_string);
+    Alert { title: text(Some(cmd), "title"), message: text(Some(cmd), "message"), buttons, input, tag }
+  }
+
+  /// The bold line and the text under it: the title and the message, or the message alone.
+  #[cfg_attr(target_os = "macos", allow(dead_code))]
+  pub fn lines(&self) -> (&str, &str) {
+    if self.title.is_empty() {
+      (&self.message, "")
+    } else {
+      (&self.title, &self.message)
+    }
+  }
+
+  /// The button Escape (and a window's close button) answers with; None: one must be clicked.
+  #[cfg_attr(target_os = "macos", allow(dead_code))]
+  pub fn cancel(&self) -> Option<usize> {
+    self.buttons.iter().position(|(_, style)| style == "cancel")
+  }
+}
+
+/// `alert.show`'s answer.
+pub fn alert_answer(button: isize, text: Option<&str>) -> String {
+  let text = text.map(|t| format!(r#","text":{}"#, json::quote(t))).unwrap_or_default();
+  format!(r#"{{"button":{button}{text}}}"#)
+}
+
+// ───────────────────────── panel.* ─────────────────────────
+
+/// A file panel that was closed without a choice.
+pub const CANCELLED: &str = r#"{"cancelled":true}"#;
+
+/// `panel.open`'s answer: `{ paths }`, or cancelled when nothing was chosen.
+pub fn open_answer(paths: &[String]) -> String {
+  if paths.is_empty() {
+    return CANCELLED.into();
+  }
+  format!(r#"{{"paths":{}}}"#, json_list(paths))
+}
+
+/// `panel.save`'s answer: `{ path }`, or cancelled.
+pub fn save_answer(path: Option<&str>) -> String {
+  path.map_or(CANCELLED.into(), |path| format!(r#"{{"path":{}}}"#, json::quote(path)))
+}
+
+/// `panel.mime`'s answer: `{ ext: mime }` for the extensions the OS knows.
+pub fn mime_answer(exts: &[String], mime_for_ext: impl Fn(&str) -> Option<String>) -> String {
+  let pairs: Vec<String> = exts.iter().filter_map(|e| mime_for_ext(e).map(|m| format!("{}:{}", json::quote(e), json::quote(&m)))).collect();
+  format!("{{{}}}", pairs.join(","))
+}
+
+pub fn strings(v: Option<&V>) -> Vec<String> {
+  match v {
+    Some(V::Arr(list)) => list.iter().filter_map(|x| x.as_str().map(str::to_string)).collect(),
+    _ => Vec::new(),
+  }
+}
+
+pub fn json_list(items: &[String]) -> String {
+  format!("[{}]", items.iter().map(|s| json::quote(s)).collect::<Vec<_>>().join(","))
+}
+
+// ───────────────────────── tests (dev builds) ─────────────────────────
+
+/// AKAN_NATIVE_TEST_PANELS (dev builds only; `akan-native test` sets "auto" on every desktop OS): every dialog,
+/// file panel and JavaScript alert is shown, then ended by a timer instead of a click, through the
+/// same completion path as a click. "auto" = the first alert button and Cancel for file panels.
+/// A JSON object sets the answer: `{"delay":300,"button":1,"text":"typed","panel":"ok",
+/// "directory":"/tmp/x","name":"out.txt"}`. An open panel for files cannot be answered "ok" this
+/// way (nothing can be selected programmatically); it is cancelled. The timers are per OS: an
+/// NSTimer (panels.rs), a GLib timeout (linux/dialogs.rs), Win32 and TaskDialog timers (win/dialogs.rs).
+pub struct TestAnswers {
+  /// Seconds.
+  pub delay: f64,
+  pub button: isize,
+  pub text: Option<String>,
+  pub panel_ok: bool,
+  pub directory: Option<String>,
+  pub name: Option<String>,
+}
+
+impl TestAnswers {
+  pub fn get(dev: bool) -> Option<&'static TestAnswers> {
+    static ANSWERS: OnceLock<Option<TestAnswers>> = OnceLock::new();
+    if !dev {
+      return None;
+    }
+    ANSWERS.get_or_init(|| Self::parse(&std::env::var("AKAN_NATIVE_TEST_PANELS").ok()?)).as_ref()
+  }
+
+  fn parse(value: &str) -> Option<TestAnswers> {
+    let mut t = TestAnswers { delay: 0.3, button: 0, text: None, panel_ok: false, directory: None, name: None };
+    if value == "auto" {
+      return Some(t);
+    }
+    let v = json::parse(value).ok()?;
+    if let Some(ms) = v.get("delay").and_then(|v| v.as_f64()) {
+      t.delay = ms / 1000.0;
+    }
+    if let Some(b) = v.get("button").and_then(|v| v.as_f64()) {
+      t.button = b as isize;
+    }
+    t.text = v.get("text").and_then(|v| v.as_str()).map(str::to_string);
+    t.panel_ok = v.get("panel").and_then(|v| v.as_str()) == Some("ok");
+    t.directory = v.get("directory").and_then(|v| v.as_str()).map(str::to_string);
+    t.name = v.get("name").and_then(|v| v.as_str()).map(str::to_string);
+    Some(t)
+  }
+
+  /// The delay in whole milliseconds (Win32 and GLib timers).
+  #[cfg_attr(target_os = "macos", allow(dead_code))]
+  pub fn delay_ms(&self) -> u32 {
+    (self.delay * 1000.0).round().clamp(1.0, u32::MAX as f64) as u32
+  }
+}
+
+#[cfg(test)]
+mod tests {
+  use super::*;
+
+  #[test]
+  fn alert_args() {
+    let a = Alert::parse(&json::parse(r#"{"title":"T","message":"M","buttons":[{"title":"Yes"},{"title":"No","style":"cancel"}],"input":{"text":"abc"}}"#).unwrap());
+    assert_eq!((a.lines(), a.cancel(), a.input.clone()), (("T", "M"), Some(1), Some(("abc".into(), "".into()))));
+    let b = Alert::parse(&json::parse(r#"{"message":"only"}"#).unwrap());
+    assert_eq!((b.lines(), b.cancel(), b.buttons.clone()), (("only", ""), None, vec![("OK".into(), "default".into())]));
+    assert_eq!(alert_answer(1, Some("a\"b")), r#"{"button":1,"text":"a\"b"}"#);
+    assert_eq!(alert_answer(-1, None), r#"{"button":-1}"#);
+  }
+
+  #[test]
+  fn panel_answers() {
+    assert_eq!(open_answer(&[]), CANCELLED);
+    assert_eq!(open_answer(&["/a b".into()]), r#"{"paths":["/a b"]}"#);
+    assert_eq!(save_answer(None), CANCELLED);
+    assert_eq!(save_answer(Some("C:\\x.txt")), r#"{"path":"C:\\x.txt"}"#);
+    assert_eq!(mime_answer(&["png".into(), "zzz".into()], |e| (e == "png").then(|| "image/png".into())), r#"{"png":"image/png"}"#);
+  }
+
+  #[test]
+  fn test_answers() {
+    let t = TestAnswers::parse(r#"{"delay":50,"button":1,"text":"hi","panel":"ok","directory":"/tmp","name":"a.txt"}"#).unwrap();
+    assert_eq!((t.delay, t.button, t.text.as_deref(), t.panel_ok, t.directory.as_deref(), t.name.as_deref()), (0.05, 1, Some("hi"), true, Some("/tmp"), Some("a.txt")));
+    assert_eq!(t.delay_ms(), 50);
+    let auto = TestAnswers::parse("auto").unwrap();
+    assert_eq!((auto.button, auto.panel_ok, auto.delay_ms()), (0, false, 300));
+    assert!(TestAnswers::parse("{not json").is_none());
+  }
+}