@shipvo/sim 0.1.5 → 0.1.6

package/nav.mjs

@@ -0,0 +1,98 @@
+// Navigation and lifecycle for the simulated phone: back, home, recents, kill. Pure state plus markup.
+// The app sees these as AppState changes: react-native-web reads document.visibilityState, so "background" means hidden.
+
+/** Typed error for a navigation action that cannot run now. */
+export class NavError extends Error { constructor(code, message) { super(message); this.code = code; } }
+
+/** Where the phone is: the app in front ("app"), the home screen ("home") or the app switcher ("recents"). */
+export function createNav() {
+  return { where: "app", kills: 0, log: [] };
+}
+
+const note = (st, name) => { st.log.push({ at: Date.now(), name, source: "simulated" }); };
+
+/** Home: app to background. From recents it also goes home. Returns the AppState the app should see ("background"), or null if nothing changes. */
+export function pressHome(st) {
+  const was = st.where; st.where = "home"; note(st, "press_home");
+  return was === "app" ? "background" : null;
+}
+
+/** Recents: the app switcher card. From the app this backgrounds it. */
+export function openRecents(st) {
+  const was = st.where; st.where = "recents"; note(st, "open_recents");
+  return was === "app" ? "background" : null;
+}
+
+/** Tap the app icon or its recents card. Returns "active" when the app comes back. Throws if the app is already in front. */
+export function resume(st) {
+  if (st.where === "app") throw new NavError("app_in_foreground", "the app is already in front");
+  st.where = "app"; note(st, "resume"); return "active";
+}
+
+/** Swipe the recents card away. The app is killed; the next open is a cold start. Throws unless the switcher is open. */
+export function killApp(st) {
+  if (st.where !== "recents") throw new NavError("recents_not_open", "open the app switcher first (open_recents), then kill_app");
+  st.where = "home"; st.kills++; note(st, "kill_app"); return st;
+}
+
+/** Throws app_not_foreground while the home screen or the app switcher is showing, so no input reaches a backgrounded app. */
+export function assertForeground(st) {
+  if (st.where !== "app") throw new NavError("app_not_foreground", `the phone is on the ${st.where === "home" ? "home screen" : "app switcher"}, so nothing was sent to the app. Open the app first (resume_app).`);
+}
+
+/**
+ * Classify a swipe on the bottom bar or the left edge.
+ * s: { skin, fromEdge: "bottom"|"left"|null, dx, dy, ms } (dy negative is up).
+ * Returns "home", "recents", "switch-left", "switch-right", "back" or null.
+ */
+export function classifySwipe({ skin = "android", fromEdge = null, dx = 0, dy = 0, ms = 0 } = {}) {
+  if (fromEdge === "left" && dx > 60 && Math.abs(dy) < 80) return "back";
+  if (fromEdge !== "bottom") return null;
+  if (dy < -60 && Math.abs(dx) < Math.abs(dy)) return ms >= 400 ? "recents" : "home";
+  if (skin === "ios" && Math.abs(dx) > 60 && Math.abs(dy) < 40) return dx > 0 ? "switch-right" : "switch-left";
+  return null;
+}
+
+/** Runs in the app page. Sets what AppState reads and fires the event. */
+export function setVisibilityInPage(state) {
+  const hidden = state === "background";
+  try {
+    Object.defineProperty(document, "visibilityState", { configurable: true, get: () => (hidden ? "hidden" : "visible") });
+    Object.defineProperty(document, "hidden", { configurable: true, get: () => hidden });
+  } catch {}
+  document.dispatchEvent(new Event("visibilitychange"));
+}
+
+/** Home screen markup: the app icon. Hidden until the phone goes home. */
+export function homeScreenHtml(appName = "App") {
+  const n = String(appName).replace(/[<>&"'\\]/g, "").slice(0, 40) || "App";
+  return `<div class="sf-home" data-part="home-screen" role="region" aria-label="Home screen" hidden><button type="button" class="sf-icon" data-part="app-icon" aria-label="${n}"><b>${n.slice(0, 1).toUpperCase()}</b><span>${n}</span></button></div>`;
+}
+
+/** App switcher markup: one card for the app. Click the card to open it, the close button (or swipe it up) to kill the app. */
+export function recentsHtml(appName = "App") {
+  const n = String(appName).replace(/[<>&"'\\]/g, "").slice(0, 40) || "App";
+  return `<div class="sf-recents" data-part="recents" role="region" aria-label="Recent apps" hidden><div class="sf-card" data-part="recents-card"><button type="button" data-part="recents-open" aria-label="Open ${n}">${n}</button><button type="button" data-part="recents-close" aria-label="Close ${n}">Close</button></div></div>`;
+}
+
+/** The three buttons of Android 3-button navigation. */
+export function navButtonsHtml() {
+  return `<div class="sf-navbtns" data-part="nav-buttons" hidden><button type="button" data-part="nav-back" aria-label="Back">◀</button><button type="button" data-part="nav-home" aria-label="Home">●</button><button type="button" data-part="nav-recents" aria-label="Recents">■</button></div>`;
+}
+
+/** CSS for the home screen and the app switcher. Colours follow the theme (data-theme on the phone body, or on any parent). Dark is the default. */
+export function navScreensCss() {
+  return [
+    `.sf-home,.sf-recents{position:absolute;inset:0;z-index:4;background:linear-gradient(160deg,#1d3557,#0b1320);color:#fff;font-family:system-ui,sans-serif}`,
+    `[data-theme="light"] .sf-home{background:linear-gradient(160deg,#dbe7f5,#f4f7fb);color:#111}`,
+    `.sf-icon{position:absolute;left:28px;top:70px;width:76px;padding:0;border:0;background:none;color:inherit;display:flex;flex-direction:column;align-items:center;gap:6px;font:600 12px system-ui,sans-serif;cursor:pointer}.sf-icon b{display:flex;width:60px;height:60px;border-radius:16px;background:#f4a261;color:#102030;align-items:center;justify-content:center;font-size:28px}`,
+    `.sf-recents{display:flex;align-items:center;justify-content:center;background:#10151cee;color:#fff}[data-theme="light"] .sf-recents{background:#eef1f5ee;color:#111}`,
+    `.sf-card{width:230px;height:420px;border-radius:20px;background:#fff;color:#111;border:1px solid #8884;display:flex;flex-direction:column;justify-content:space-between;align-items:center;padding:14px;box-sizing:border-box;transition:transform .2s}[data-theme="dark"] .sf-card{background:#1c232d;color:#fff}.sf-card button{border:0;border-radius:10px;padding:8px 18px;background:#8883;color:inherit;font:600 14px system-ui,sans-serif;cursor:pointer}`,
+  ].join("");
+}
+
+/** The home screen or switcher as plain markup, shown (not hidden), for a screenshot of a headless session. */
+export function awayScreenHtml(where, appName = "App") {
+  const inner = (where === "home" ? homeScreenHtml(appName) : recentsHtml(appName)).replace(" hidden>", ">");
+  return `<style>${navScreensCss()}</style><div data-theme="dark" style="position:fixed;inset:0;z-index:2147483647">${inner}</div>`;
+}

package/network-profiles.mjs

@@ -0,0 +1,84 @@
+// Network profiles for the simulator. Pure functions: no sim wiring.
+//
+// The numbers below are simulation settings, not measurements of any real
+// network. `latencyMs` is a fixed wait per request, `downKbps` is the
+// throughput used to turn bytes into wait time, and `failureRate` is the share
+// of requests that fail with a network error (0 to 1).
+//
+// `low-end-4g` uses the download rate seen on the Android phone in
+// docs/spike-results.md, section "Results so far": a 1.57 MB bundle in 1.4 to
+// 2.0 s over 4G, which is about 6,300 kbps at the slow end. That section does
+// not record a round-trip time, so its latency is a simulation setting.
+
+export const PROFILES = Object.freeze({
+  online: Object.freeze({ latencyMs: 0, downKbps: Infinity, failureRate: 0 }),
+  offline: Object.freeze({ latencyMs: 0, downKbps: 0, failureRate: 1 }),
+  '2g': Object.freeze({ latencyMs: 800, downKbps: 50, failureRate: 0.02 }),
+  '3g': Object.freeze({ latencyMs: 300, downKbps: 750, failureRate: 0.01 }),
+  'slow-4g': Object.freeze({ latencyMs: 150, downKbps: 1600, failureRate: 0 }),
+  spotty: Object.freeze({ latencyMs: 400, downKbps: 500, failureRate: 0.3 }),
+  'low-end-4g': Object.freeze({ latencyMs: 100, downKbps: 6300, failureRate: 0.005 }),
+});
+
+export const PROFILE_NAMES = Object.freeze(Object.keys(PROFILES));
+
+export function getProfile(name) {
+  if (typeof name !== 'string' || !Object.hasOwn(PROFILES, name)) {
+    const err = new Error(
+      `Unknown network profile "${String(name)}". Use one of: ${PROFILE_NAMES.join(', ')}.`,
+    );
+    err.code = 'unknown_profile';
+    throw err;
+  }
+  return PROFILES[name];
+}
+
+// mulberry32: small seeded PRNG, returns numbers in [0, 1).
+function prng(seed) {
+  let a = seed >>> 0;
+  return () => {
+    a = (a + 0x6d2b79f5) >>> 0;
+    let t = a;
+    t = Math.imul(t ^ (t >>> 15), t | 1);
+    t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
+    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+  };
+}
+
+function bodyBytes(body) {
+  if (body == null) return 0;
+  if (typeof body === 'string') return new TextEncoder().encode(body).length;
+  if (typeof body.byteLength === 'number') return body.byteLength;
+  if (typeof body.size === 'number') return body.size;
+  return 0;
+}
+
+function transferMs(bytes, downKbps) {
+  if (!bytes || !Number.isFinite(downKbps)) return 0;
+  return (bytes * 8) / downKbps;
+}
+
+/**
+ * Wrap `fetchImpl` so requests behave as `profile` describes.
+ * Waits latencyMs + bytes*8/downKbps (request body bytes, then the response's
+ * content-length when present) through `clock.sleep(ms)`. Rejects with a
+ * network TypeError at `failureRate`, drawn from a PRNG seeded by `seed`.
+ */
+export function applyProfile(fetchImpl, profile, { seed = 1, clock } = {}) {
+  if (profile === PROFILES.online) return fetchImpl;
+  const random = prng(seed);
+  const fail = () => new TypeError('fetch failed: network request failed');
+  return async function profiledFetch(input, init) {
+    if (profile.failureRate >= 1) throw fail();
+    // One draw per request keeps the failing set stable for a seed.
+    const failed = random() < profile.failureRate;
+    const reqBytes = bodyBytes(init?.body ?? input?.body);
+    await clock.sleep(profile.latencyMs + transferMs(reqBytes, profile.downKbps));
+    if (failed) throw fail();
+    const res = await fetchImpl(input, init);
+    const len = Number(res?.headers?.get?.('content-length'));
+    const extra = transferMs(Number.isFinite(len) ? len : 0, profile.downKbps);
+    if (extra > 0) await clock.sleep(extra);
+    return res;
+  };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shipvo/sim",
-  "version": "0.1.5",
+  "version": "0.1.6",
   "type": "module",
   "license": "Apache-2.0",
   "description": "The Shipvo simulator: runs a Shipvo app's web build in a phone-sized headless browser and exposes it to agents (accessibility tree, tap/type/scroll, simulated device, mock backend). Used by @shipvo/mcp and `shipvo sim`.",
@@ -10,6 +10,7 @@
   "exports": {
     "./server.mjs": "./server.mjs",
     "./screen-rules.mjs": "./screen-rules.mjs",
+    "./network-profiles.mjs": "./network-profiles.mjs",
     "./frame.mjs": {
       "types": "./frame.d.mts",
       "default": "./frame.mjs"
@@ -22,11 +23,24 @@
     "browser-resolver.mjs",
     "app-name.mjs",
     "frame.mjs",
+    "lumi.mjs",
+    "guide.mjs",
+    "phone-browser.mjs",
+    "browser-app.mjs",
+    "ws-lite.mjs",
     "lifecycle.mjs",
+    "shade.mjs",
+    "shade-actions.mjs",
+    "settings.mjs",
+    "settings-actions.mjs",
+    "nav.mjs",
+    "update.mjs",
     "frame.d.mts",
     "mock-rules.mjs",
     "screen-rules.mjs",
     "push-notification.mjs",
+    "network-profiles.mjs",
+    "apps.mjs",
     "README.md"
   ],
   "peerDependencies": {

package/phone-browser.mjs

@@ -0,0 +1,187 @@
+// A real Chromium page behind the phone: one isolated browser context per phone, a mobile viewport and touch.
+// Pages are untrusted web content. Private hosts are refused unless the caller opts in.
+import { lookup } from "node:dns/promises";
+import { isIP } from "node:net";
+
+export const USER_AGENT_TAG = "ShipvoPhone";
+
+export class BrowserError extends Error {
+  constructor(code, message) { super(message); this.code = code; }
+}
+
+function v4Private(a, b) {
+  return a === 0 || a === 10 || a === 127 || (a === 169 && b === 254) || (a === 172 && b >= 16 && b <= 31) ||
+    (a === 192 && b === 168) || (a === 100 && b >= 64 && b <= 127);
+}
+
+/** True for loopback, link-local, RFC1918, CGNAT, `.local`, `.internal` and `localhost` names or addresses. */
+export function isPrivateHost(host) {
+  let h = String(host).toLowerCase().replace(/^\[|\]$/g, "").replace(/\.$/, "");
+  if (h === "localhost" || h.endsWith(".localhost") || h.endsWith(".local") || h.endsWith(".internal")) return true;
+  const kind = isIP(h);
+  if (kind === 4) { const [a, b] = h.split(".").map(Number); return v4Private(a, b); }
+  if (kind === 6) {
+    // IPv4-mapped (::ffff:a.b.c.d or ::ffff:7f00:1)
+    const m = /^::ffff:(?:(\d+)\.(\d+)\.(\d+)\.(\d+)|([0-9a-f]{1,4}):([0-9a-f]{1,4}))$/.exec(h);
+    if (m) {
+      if (m[1]) return v4Private(Number(m[1]), Number(m[2]));
+      const hi = parseInt(m[5], 16); return v4Private(hi >> 8, hi & 255);
+    }
+    if (h === "::" || h === "::1") return true;
+    const first = parseInt(h.split(":")[0] || "0", 16);
+    return (first & 0xfe00) === 0xfc00 || (first & 0xffc0) === 0xfe80;   // fc00::/7 unique local, fe80::/10 link-local
+  }
+  return false;
+}
+
+/**
+ * Decides if a URL may be loaded. Throws BrowserError host_not_allowed. A public name that resolves to a
+ * private address is refused too, so a DNS record cannot reach the local network.
+ */
+export async function checkUrl(raw, { allowPrivate = false, allowHosts = [] } = {}, resolve = (h) => lookup(h, { all: true })) {
+  let u; try { u = new URL(raw); } catch { throw new BrowserError("bad_url", `not a URL: ${raw}`); }
+  if (u.protocol === "about:" || u.protocol === "data:" || u.protocol === "blob:") return u;
+  if (u.protocol !== "http:" && u.protocol !== "https:") throw new BrowserError("bad_url", `only http and https pages can be opened, not ${u.protocol}`);
+  const host = u.hostname.toLowerCase();
+  if (allowPrivate || allowHosts.map((x) => x.toLowerCase()).includes(host)) return u;
+  const refuse = (why) => new BrowserError("host_not_allowed", `${host} is ${why}, so the phone browser did not open it. Pass allow_private: true, or allow_hosts: ["${host}"], to opt in.`);
+  if (isPrivateHost(host)) throw refuse("a private host");
+  if (!isIP(host.replace(/^\[|\]$/g, ""))) {
+    let addrs = []; try { addrs = await resolve(host); } catch {}
+    if (addrs.some((a) => isPrivateHost(a.address))) throw refuse("a name that points to a private address");
+  }
+  return u;
+}
+
+export class PhoneBrowser {
+  /** @param browser a Playwright Browser. @param opts {allowPrivate, allowHosts, device, resolve} */
+  constructor(browser, opts = {}) {
+    this.browser = browser; this.opts = { allowPrivate: !!opts.allowPrivate, allowHosts: opts.allowHosts ?? [] };
+    this.device = opts.device ?? {}; this.resolve = opts.resolve; this.navigations = [];
+    this.ctx = null; this.page = null; this.pages = []; this.refsFrom = null;
+    this.onDeepLink = opts.onDeepLink ?? null;   // called with a link such as myapp://item/3 that a page tried to open
+    this.cdp = null; this.screencast = null; this.onChange = null;
+  }
+  async #start() {
+    if (this.ctx) { if (!this.page) await this.ctx.newPage(); return; }
+    const d = this.device;
+    this.ctx = await this.browser.newContext({ ...d, userAgent: `${d.userAgent ?? "Mozilla/5.0 (Linux; Android 11; Pixel 5)"} ${USER_AGENT_TAG}`, hasTouch: true, isMobile: true, viewport: d.viewport ?? { width: 393, height: 851 } });
+    // Every request, including redirects and sub-resources, goes through the same host check.
+    await this.ctx.route("**/*", async (route) => {
+      try { await checkUrl(route.request().url(), this.opts, this.resolve); } catch (e) {
+        if (route.request().isNavigationRequest()) this.#log(route.request().url(), false, e.code);
+        return route.abort("blockedbyclient");
+      }
+      return route.continue();
+    });
+    // A link to another app's scheme (myapp://...) cannot load in Chromium. Hand it to the phone, which gives it to the app.
+    await this.ctx.exposeFunction("__shipvoDeepLink", (u) => { if (isDeepLink(u)) { this.#log(String(u), true, undefined, "deep_link"); this.onDeepLink?.(String(u)); } });
+    await this.ctx.addInitScript(() => document.addEventListener("click", (e) => {
+      const a = e.target?.closest?.("a[href]"); if (!a) return;
+      const u = a.href; if (/^(https?|about|data|blob|javascript|file|mailto|tel):/i.test(u) || !/^[a-z][a-z0-9+.-]*:/i.test(u)) return;
+      e.preventDefault(); globalThis.__shipvoDeepLink(u);
+    }, true));
+    this.ctx.on("page", (p) => this.#adopt(p));   // a popup or target=_blank link is a new tab
+    await this.ctx.newPage();
+  }
+  #adopt(p) {
+    if (this.pages.includes(p)) return;
+    this.pages.push(p); this.page = p; this.refsFrom = null;
+    p.on("framenavigated", (f) => { if (f === p.mainFrame()) { this.#log(f.url(), true); this.onChange?.(); } });
+    p.on("close", () => { this.pages = this.pages.filter((x) => x !== p); if (this.page === p) { this.page = this.pages.at(-1) ?? null; this.refsFrom = null; if (this.page) this.#cast(); } this.onChange?.(); });
+    if (this.screencast) this.#cast();
+  }
+  #log(url, ok, code, kind = "browser_navigation") { this.navigations.push({ at: Date.now(), kind, detail: { url, allowed: ok, ...(code ? { code } : {}) }, source: "real", simulated: false }); }
+
+  async open(url) {
+    try { await checkUrl(url, this.opts, this.resolve); } catch (e) { this.#log(String(url), false, e.code); throw e; }
+    await this.#start();
+    try { await this.page.goto(url, { waitUntil: "load", timeout: 20000 }); }
+    catch (e) { throw new BrowserError(/blockedbyclient/i.test(e.message) ? "host_not_allowed" : "navigation_failed", String(e.message).split("\n")[0]); }
+    return this.snapshot();
+  }
+  #need() { if (!this.page) throw new BrowserError("no_page", "no page is open: call browser_open first"); return this.page; }
+  async snapshot() {
+    const page = this.#need();
+    await page.waitForTimeout(100);
+    const tree = await page.locator("body").ariaSnapshot({ mode: "ai" });
+    this.refsFrom = page.url();
+    return { source: "web", untrusted: true, url: page.url(), title: await page.title(), tree };
+  }
+  async #target(ref) {
+    const page = this.#need();
+    const stale = new BrowserError("stale_ref", `stale ref ${ref}: take a new browser_snapshot and use a ref from it.`);
+    if (!/^(?:f\d+)?e\d+$/.test(String(ref)) || this.refsFrom !== page.url()) throw stale;
+    const l = page.locator(`aria-ref=${ref}`);
+    if ((await l.count().catch(() => 0)) !== 1) throw stale;
+    return l;
+  }
+  async click(ref) { const l = await this.#target(ref); await l.click({ timeout: 3000 }); await this.page.waitForLoadState("load").catch(() => {}); return this.snapshot(); }
+  async type(ref, text, enter = false) {
+    const l = await this.#target(ref);
+    await l.fill(String(text ?? ""), { timeout: 3000 }); if (enter) await l.press("Enter");
+    await this.page.waitForLoadState("load").catch(() => {});
+    return this.snapshot();
+  }
+  async back() {
+    const page = this.#need();
+    if (!(await page.goBack({ timeout: 5000 }).catch(() => null))) throw new BrowserError("no_history", "there is no earlier page to go back to");
+    return this.snapshot();
+  }
+  async screenshot() { return this.#need().screenshot({ type: "png" }); }
+  async forward() {
+    const page = this.#need();
+    if (!(await page.goForward({ timeout: 5000 }).catch(() => null))) throw new BrowserError("no_history", "there is no later page to go forward to");
+    return this.snapshot();
+  }
+  async reload() { await this.#need().reload({ timeout: 20000 }).catch((e) => { throw new BrowserError("navigation_failed", String(e.message).split("\n")[0]); }); return this.snapshot(); }
+  async scroll(dy = 400, dx = 0) { await this.#need().mouse.wheel(dx, dy); return this.snapshot(); }
+  /** Waits for text to appear in the page (or to be gone, with gone: true). Resolves with a snapshot. */
+  async waitFor({ text, gone = false, timeoutMs = 5000 } = {}) {
+    const page = this.#need();
+    if (typeof text !== "string" || !text) throw new BrowserError("bad_args", "browser_wait_for needs text");
+    try { await page.waitForFunction(([t, g]) => document.body.innerText.includes(t) !== g, [text, gone], { timeout: Math.min(Math.max(timeoutMs, 100), 30000) }); }
+    catch { throw new BrowserError("timeout", `"${text}" ${gone ? "did not go away" : "did not appear"} within ${timeoutMs} ms`); }
+    return this.snapshot();
+  }
+  async tabs() { return Promise.all(this.pages.map(async (p, index) => ({ index, url: p.url(), title: await p.title().catch(() => ""), active: p === this.page }))); }
+  async selectTab(index) { const p = this.pages[index]; if (!p) throw new BrowserError("no_tab", `no tab ${index}`); this.page = p; this.refsFrom = null; await p.bringToFront(); if (this.screencast) await this.#cast(); this.onChange?.(); }
+  async newTab(url = "about:blank") { await this.#start(); await checkUrl(url, this.opts, this.resolve); const p = await this.ctx.newPage(); await p.goto(url).catch(() => {}); return this.tabs(); }
+  async closeTab(index) {
+    const p = this.pages[index]; if (!p) throw new BrowserError("no_tab", `no tab ${index}`);
+    await p.close(); return this.tabs();
+  }
+
+  // Live view. Chromium pushes JPEG frames (CDP Page.startScreencast); each one is acked once it has been handed on.
+  async #cast() {
+    if (!this.page || !this.ctx) return;
+    try {   // a tab that is closing or not yet attached must not take the server down
+      await this.cdp?.send("Page.stopScreencast").catch(() => {}); this.cdp?.detach().catch(() => {});
+      const c = this.cdp = await this.ctx.newCDPSession(this.page);
+      c.on("Page.screencastFrame", (f) => { c.send("Page.screencastFrameAck", { sessionId: f.sessionId }).catch(() => {}); this.screencast?.({ data: f.data, width: f.metadata.deviceWidth, height: f.metadata.deviceHeight }); });
+      await c.send("Page.startScreencast", { format: "jpeg", quality: 60, maxWidth: 400, maxHeight: 860, everyNthFrame: 1 });
+    } catch {}
+  }
+  async startScreencast(onFrame) { await this.#need(); this.screencast = onFrame; await this.#cast(); }
+  async stopScreencast() { this.screencast = null; await this.cdp?.send("Page.stopScreencast").catch(() => {}); }
+  /** Input as a finger and keyboard would give it, in CSS px of the viewport. */
+  async input(m) {
+    this.#need(); const c = this.cdp ?? (this.cdp = await this.ctx.newCDPSession(this.page));
+    const touch = (type, x, y) => c.send("Input.dispatchTouchEvent", { type, touchPoints: type === "touchEnd" ? [] : [{ x, y }] });
+    const num = (...v) => { if (!v.every((n) => Number.isFinite(n))) throw new BrowserError("bad_args", "coordinates must be numbers"); };
+    if (m.type === "tap") { num(m.x, m.y); await touch("touchStart", m.x, m.y); await touch("touchEnd"); }
+    else if (m.type === "swipe") {
+      num(m.x1, m.y1, m.x2, m.y2); await touch("touchStart", m.x1, m.y1);
+      for (let i = 1; i <= 8; i++) await touch("touchMove", m.x1 + ((m.x2 - m.x1) * i) / 8, m.y1 + ((m.y2 - m.y1) * i) / 8);
+      await touch("touchEnd");
+    }
+    else if (m.type === "text") await c.send("Input.insertText", { text: String(m.text ?? "").slice(0, 2000) });
+    else if (m.type === "key") { const key = String(m.key); const code = { Enter: 13, Backspace: 8, Tab: 9 }[key]; if (!code) throw new BrowserError("bad_args", `unsupported key ${key}`);
+      for (const type of ["keyDown", "keyUp"]) await c.send("Input.dispatchKeyEvent", { type, key, windowsVirtualKeyCode: code, ...(key === "Enter" && type === "keyDown" ? { text: "\r" } : {}) }); }
+    else throw new BrowserError("bad_args", `unknown input ${m.type}`);
+  }
+  async close() { this.screencast = null; await this.ctx?.close().catch(() => {}); this.ctx = this.page = this.cdp = null; this.pages = []; }
+}
+
+/** True for a link into another app: a scheme that is not a web page scheme. */
+export function isDeepLink(u) { return /^[a-z][a-z0-9+.-]*:/i.test(String(u)) && !/^(https?|about|data|blob|javascript|file|ftp|view-source|chrome|devtools|mailto|tel):/i.test(String(u)); }