akanjs 3.0.0-beta.8 → 3.0.0

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

@@ -0,0 +1,190 @@
+//! Displays and the mouse cursor on macOS (screen plugin, plugins.md §5).
+//!   screen.displays → [{"id","name","bounds":{x,y,width,height},"workArea":{…},"scale","primary"}], primary first
+//!   screen.cursor   → {"x","y"}
+//!   screen.watch    → null. From then on the shell sends {"type":"screen","event":"changed"} whenever
+//!                     AppKit posts NSApplicationDidChangeScreenParametersNotification (a display was
+//!                     added, removed or rearranged, or its resolution or scale changed); the plugin
+//!                     host reads screen.displays again. Neither TAO nor Electrobun watches this.
+//!
+//! Coordinates are logical points (CSS px) with the origin at the top-left corner of the primary
+//! display (the one with the menu bar) and y growing down: the space of window.setPosition,
+//! window.getState and window-state (placement.rs). TAO flips Cocoa's bottom-left screen
+//! coordinates against the main display (tao/src/platform_impl/macos/util/mod.rs:87-106).
+//! - bounds: the TAO monitor's position and size (CGDisplayBounds, tao/src/platform_impl/macos/monitor.rs:216-231),
+//!   the same rects lib.rs `monitors` hands to placement.rs.
+//! - workArea: TAO has none. As in Tauri (tauri/crates/tauri-runtime-wry/src/monitor/macos.rs:7-35),
+//!   the NSScreen's visibleFrame (without the menu bar and the Dock) is placed inside bounds by its
+//!   insets from frame; Cocoa's y grows up, so the top inset is frame.maxY − visibleFrame.maxY.
+//!   Electrobun flips both rects against the first NSScreen's height and truncates them to integers
+//!   (electrobun/package/src/native/macos/nativeWrapper.mm:9260-9303); taking bounds from TAO keeps
+//!   one source for display rects, and points stay fractional where macOS has them.
+//! - TAO's ns_screen() hands out a +1 retained pointer (tao/src/platform/macos.rs:376-381). Tauri's
+//!   work_area borrows it and never releases it; here it is taken back with Retained::from_raw.
+//! - TAO names every monitor "Monitor #<model number>"; NSScreen.localizedName is the name System
+//!   Settings shows.
+//! - The cursor: TAO's cursor_position (NSEvent.mouseLocation, flipped the same way) is physical at
+//!   the primary display's scale (util/mod.rs:101-106), so it is divided by that scale again.
+
+use std::{cell::OnceCell, ptr::NonNull};
+
+use block2::RcBlock;
+use objc2::{msg_send, rc::Retained, runtime::AnyObject, MainThreadMarker};
+use objc2_app_kit::{NSApplicationDidChangeScreenParametersNotification, NSScreen};
+use objc2_foundation::{NSNotificationCenter, NSRect};
+use tao::{event_loop::EventLoopWindowTarget, platform::macos::MonitorHandleExtMacOS};
+
+use crate::{json, placement::Rect, push_event};
+
+/// The part of `bounds` (top-left origin, y down) that visibleFrame covers, from an NSScreen's
+/// frame and visibleFrame (Cocoa coordinates, y up).
+pub fn work_area(bounds: Rect, frame: NSRect, visible: NSRect) -> Rect {
+  let left = visible.origin.x - frame.origin.x;
+  let top = (frame.origin.y + frame.size.height) - (visible.origin.y + visible.size.height);
+  Rect { x: bounds.x + left, y: bounds.y + top, width: visible.size.width, height: visible.size.height }
+}
+
+pub struct Display {
+  /// CGDirectDisplayID: stable while the display stays connected.
+  pub id: u32,
+  pub name: String,
+  pub bounds: Rect,
+  pub work_area: Rect,
+  pub scale: f64,
+  pub primary: bool,
+}
+
+fn rect_json(r: Rect) -> String {
+  format!(r#"{{"x":{},"y":{},"width":{},"height":{}}}"#, r.x, r.y, r.width, r.height)
+}
+
+pub fn display_json(d: &Display) -> String {
+  format!(
+    r#"{{"id":{},"name":{},"bounds":{},"workArea":{},"scale":{},"primary":{}}}"#,
+    d.id,
+    json::quote(&d.name),
+    rect_json(d.bounds),
+    rect_json(d.work_area),
+    d.scale,
+    d.primary
+  )
+}
+
+/// The primary display first (it holds the origin), then CGGetActiveDisplayList's order.
+pub fn list_json(mut displays: Vec<Display>) -> String {
+  displays.sort_by_key(|d| !d.primary);
+  format!("[{}]", displays.iter().map(display_json).collect::<Vec<_>>().join(","))
+}
+
+fn displays<T>(target: &EventLoopWindowTarget<T>) -> String {
+  let primary = target.primary_monitor().map(|m| m.native_id());
+  let list = target
+    .available_monitors()
+    .map(|m| {
+      let scale = m.scale_factor();
+      let (p, s) = (m.position().to_logical::<f64>(scale), m.size().to_logical::<f64>(scale));
+      let bounds = Rect { x: p.x, y: p.y, width: s.width, height: s.height };
+      // Safety: a +1 retained NSScreen (see above), released when `screen` drops.
+      let screen = m.ns_screen().and_then(|ptr| unsafe { Retained::from_raw(ptr as *mut NSScreen) });
+      let (work_area, name) = match &screen {
+        Some(screen) => (work_area(bounds, screen.frame(), screen.visibleFrame()), screen.localizedName().to_string()),
+        None => (bounds, m.name().unwrap_or_default()),
+      };
+      Display { id: m.native_id(), name, bounds, work_area, scale, primary: primary == Some(m.native_id()) }
+    })
+    .collect();
+  list_json(list)
+}
+
+/// Mouse positions have fractions of a point; the scale round trip adds float noise past them.
+fn round(v: f64) -> f64 {
+  (v * 1000.0).round() / 1000.0
+}
+
+fn cursor<T>(target: &EventLoopWindowTarget<T>) -> Result<String, String> {
+  let physical = target.cursor_position().map_err(|e| format!("cannot read the cursor position: {e}"))?;
+  let scale = target.primary_monitor().map_or(1.0, |m| m.scale_factor());
+  let p = physical.to_logical::<f64>(scale);
+  Ok(format!(r#"{{"x":{},"y":{}}}"#, round(p.x), round(p.y)))
+}
+
+thread_local! {
+  /// The notification observer (main thread), kept for the rest of the process.
+  static OBSERVER: OnceCell<Retained<AnyObject>> = const { OnceCell::new() };
+}
+
+fn watch() -> Result<String, String> {
+  MainThreadMarker::new().ok_or("screen.watch runs on the main thread")?;
+  OBSERVER.with(|observer| {
+    observer.get_or_init(|| {
+      let block = RcBlock::new(|_note: NonNull<AnyObject>| push_event(r#"{"type":"screen","event":"changed"}"#));
+      let center = NSNotificationCenter::defaultCenter();
+      let none = std::ptr::null::<AnyObject>();
+      // Safety: addObserverForName:object:queue:usingBlock: copies the block; a nil queue runs it
+      // on the posting thread (AppKit posts this on the main thread; push_event is thread-safe).
+      unsafe { msg_send![&center, addObserverForName: NSApplicationDidChangeScreenParametersNotification, object: none, queue: none, usingBlock: &*block] }
+    });
+  });
+  Ok("null".into())
+}
+
+/// screen.* shell ops; None for other ops.
+pub fn shell_op<T>(op: &str, target: &EventLoopWindowTarget<T>) -> Option<Result<String, String>> {
+  let result = match op {
+    "screen.displays" => Ok(displays(target)),
+    "screen.cursor" => cursor(target),
+    "screen.watch" => watch(),
+    _ if op.starts_with("screen.") => Err(format!("unknown op {op}")),
+    _ => return None,
+  };
+  Some(result)
+}
+
+#[cfg(test)]
+mod tests {
+  use super::*;
+  use objc2_foundation::{NSPoint, NSSize};
+
+  fn ns(x: f64, y: f64, width: f64, height: f64) -> NSRect {
+    NSRect::new(NSPoint::new(x, y), NSSize::new(width, height))
+  }
+
+  fn r(x: f64, y: f64, width: f64, height: f64) -> Rect {
+    Rect { x, y, width, height }
+  }
+
+  #[test]
+  fn work_area_below_the_menu_bar_and_above_the_dock() {
+    // A 1512×982 laptop, 33-point menu bar, 70-point Dock at the bottom.
+    let laptop = r(0.0, 0.0, 1512.0, 982.0);
+    assert_eq!(work_area(laptop, ns(0.0, 0.0, 1512.0, 982.0), ns(0.0, 70.0, 1512.0, 879.0)), r(0.0, 33.0, 1512.0, 879.0));
+    // Dock on the left.
+    assert_eq!(work_area(laptop, ns(0.0, 0.0, 1512.0, 982.0), ns(80.0, 0.0, 1432.0, 949.0)), r(80.0, 33.0, 1432.0, 949.0));
+  }
+
+  #[test]
+  fn work_area_on_a_display_above_and_left_of_the_primary() {
+    // CG bounds (-1920, -1080); in Cocoa its frame starts at y = 982 − (−1080 + 1080) = 982.
+    let external = r(-1920.0, -1080.0, 1920.0, 1080.0);
+    let wa = work_area(external, ns(-1920.0, 982.0, 1920.0, 1080.0), ns(-1920.0, 982.0, 1920.0, 1055.0));
+    assert_eq!(wa, r(-1920.0, -1055.0, 1920.0, 1055.0));
+  }
+
+  #[test]
+  fn json_shape() {
+    let d = |id, primary| Display { id, name: "Built-in \"Retina\"".into(), bounds: r(0.0, 0.0, 1512.0, 982.0), work_area: r(0.0, 33.5, 1512.0, 948.5), scale: 2.0, primary };
+    let one = display_json(&d(1, true));
+    assert_eq!(one, r#"{"id":1,"name":"Built-in \"Retina\"","bounds":{"x":0,"y":0,"width":1512,"height":982},"workArea":{"x":0,"y":33.5,"width":1512,"height":948.5},"scale":2,"primary":true}"#);
+    let list = list_json(vec![d(7, false), d(1, true), d(9, false)]);
+    assert!(json::parse(&list).is_ok());
+    let ids: Vec<&str> = list.match_indices(r#""id":"#).map(|(i, _)| &list[i + 5..i + 6]).collect();
+    assert_eq!(ids, ["1", "7", "9"]);
+    assert_eq!(list_json(vec![]), "[]");
+  }
+
+  #[test]
+  fn rounds_float_noise_only() {
+    assert_eq!(round(1512.0000000002), 1512.0);
+    assert_eq!(round(100.5), 100.5);
+    assert_eq!(round(-3.25), -3.25);
+  }
+}

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

@@ -0,0 +1,279 @@
+//! Tray icons on macOS (tray plugin, plugins.md §5): NSStatusItem in the system status bar.
+//!
+//! Know-how from the references (electrobun nativeWrapper.mm createTray/StatusItemTarget, Tauri's
+//! tray API docs in tauri/crates/tauri/src/tray/mod.rs):
+//! - The button sends its action on left and right mouse-up (sendActionOn), so both are clicks.
+//! - A status item with a menu set opens the menu on every click and never sends the action. To
+//!   keep click events and still show the menu, the menu is set only while the click opens it
+//!   (setMenu → performClick → setMenu(nil)).
+//! - Icons are sized to the 18 pt status bar height; template images follow the menu bar's
+//!   light/dark appearance.
+//!
+//! Events: `click { tray, button }` for every left and right click; then, if the tray has a menu,
+//! a right click opens it, and so does a left click unless menuOnLeftClick is false. Menu items
+//! push `menuClick { tray, item }` (menu.rs Source::Tray).
+
+use std::{
+  cell::{Cell, OnceCell, RefCell},
+  collections::HashMap,
+  path::{Path, PathBuf},
+};
+
+use objc2::{
+  define_class, msg_send,
+  rc::Retained,
+  runtime::{NSObject, NSObjectProtocol},
+  sel, AllocAnyThread, MainThreadMarker, MainThreadOnly,
+};
+use objc2_app_kit::{
+  NSApplication, NSEventMask, NSEventModifierFlags, NSEventType, NSImage, NSMenu, NSStatusBar, NSStatusBarButton, NSStatusItem,
+  NSUserInterfaceItemIdentification, NSVariableStatusItemLength,
+};
+use objc2_foundation::{NSData, NSSize, NSString};
+
+use crate::{
+  json::{self, V},
+  menu, push_event,
+  routes::{route, Route},
+};
+
+/// Status bar icon height in points.
+const ICON_HEIGHT: f64 = 18.0;
+
+struct Tray {
+  item: Retained<NSStatusItem>,
+  menu: Option<Retained<NSMenu>>,
+  menu_on_left_click: bool,
+}
+
+thread_local! {
+  static TRAYS: RefCell<HashMap<String, Tray>> = RefCell::new(HashMap::new());
+  static TARGET: OnceCell<Retained<TrayTarget>> = const { OnceCell::new() };
+  /// tray.trigger: the button a synthetic click reports (performClick has no mouse event). A
+  /// synthetic click does not open the tray's menu.
+  static FORCED_BUTTON: Cell<Option<&'static str>> = const { Cell::new(None) };
+}
+
+define_class!(
+  // SAFETY: NSObject has no subclassing requirements; TrayTarget has no Drop.
+  #[unsafe(super(NSObject))]
+  #[thread_kind = MainThreadOnly]
+  #[name = "AkanNativeTrayTarget"]
+  struct TrayTarget;
+
+  impl TrayTarget {
+    #[unsafe(method(akanNativeTrayClicked:))]
+    fn clicked(&self, sender: &NSStatusBarButton) {
+      let Some(id) = sender.identifier().map(|i| i.to_string()) else { return };
+      let forced = FORCED_BUTTON.with(|f| f.take());
+      let button = forced.unwrap_or_else(|| {
+        let event = NSApplication::sharedApplication(self.mtm()).currentEvent();
+        let right = event.is_some_and(|e| {
+          matches!(e.r#type(), NSEventType::RightMouseUp | NSEventType::RightMouseDown) || e.modifierFlags().contains(NSEventModifierFlags::Control)
+        });
+        if right { "right" } else { "left" }
+      });
+      push_event(&format!(r#"{{"type":"tray","event":"click","tray":{},"button":"{button}"}}"#, json::quote(&id)));
+      if forced.is_some() {
+        return; // tray.trigger: no menu, nobody could close it
+      }
+      // Take what the menu needs, then release the registry: the menu runs a nested loop.
+      let open = TRAYS.with(|t| {
+        let trays = t.borrow();
+        let tray = trays.get(&id)?;
+        let menu = tray.menu.clone()?;
+        (button == "right" || tray.menu_on_left_click).then(|| (tray.item.clone(), menu))
+      });
+      if let Some((item, menu)) = open {
+        item.setMenu(Some(&menu));
+        unsafe { sender.performClick(None) };
+        item.setMenu(None);
+      }
+    }
+  }
+
+  unsafe impl NSObjectProtocol for TrayTarget {}
+);
+
+impl TrayTarget {
+  fn new(mtm: MainThreadMarker) -> Retained<Self> {
+    let this = Self::alloc(mtm).set_ivars(());
+    unsafe { msg_send![super(this), init] }
+  }
+}
+
+fn mtm() -> Result<MainThreadMarker, String> {
+  MainThreadMarker::new().ok_or_else(|| "trays are built on the main thread".to_string())
+}
+
+fn string<'a>(cmd: &'a V, key: &str) -> Result<Option<&'a str>, String> {
+  match cmd.get(key) {
+    None | Some(V::Null) => Ok(None),
+    Some(V::Str(s)) => Ok(Some(s)),
+    Some(_) => Err(format!("{key} must be a string")),
+  }
+}
+
+fn flag(cmd: &V, key: &str) -> Result<Option<bool>, String> {
+  match cmd.get(key) {
+    None | Some(V::Null) => Ok(None),
+    Some(V::Bool(b)) => Ok(Some(*b)),
+    Some(_) => Err(format!("{key} must be a boolean")),
+  }
+}
+
+/// An app path ("/tray.png", a public/ asset) or a FileRef URL ("/__akan_native/file/<id>") → a file.
+pub fn resolve_app_file(app_dir: &Path, path: &str) -> Result<PathBuf, String> {
+  let exists = |rel: &str| app_dir.join(rel).is_file();
+  match route(path, exists) {
+    Route::File(id) => crate::FILES.lock().unwrap().get(&id).map(|(p, _)| p.clone()).ok_or_else(|| format!("no file {path}")),
+    // The SPA fallback answers any path without an extension with index.html: not an icon.
+    Route::Asset(rel) if rel != "index.html" || path.trim_start_matches('/') == "index.html" => Ok(app_dir.join(rel)),
+    _ => Err(format!("{path} is not a file of the app (a public/ asset path or a /__akan_native/file URL)")),
+  }
+}
+
+fn image(app_dir: &Path, path: &str, template: bool) -> Result<Retained<NSImage>, String> {
+  let file = resolve_app_file(app_dir, path)?;
+  let bytes = std::fs::read(&file).map_err(|e| format!("cannot read {path}: {e}"))?;
+  let data = NSData::with_bytes(&bytes);
+  let image = NSImage::initWithData(NSImage::alloc(), &data).ok_or_else(|| format!("{path} is not an image"))?;
+  let size = image.size();
+  if size.height > 0.0 {
+    image.setSize(NSSize::new(size.width * ICON_HEIGHT / size.height, ICON_HEIGHT));
+  }
+  image.setTemplate(template);
+  Ok(image)
+}
+
+fn button(item: &NSStatusItem, mtm: MainThreadMarker) -> Result<Retained<NSStatusBarButton>, String> {
+  item.button(mtm).ok_or_else(|| "the status item has no button".to_string())
+}
+
+fn apply(tray: &mut Tray, cmd: &V, app_dir: &Path, mtm: MainThreadMarker, id: &str) -> Result<(), String> {
+  let button = button(&tray.item, mtm)?;
+  if cmd.get("icon").is_some() {
+    match string(cmd, "icon")? {
+      Some(path) => {
+        let image = image(app_dir, path, flag(cmd, "iconAsTemplate")?.unwrap_or(false))?;
+        button.setImage(Some(&image));
+      }
+      None => button.setImage(None),
+    }
+  } else if let Some(template) = flag(cmd, "iconAsTemplate")? {
+    if let Some(image) = button.image() {
+      image.setTemplate(template);
+    }
+  }
+  if cmd.get("title").is_some() {
+    button.setTitle(&NSString::from_str(string(cmd, "title")?.unwrap_or("")));
+  }
+  if cmd.get("tooltip").is_some() {
+    button.setToolTip(string(cmd, "tooltip")?.map(NSString::from_str).as_deref());
+  }
+  match cmd.get("menu") {
+    None => {}
+    Some(V::Null) => tray.menu = None,
+    Some(items) => tray.menu = Some(menu::build(items, &menu::Source::Tray(id.to_string()))?),
+  }
+  if let Some(v) = flag(cmd, "menuOnLeftClick")? {
+    tray.menu_on_left_click = v;
+  }
+  Ok(())
+}
+
+fn tray_json(id: &str, tray: &Tray, mtm: MainThreadMarker) -> String {
+  let button = tray.item.button(mtm);
+  let title = button.as_ref().map(|b| b.title().to_string()).unwrap_or_default();
+  let tooltip = button.as_ref().and_then(|b| b.toolTip()).map(|t| json::quote(&t.to_string())).unwrap_or_else(|| "null".into());
+  let image = button.as_ref().and_then(|b| b.image());
+  format!(
+    r#"{{"id":{},"title":{},"tooltip":{tooltip},"icon":{},"iconAsTemplate":{},"menu":{},"menuOnLeftClick":{}}}"#,
+    json::quote(id),
+    json::quote(&title),
+    image.is_some(),
+    image.is_some_and(|i| i.isTemplate()),
+    tray.menu.is_some(),
+    tray.menu_on_left_click
+  )
+}
+
+/// tray.* shell ops; None for other ops.
+pub fn shell_op(op: &str, cmd: &V, app_dir: &Path) -> Option<Result<String, String>> {
+  if !op.starts_with("tray.") {
+    return None;
+  }
+  Some(run(op, cmd, app_dir))
+}
+
+fn run(op: &str, cmd: &V, app_dir: &Path) -> Result<String, String> {
+  let mtm = mtm()?;
+  if op == "tray.list" {
+    return TRAYS.with(|t| {
+      let trays = t.borrow();
+      let mut ids: Vec<&String> = trays.keys().collect();
+      ids.sort();
+      Ok(format!("[{}]", ids.iter().map(|id| tray_json(id, &trays[*id], mtm)).collect::<Vec<_>>().join(",")))
+    });
+  }
+  let id = string(cmd, "id")?.filter(|s| !s.is_empty()).ok_or("id is required")?.to_string();
+  match op {
+    "tray.create" => {
+      let fresh = TRAYS.with(|t| !t.borrow().contains_key(&id));
+      if fresh {
+        // A tray with neither icon nor title would take no space and could not be clicked.
+        if string(cmd, "icon")?.is_none() && string(cmd, "title")?.is_none_or(str::is_empty) {
+          return Err("a tray needs an icon or a title".into());
+        }
+        let item = NSStatusBar::systemStatusBar().statusItemWithLength(NSVariableStatusItemLength);
+        let button = button(&item, mtm)?;
+        let target = TARGET.with(|t| t.get_or_init(|| TrayTarget::new(mtm)).clone());
+        unsafe {
+          button.setTarget(Some(&target));
+          button.setAction(Some(sel!(akanNativeTrayClicked:)));
+        }
+        button.sendActionOn(NSEventMask::LeftMouseUp | NSEventMask::RightMouseUp);
+        button.setIdentifier(Some(&NSString::from_str(&id)));
+        let mut tray = Tray { item, menu: None, menu_on_left_click: true };
+        if let Err(e) = apply(&mut tray, cmd, app_dir, mtm, &id) {
+          NSStatusBar::systemStatusBar().removeStatusItem(&tray.item);
+          return Err(e);
+        }
+        let json = tray_json(&id, &tray, mtm);
+        TRAYS.with(|t| t.borrow_mut().insert(id, tray));
+        return Ok(json);
+      }
+      // Creating an existing id updates it (a reloaded page creates its tray again).
+      update(&id, cmd, app_dir, mtm)
+    }
+    "tray.update" => update(&id, cmd, app_dir, mtm),
+    "tray.remove" => {
+      if let Some(tray) = TRAYS.with(|t| t.borrow_mut().remove(&id)) {
+        NSStatusBar::systemStatusBar().removeStatusItem(&tray.item);
+      }
+      Ok("null".into())
+    }
+    "tray.trigger" => {
+      let item = TRAYS.with(|t| t.borrow().get(&id).map(|tray| tray.item.clone())).ok_or_else(|| format!("no tray {id}"))?;
+      let which = match string(cmd, "button")? {
+        None | Some("left") => "left",
+        Some("right") => "right",
+        Some(other) => return Err(format!("unknown button {other}")),
+      };
+      FORCED_BUTTON.with(|f| f.set(Some(which)));
+      unsafe { button(&item, mtm)?.performClick(None) };
+      FORCED_BUTTON.with(|f| f.set(None));
+      Ok("null".into())
+    }
+    _ => Err(format!("unknown op {op}")),
+  }
+}
+
+fn update(id: &str, cmd: &V, app_dir: &Path, mtm: MainThreadMarker) -> Result<String, String> {
+  TRAYS.with(|t| {
+    let mut trays = t.borrow_mut();
+    let tray = trays.get_mut(id).ok_or_else(|| format!("no tray {id}"))?;
+    apply(tray, cmd, app_dir, mtm, id)?;
+    Ok(tray_json(id, tray, mtm))
+  })
+}

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

@@ -0,0 +1,126 @@
+//! The shared vectors (packages/core/vectors) against the desktop kernel: routes.rs and
+//! navigation.rs. The TypeScript reference runs the same files in bun test.
+
+use crate::contract;
+use crate::json::{self, V};
+use crate::navigation::{decide_for, Decision};
+use crate::routes::{asset_mime, file_mime, file_ref_sandboxed, id_valid, is_host_path, parse_range, route, RangeAnswer, Route};
+
+fn load(text: &str) -> V {
+  json::parse(text).expect("vector file")
+}
+
+fn arr(v: &V) -> &[V] {
+  match v {
+    V::Arr(a) => a,
+    _ => panic!("not an array"),
+  }
+}
+
+fn text(v: &V) -> String {
+  v.as_str().expect("string").to_string()
+}
+
+#[test]
+fn routes() {
+  let v = load(include_str!("../../../packages/core/vectors/routes.json"));
+  let files: Vec<String> = arr(v.get("files").unwrap()).iter().map(text).collect();
+  let mut failed = Vec::new();
+  for case in arr(v.get("cases").unwrap()) {
+    let c = arr(case);
+    let (path, all) = (text(&c[0]), text(&c[1]) == "all");
+    let got = match route(&path, |rel| all || files.iter().any(|f| f == rel)) {
+      Route::Init => ("init", None),
+      Route::Ipc => ("ipc", None),
+      Route::Hello => ("hello", None),
+      Route::File(id) => ("file", Some(id)),
+      Route::Asset(p) => ("asset", Some(p)),
+      Route::NotFound => ("not-found", None),
+    };
+    let expected = (text(&c[2]), c[3].as_str().map(str::to_string));
+    if (got.0.to_string(), got.1.clone()) != expected {
+      failed.push(format!("{path:?}: {got:?}, expected {expected:?}"));
+    }
+  }
+  for case in arr(v.get("hostPaths").unwrap()) {
+    let c = arr(case);
+    if is_host_path(&text(&c[0])) != c[1].as_bool().unwrap() {
+      failed.push(format!("host path {:?}", text(&c[0])));
+    }
+  }
+  assert!(failed.is_empty(), "{failed:#?}");
+}
+
+#[test]
+fn ranges() {
+  let v = load(include_str!("../../../packages/core/vectors/ranges.json"));
+  let mut failed = Vec::new();
+  for case in arr(v.get("cases").unwrap()) {
+    let c = arr(case);
+    let header = c[0].as_str();
+    let size = c[1].as_f64().unwrap() as u64;
+    let expected: Vec<u64> = arr(&c[2]).iter().map(|n| n.as_f64().unwrap() as u64).collect();
+    let got = match parse_range(header, size) {
+      RangeAnswer::Whole => vec![200],
+      RangeAnswer::Part(a, b) => vec![206, a, b],
+      RangeAnswer::Unsatisfiable => vec![416],
+    };
+    if got != expected {
+      failed.push(format!("{header:?} of {size}: {got:?}, expected {expected:?}"));
+    }
+  }
+  assert!(failed.is_empty(), "{failed:#?}");
+}
+
+#[test]
+fn ids_and_mime() {
+  let v = load(include_str!("../../../packages/core/vectors/ids.json"));
+  let mut failed = Vec::new();
+  for case in arr(v.get("cases").unwrap()) {
+    let c = arr(case);
+    let spec = match text(&c[0]).as_str() {
+      "fileRef" => &contract::ID_FILE_REF,
+      "bundle" => &contract::ID_BUNDLE,
+      "document" => &contract::ID_DOCUMENT,
+      _ => &contract::ID_NAME,
+    };
+    if id_valid(spec, &text(&c[1])) != c[2].as_bool().unwrap() {
+      failed.push(format!("{} {:?}", text(&c[0]), text(&c[1])));
+    }
+  }
+  for case in arr(v.get("mime").unwrap().get("cases").unwrap()) {
+    let c = arr(case);
+    let path = text(&c[0]);
+    if asset_mime(&path) != text(&c[1]) || file_mime(&path) != text(&c[2]) {
+      failed.push(format!("mime {path:?}: {} / {}", asset_mime(&path), file_mime(&path)));
+    }
+  }
+  assert!(failed.is_empty(), "{failed:#?}");
+}
+
+#[test]
+fn navigation() {
+  let v = load(include_str!("../../../packages/core/vectors/navigation.json"));
+  let mut failed = Vec::new();
+  for case in arr(v.get("cases").unwrap()) {
+    let c = arr(case);
+    let url = text(&c[0]);
+    let extra: Vec<String> = arr(&c[2]).iter().map(text).collect();
+    let expected = match text(&c[3]).as_str() {
+      "load" => Decision::Load,
+      "open" => Decision::Open,
+      _ => Decision::Drop,
+    };
+    let got = decide_for(&url, c[1].as_bool().unwrap(), "app://localhost", &extra);
+    if got != expected {
+      failed.push(format!("{url:?} top={:?} extra={extra:?}: {got:?}, expected {expected:?}", c[1].as_bool()));
+    }
+  }
+  for case in arr(v.get("fileRefSandbox").unwrap()) {
+    let c = arr(case);
+    if file_ref_sandboxed(&text(&c[0])) != c[1].as_bool().unwrap() {
+      failed.push(format!("sandbox {:?}", text(&c[0])));
+    }
+  }
+  assert!(failed.is_empty(), "{failed:#?}");
+}